1 // Copyright (c) 1997-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 <s32std.h>

    17 #include <f32file.h>

    18 

    19 #include <cntdef.h>

    20 #include <cntitem.h>

    21 #include <cntfield.h>

    22 #include <cntfldst.h>

    23 #include <cntdb.h>

    24 

    25 #include "CNTSTD.H"

    26 #include "CNTPROF.H"

    27 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    28 #include "cntfieldheader.h"

    29 #endif

    30 

    31 

    32 EXPORT_C CContactItemFieldSet* CContactItemFieldSet::NewL()

    33 /** Allocates and constructs a new field set.

    34 

    35 @return Pointer to the newly created field set. */

    36 	{ // static 

    37 	CContactItemFieldSet* self=CContactItemFieldSet::NewLC();

    38 	CleanupStack::Pop(); // self

    39 	return self;

    40 	}

    41 

    42 EXPORT_C CContactItemFieldSet* CContactItemFieldSet::NewLC()

    43 /** Allocates and constructs a new field set.

    44 

    45 @return Pointer to the newly created field set. This is left on the cleanup 

    46 stack. */

    47 	{ // static

    48 	CContactItemFieldSet* self=new(ELeave) CContactItemFieldSet;

    49 	CleanupStack::PushL(self);

    50 	self->ConstructL();

    51 	return self;

    52 	}

    53 

    54 EXPORT_C CContactItemFieldSet::~CContactItemFieldSet()

    55 /** The destructor frees all resources owned by the field set, prior to its destruction. */

    56 	{

    57 	if (iFields)

    58 		{

    59 		iFields->ResetAndDestroy();

    60 		delete iFields;

    61 		}

    62 	}

    63 

    64 CContactItemFieldSet::CContactItemFieldSet()

    65 	{}

    66 

    67 void CContactItemFieldSet::ConstructL()

    68 	{

    69 	iFields=new(ELeave) CArrayPtrFlat<CContactItemField>(4);

    70 	}

    71 

    72 const CContactItemField* CContactItemFieldSet::FindById(TInt aId) const

    73 	{

    74 	const CContactItemField* field=NULL;

    75 	for (TInt ii=0;ii<iFields->Count();ii++)

    76 		{

    77 		field=iFields->At(ii);

    78 		if (field->Id()==aId)

    79 			return(field);

    80 		}

    81 	return(NULL);

    82 	}

    83 

    84 EXPORT_C TInt CContactItemFieldSet::FindNext(TFieldType aFieldType,TInt aStartPos) const

    85 /** Finds the next field in the field set with the specified field type.

    86 

    87 @param aFieldType The field type of interest.

    88 @param aStartPos The index within the field set array at which to start the 

    89 search. By default set to KContactFieldSetSearchAll, to find the first field. 

    90 Must be a valid array index, or the function raises a panic.

    91 @return If found, the index of the field within the field set, or KErrNotFound 

    92 if not found. */

    93 	{

    94 	return(FindNext(aFieldType,KUidContactFieldMatchAll,aStartPos));

    95 	}

    96 

    97 EXPORT_C TInt CContactItemFieldSet::FindNext(TFieldType aFieldType,TUid aMapping,TInt aStartPos) const

    98 /** Finds the next field in the field set containing both the content type mapping 

    99 and the field type specified.

   100 

   101 @param aFieldType The field type of interest.

   102 @param aMapping The content type mapping of interest.

   103 @param aStartPos The index within the array at which to start the search. By 

   104 default set to KContactFieldSetSearchAll, to find the first field. Must be 

   105 a valid array index, or the function raises a panic.

   106 @return If found, the index of the field within the field set, or KErrNotFound 

   107 if not found. */

   108 	{

   109 	const TInt count=iFields->Count();

   110 	TInt pos=(aStartPos==KContactFieldSetSearchAll? 0 : aStartPos);

   111 	TInt ii=KErrNotFound;

   112 	for (ii=pos;ii<count;ii++)

   113 		{

   114 		const CContentType& contentType=(*iFields)[ii]->ContentType();

   115 		if (contentType.Mapping()==KUidContactFieldMatchAll || aMapping==KUidContactFieldMatchAll || contentType.Mapping()==aMapping)

   116 			if (aFieldType==KUidContactFieldMatchAll || contentType.ContainsFieldType(aFieldType))

   117 				return ii;

   118 		}

   119 	return KErrNotFound;

   120 	}

   121 

   122 void CContactItemFieldSet::SetFieldId(CContactItemField& aField)

   123 	{

   124 	TInt id=iFields->Count();

   125 	TInt count=iFields->Count();

   126 	FOREVER

   127 		{

   128 		TInt loop=0;

   129 		for(;loop<count;loop++)

   130 			if ((*iFields)[loop]->Id()==id)

   131 				break;

   132 		if (loop==count)

   133 			{

   134 			aField.SetId(id);

   135 			break;

   136 			}

   137 		id++;

   138 		}

   139 	}

   140 

   141 EXPORT_C CContactItemFieldSet& CContactItemFieldSet::AddL(CContactItemField& aField)

   142 /** Appends a field to the field set. The field set takes ownership of the field.

   143 

   144 @param aField Reference to the field to add to the field set. The field's 

   145 ID is updated.

   146 @return Reference to the current field set. */

   147 	{

   148 	__ASSERT_DEBUG(&aField!=NULL,Panic(ECntPanicNullPointer));

   149 	SetFieldId(aField);

   150 	iFields->AppendL(&aField);

   151 	return (*this);

   152 	}

   153 

   154 EXPORT_C void CContactItemFieldSet::Remove(TInt aIndex)

   155 /** Removes a field from the field set.

   156 

   157 @param aIndex The index of the field to delete. Must be a valid index within 

   158 the field set or the function raises a panic. */

   159 	{

   160 	delete (*iFields)[aIndex];

   161 	iFields->Delete(aIndex);

   162 	}

   163 

   164 EXPORT_C void CContactItemFieldSet::Move(TInt aFrom, TInt aTo)

   165 /** Changes a field's position within the field set.

   166 

   167 Both indexes specified must be valid (i.e. between zero and Count()-1 inclusive), 

   168 or the function raises a panic.

   169 

   170 @param aFrom The index of the field to move.

   171 @param aTo The index of the new position within the field set. */

   172 	{

   173 	CContactItemField *moveField=(*iFields)[aFrom];

   174 	if (aFrom<aTo)

   175 		{

   176 		for(TInt loop=aFrom;loop<aTo;loop++)

   177 			(*iFields)[loop]=(*iFields)[loop+1];

   178 		}

   179 	else

   180 		{

   181 		for(TInt loop=aFrom;loop>aTo;loop--)

   182 			(*iFields)[loop]=(*iFields)[loop-1];

   183 		}

   184 	(*iFields)[aTo]=moveField;

   185 	}

   186 

   187 EXPORT_C void CContactItemFieldSet::InsertL(TInt aIndex,CContactItemField& aField)

   188 /** Inserts a field into the field set.

   189 

   190 @param aIndex The position in the field set at which to insert the field. 

   191 If equal to or greater than the number of elements in the field set, the field 

   192 is appended to the field set.

   193 @param aField Reference to the field to add to the field set. The field's ID 

   194 is updated. */

   195 	{

   196 	__ASSERT_DEBUG(&aField!=NULL,Panic(ECntPanicNullPointer));

   197 	SetFieldId(aField);

   198 	TInt count=iFields->Count();

   199 	if (count>aIndex)

   200 		iFields->InsertL(aIndex,&aField);

   201 	else

   202 		iFields->AppendL(&aField);

   203 	}

   204 

   205 /**

   206 

   207 Find and return the index of the best matched template field. The method uses a matching algorithm which compares the content type of the template fields with that of the incoming contact item.

   208 

   209 Matching Algorithm Steps:

   210 ========================

   211 

   212 The algorithm is based on a scoring mechanism counting 'hits' and 'misses' in order to find the best possible field match within the fieldset of the template.

   213 

   214 1. Loop through all the contact item fields of the template.

   215 

   216 For each template field:

   217 

   218 2. Perform a strict, or exact, match between the vCard mappings of the template field and the field to be matched.

   219 3. If the vCard mappings match exactly, compare User Flags values and amend the overall score accordingly.

   220 4. Loop through all the field types (TFieldType array) stored as part of the content type of the field to be matched.

   221 

   222 For each field type of the field to be matched:

   223 

   224 5. Loop through the field types of the iterated template field to find a field type match. Amend the 'hits' and 'misses' count accordingly.

   225 6. Calculate the overall score weighing the 'hits' and 'misses' count.

   226 7. Amend the overall score count in order to account for special cases (e.g. user defined fields)

   227 8. Compare the overall score with the best score. If score > current best score, replace the 'bestScore' count and 'bestMatch' index.

   228 

   229 9. Return the 'bestMatch' field index of the template field.

   230 

   231 @param aContentType		The content type of the field to find a match for.

   232 @param aUserFlags		The user flags of the field to find a match for.

   233 @param aExactMatch		Boolean to indicate an exact field match within the template.

   234 

   235 @return The index of the best matched template field, if found, else KErrNotFound.

   236 

   237 */

   238 

   239 TInt CContactItemFieldSet::MatchTemplateField(const CContentType& aContentType,TUint aUserFlags,TBool &aExactMatch) const

   240 	{

   241 	const TInt count=Count();

   242 	TInt bestScore=5;	// Has to be better than one or fail the match

   243 	TInt bestMatch=KErrNotFound;

   244 	TInt contentTypeCount=aContentType.FieldTypeCount();

   245 

   246 	// Loop through all the template fields to find the best field match

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

   248 		{

   249 		const CContactItemField& field=*(*iFields)[ii];

   250 		const CContentType &fieldContentType=field.ContentType();

   251 

   252 		// Strict matching executed on the vCard mappings in order to avoid matching non-related fields e.g. Fax and Address fields.

   253 		// NOTE: The vCard mappings are intended to match the vCard PROPERTY (e.g. TEL in TEL;HOME;FAX:01234), wherein the field is to be exported into a vCard.

   254 		if (fieldContentType.Mapping()==aContentType.Mapping())

   255 			{

   256 			TInt score=fieldContentType.Mapping()==KUidContactFieldVCardMapUnusedN?0:100;

   257 			TInt hits=0;

   258 			TInt misses=0;

   259 

   260 			// The criteria for an exact match of the User Flags has been changed

   261 			// from a mandatory requirement to a preference within the scoring system

   262 			if (aUserFlags==0 || field.UserFlags()==aUserFlags)

   263 				{

   264 				++score;

   265 				}

   266 

   267 			// NOTE: A common Field Types array stores BOTH the Field Type in addition to the Extra Mappings

   268 			//

   269 			// A. Field Type     = Contact item field's type defined internally

   270 			// B. Extra Mappings = Refer to the vCard PARAMETERS (e.g. FAX and HOME in TEL;HOME;FAX:01234)

   271 			//

   272 			// The Field Type and Extra Mappings are defined as part of the FIELD structure within the template (cntmodel.rss)

   273 			//

   274 			// C. Field Types array = A (Field Type, first element) + B (Extra Mappings, all elements after the first element)

   275 			

   276 			// Loop through the incoming contact item field's Field Types (C)

   277 			for(TInt contactFieldTypeLoop=0; contactFieldTypeLoop < contentTypeCount; ++contactFieldTypeLoop)

   278 				{

   279 				// Match EACH of the incoming contact item field's Field Types (C) within the template field's Field Types (C)

   280 				if(ContainsFieldTypeMapping(fieldContentType,aContentType.FieldType(contactFieldTypeLoop)))

   281 					{

   282 					++hits;

   283 					}

   284 				else

   285 					{

   286 					++misses;

   287 					}				

   288 				}

   289 

   290 			

   291 			misses+=fieldContentType.FieldTypeCount()-hits;

   292 			score+=10*hits-5*misses;

   293 			

   294 			if (!field.UserAddedField())

   295 				{

   296 				score+=3;	// Non-user added field takes priority over user added fields

   297 				}

   298 			

   299 			if (fieldContentType.ContainsFieldType(KUidContactFieldVCardMapWORK))

   300 				{

   301 				score+=1;	// Work fields take priority over home fields

   302 				}

   303 				

   304 			if (score>bestScore)

   305 				{

   306 				aExactMatch=(misses==0);

   307 				bestScore=score;

   308 				bestMatch=ii;

   309 				}

   310 			}

   311 		}

   312 	return bestMatch;

   313 	}

   314 

   315 // Attempt to find a contact item field type within the Field Types array (Field Types array = Field Type (internal) + Extra Mappings) of the base contact item.

   316 // NOTE: This function does not include the base contact item field's vCard mapping whilst looking for the Field Type

   317 TBool CContactItemFieldSet::ContainsFieldTypeMapping(const CContentType& aBaseFieldContentType, const TFieldType& aContactFieldType) const

   318 	{

   319 	// Loop through all the template Field Types to attempt to match the individual Field Type of the incoming contact item's field

   320 	for(TInt templateFieldTypeLoop=0; templateFieldTypeLoop < aBaseFieldContentType.FieldTypeCount(); ++templateFieldTypeLoop)

   321 		{

   322 		if(aBaseFieldContentType.FieldType(templateFieldTypeLoop) == aContactFieldType)

   323 			{

   324 			return ETrue;

   325 			}

   326 		}

   327 	return EFalse;

   328 	}

   329 

   330 /**

   331 @internalTechnology 

   332 */

   333 EXPORT_C TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore,const CContactItem* aTemplate,RWriteStream& aTextStream,CStreamStore& aBlobStore,CContactTables* aTables)

   334 	{

   335 	const TInt count=Count();

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

   337 		{

   338 		CContactItemField* field=(*iFields)[ii];

   339 		if (aTemplate)

   340 			{

   341 			const CContactItemFieldSet& templateFields = aTemplate->CardFields();

   342 			field->UpdateFieldFlags(templateFields);

   343 			}

   344 		else

   345 			{

   346 			field->SetLabelUnspecified(EFalse);

   347 			}

   348 		}

   349 	return StoreL(aStore,aTextStream,aBlobStore,aTables);

   350 	}

   351 

   352 EXPORT_C TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore,RWriteStream& aTextStream,CStreamStore& aBlobStore)

   353 /** Stores the field set to a stream store.

   354 @internalTechnology

   355 @param aStore Stream store to which the field set is written.

   356 @param aTextStream Stream to which data stored in text fields (with a storage 

   357 type of KStorageTypeText) is written.

   358 @param aBlobStore Stream store to which data stored in non-text fields is written.

   359 @return The ID of the stream store. */

   360 	{

   361 	//Overloaded to maintain SC.

   362 	return (StoreL(aStore,aTextStream,aBlobStore,NULL));

   363 	}

   364 	

   365 /* 

   366 Store all contact fields in this field set into given header and data stores.

   367 

   368 In SQLite data schema, contact field data is saved in the stream store (aStore) as:

   369 

   370 contact-item-field-set = number-of-fields *field		

   371     ; <field> repeated <number-of-fields> times

   372  

   373 field = contact-field-atts [ stream-id ] field-id template-id [ hint-value *mapping *additional-field ] [ label-length [ label ] ]

   374 	; 1st optional part is there if the contact field is NOT stored as text.

   375 	; if the field uses the template's content type, the 2nd optional part is left out

   376 	; <additional-field> is repeated a number of times as specified by <number-of-additional-fields> inside hint-value

   377 	; mapping is there if vcard-mapping-id-mask in hint-valute is set

   378 	; 3rd optional part is there if there is a label which overrides the template label. <label> is left out if <label-length> is zero

   379 

   380 contact-field-atts = attrib-store

   381 

   382 attrib-store =	attribs field-type extended-attribs				

   383 	; 32 bits -- order is endian-dependent

   384 

   385 attribs	= 14BIT						

   386 	; 14 bitfields: Hidden, ReadOnly, Synchronize, Disabled, 

   387 	;	4 user-defined fields, OverRidesLabel, UsesTemplateData, 

   388 	;	UserAddedField, Template, LabelUnspecified and Deleted (in that order), 

   389 	

   390 field-type = 4BIT						; 0..16

   391 extended-attribs = 8BIT

   392     ; 8 bitfields: Private, SpeedDial, EUserDefinedFilter and 

   393     ; EUserDefinedFilter1-4(in that order)		

   394 

   395 hint-value = vcard-mapping-id-mask *number-of-additional-fields *hint-value

   396     ; 32 bits -- order is endian-dependent

   397     ; hint-value and number-of-additional-fields is there if UsesTemplateData is NOT set in attribs

   398 vcard-mapping-id-mask= 1BIT   

   399 number-of-additional-fields = 7BIT

   400 hint-value = 24BIT

   401 

   402 mapping = Int32

   403 field-id =UInt32

   404 template-id =UInt32

   405 stream-id =UInt32

   406 label-length = Int32

   407 label = Descriptor

   408 

   409 @param aStore the stream store for data header

   410 @param aTextStream the stream to store text data

   411 @param aBlobStore  the stream store for blob data

   412 

   413 @return stream id the data header stored in aStore.

   414 */

   415 

   416 TStreamId CContactItemFieldSet::StoreL(CStreamStore& aStore, RWriteStream& aTextStream, CStreamStore& aBlobStore, CContactTables* /*aTables*/)

   417 	{

   418 	CArrayFix<TInt>* fullFields = new(ELeave) CArrayFixFlat<TInt>(4);

   419 	CleanupStack::PushL(fullFields);  // push here to make cleanup easier

   420 	

   421 	CArrayFix<TFieldHeader>* fieldHeader = new(ELeave) CArrayFixFlat<TFieldHeader>(5);

   422 	CleanupStack::PushL(fieldHeader);

   423 	

   424 	TInt textFieldIndex = 0;

   425 

   426 	const TInt KCount = Count();

   427 	for(TInt ii = 0; ii < KCount; ++ii)

   428 	    {  

   429 	    // find all non-empty fields

   430 		CContactItemField* field = (*iFields)[ii];

   431 

   432 		if (!field->IsDeleted()) 

   433 			{

   434 			// only save non-empty content in the blob

   435 			fullFields->AppendL(ii); // save for later

   436 			

   437 			//Add the text storage field data from the field to the blob

   438 			fieldHeader->AppendL(field->StoreL(aTextStream, aBlobStore, textFieldIndex));

   439 			if (field->StorageType() == KStorageTypeText)

   440 			    {

   441 				++textFieldIndex;

   442 			    }

   443 			}

   444 		}

   445 

   446 	// adjust the hint values for non-empty fields only

   447 	RStoreWriteStream rootStream;

   448 	TStreamId streamId = rootStream.CreateLC(aStore);

   449 	

   450 	const TInt KHintCount = fieldHeader->Count();

   451 	rootStream << TCardinality(KHintCount);

   452 	

   453 	for (TInt ii = 0; ii < KHintCount; ++ii)

   454 		{

   455 		CContactItemField* field=(*iFields)[(*fullFields)[ii]];

   456 		field->PopulateStoreL(rootStream, ii, *fieldHeader);

   457 		}	

   458 		

   459 	rootStream.CommitL();

   460 	aStore.CommitL();

   461 		

   462 	CleanupStack::PopAndDestroy(3, fullFields); // rootStream, fieldHeader, fullFields

   463 	return streamId;

   464 	}

   465 	

   466 HBufC* CContactItemFieldSet::LoadTextStreamLC(RReadStream& aStream)

   467 	{

   468 	TInt maxlen=0;

   469 	if (aStream.Source())

   470 		maxlen=aStream.Source()->SizeL(); 

   471 	maxlen=maxlen/2;

   472 	HBufC* textStream=HBufC::NewLC(maxlen);

   473 	if (maxlen)

   474 		{

   475 		TPtr des=textStream->Des();

   476 		aStream.ReadL(des,maxlen);

   477 		}

   478 	return(textStream);

   479 	}

   480 

   481 void CContactItemFieldSet::RestoreAndAddTemplateL(CStreamStore& aStore, TStreamId aId,CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,

   482 									const CContactItem* aTemplate,RReadStream& aReadStream,CContactTables* aContactsTable,RArray<TInt>* aEmailIdArray)

   483 	{

   484 	if (aViewDef.Use()==CContactItemViewDef::EIncludeFields && aViewDef.Count()==0)

   485 		return; // zzz temp kludge, fix this properly

   486 	if (aTemplate)

   487 		{

   488 		CContactItemFieldSet *original=CContactItemFieldSet::NewLC();

   489 		original->RestoreL(aStore,aId,aBlobStore,aViewDef,aTemplate,aReadStream,aContactsTable,aEmailIdArray);

   490 		TInt count=original->Count();

   491 		for(TInt loop=0;loop<count;loop++)

   492 			{

   493 			CContactItemField* additionalField=CContactItemField::NewLC((*original)[loop]);

   494 			AddL(*additionalField);

   495 			CleanupStack::Pop(); // additionalField

   496 			}

   497 		CleanupStack::PopAndDestroy(); // original

   498 		}

   499 	else

   500 		RestoreL(aStore,aId,aBlobStore,aViewDef,NULL,aReadStream,aContactsTable,aEmailIdArray);

   501 	}

   502 

   503 /** 

   504 Restores the field set using a view definition.

   505 @internalTechnology

   506 @param aStore Store from which to restore the field set.

   507 @param anId The root stream ID of aStore.

   508 @param aBlobStore If specified, the stream store from which data stored in 

   509 non-text fields is read.

   510 @param aViewDef The view definition to use.

   511 @param aReadStream Read stream from which data stored in text fields (with 

   512 a storage type of KStorageTypeText) is read. 

   513 */

   514 EXPORT_C void CContactItemFieldSet::RestoreL(CStreamStore& aStore, TStreamId anId,CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,RReadStream& aReadStream)

   515     {

   516 	//THIS FUNCTION IS TO BE REMOVED....

   517 	RestoreL(aStore,anId,aBlobStore,aViewDef,NULL,aReadStream,NULL,NULL);

   518 	}

   519 

   520 

   521 void CContactItemFieldSet::RestoreL(CStreamStore& aStore, TStreamId anId, CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,const CContactItem* aTemplate,RReadStream& aReadStream,CContactTables* /*aContactsTable*/, RArray<TInt>* /*aEmailIdArray*/)

   522 	// Overloaded looks in the Contacts Table for cetain fields.

   523 	{

   524 	const TBool includeFields=aViewDef.Use()==CContactItemViewDef::EIncludeFields;

   525 	if (includeFields && aViewDef.Count()==0)

   526 		return;

   527 	RStoreReadStream stream;

   528 	stream.OpenLC(aStore,anId);

   529 	TCardinality fieldCount;

   530 	stream>>fieldCount;

   531 	TStreamId nestedId;

   532 	TInt textFieldIndex=0;

   533 	HBufC *textStream=CContactItemFieldSet::LoadTextStreamLC(aReadStream);

   534 

   535 	for (TInt ii=0; ii<fieldCount; ++ii)

   536 		{

   537 		CContactItemField* field=CContactItemField::NewLC();

   538 		nestedId=field->RestoreFieldTypesL(stream,aTemplate?&(aTemplate->CardFields()):NULL);

   539 		const CContentType &type=field->ContentType();

   540 		TBool fieldDefined=aViewDef.MatchesAll() || (aViewDef.Find(type)!=KErrNotFound);

   541 		if (!((fieldDefined&&includeFields) || (!fieldDefined&&!includeFields)) || 

   542 			(field->IsHidden() && aViewDef.Mode()==CContactItemViewDef::EMaskHiddenFields)

   543 			)

   544 			{

   545 			if (field->StorageType()==KStorageTypeText)  

   546 				textFieldIndex++;

   547 			CleanupStack::PopAndDestroy(); // field

   548 			}

   549 		else

   550 			{

   551 			if (field->StorageType()==KStorageTypeText)  // restore from text stream

   552 				{

   553 				// restore text from contacts table.

   554 				TPtrC textPtr;

   555 				if(textPtr.Length())

   556 					{

   557 					field->TextStorage()->SetTextL(textPtr);

   558 					}

   559 				else

   560 					{

   561 					field->RestoreTextL(textStream,textFieldIndex);

   562 					}

   563 				iFields->AppendL(field);

   564 				CleanupStack::Pop(); // field

   565 				textFieldIndex++;

   566 				}

   567 			else if (aBlobStore)

   568 				{

   569 				field->RestoreDataL(*aBlobStore, nestedId);

   570 				iFields->AppendL(field);

   571 				CleanupStack::Pop(); // field

   572 				}

   573 			else

   574 				{

   575 				CleanupStack::PopAndDestroy(); // field

   576 				}

   577 			}

   578 		}

   579 	CleanupStack::PopAndDestroy(2); // textStream,stream

   580     }

   581 

   582 /**

   583 The overload that doesn't use dangerous CContactItemFieldSet::LoadTextStreamLC(aReadStream) method.

   584 LoadTextStreamLC relies on the stream to know its size, but now all types of streams support this functionality.

   585 In order to avoid calling LoadTextStreamLC, aTextBuf is already loaded in HBufC in the caller function.

   586 The caller function had access to the table and can use ColLength() API to get the lebgth of the field.

   587 @internalTechnology

   588 */

   589 EXPORT_C void CContactItemFieldSet::RestoreL(CStreamStore& aStore, TStreamId anId, CStreamStore* aBlobStore,const CContactItemViewDef& aViewDef,const CContactItem* aTemplate,HBufC* aTextBuf)

   590 	{

   591 	const TBool includeFields=aViewDef.Use()==CContactItemViewDef::EIncludeFields;

   592 	if (includeFields && aViewDef.Count()==0)

   593 		return;

   594 	RStoreReadStream stream;

   595 	stream.OpenLC(aStore,anId);

   596 	TCardinality fieldCount;

   597 	stream>>fieldCount;

   598 	TStreamId nestedId;

   599 	TInt textFieldIndex=0;

   600 

   601 	for (TInt ii=0;ii<fieldCount;ii++)

   602 		{

   603 		CContactItemField* field=CContactItemField::NewLC();

   604 		nestedId=field->RestoreFieldTypesL(stream,aTemplate?&(aTemplate->CardFields()):NULL);

   605 		const CContentType &type=field->ContentType();

   606 		TBool fieldDefined=aViewDef.MatchesAll() || (aViewDef.Find(type)!=KErrNotFound);

   607 		if (!((fieldDefined&&includeFields) || (!fieldDefined&&!includeFields)) || 

   608 			(field->IsHidden() && aViewDef.Mode()==CContactItemViewDef::EMaskHiddenFields)

   609 			)

   610 			{

   611 			if (field->StorageType()==KStorageTypeText)  

   612 				textFieldIndex++;

   613 			CleanupStack::PopAndDestroy(field);

   614 			}

   615 		else

   616 			{

   617 			if (field->StorageType()==KStorageTypeText)  // restore from text stream

   618 				{

   619 				// restore text from contacts table.

   620 				TPtrC textPtr;

   621 				if(textPtr.Length())

   622 					{

   623 					field->TextStorage()->SetTextL(textPtr);

   624 					}

   625 				else

   626 					{

   627 					field->RestoreTextL(aTextBuf,textFieldIndex);

   628 					}

   629 

   630                 if (aTemplate)

   631                     {

   632                     AddL(*field);

   633                     }

   634                 else

   635                     {

   636                     iFields->AppendL(field);

   637                     }

   638 

   639 				CleanupStack::Pop(field);

   640 				textFieldIndex++;

   641 				}

   642 			else if (aBlobStore)

   643 				{

   644 				field->RestoreDataL(*aBlobStore, nestedId);

   645 

   646                 if (aTemplate)

   647                     {

   648                     AddL(*field);

   649                     }

   650                 else

   651                     {

   652                     iFields->AppendL(field);

   653                     }

   654 

   655 				CleanupStack::Pop(field);

   656 				}

   657 			else

   658 				{

   659 				CleanupStack::PopAndDestroy(field);

   660 				}

   661 			}

   662 		}

   663 	CleanupStack::PopAndDestroy(&stream); 

   664     }

   665 

   666 

   667 

   668 EXPORT_C void CContactItemFieldSet::UpdateFieldL(const CContactItemField &aField, TInt aMatchCount)

   669 /** Updates a field in the field set. The field whose content type matches aField's 

   670 content type is replaced by aField. The second parameter is used to identify 

   671 which matching field is updated. Specify 1 to update the first matching field, 

   672 2 for the second and so on. If there is no field in the field set which matches 

   673 aField's content type, then aField is appended to the field set.

   674 

   675 @param aField The new field information.

   676 @param aMatchCount Identifies which matching field in the field set should 

   677 be updated. */

   678 	{

   679 	const CContentType &newContentType=aField.ContentType();

   680 	TInt fieldPos=0;

   681 	for(;fieldPos<iFields->Count();fieldPos++)

   682 		{

   683 		if (newContentType==(*iFields)[fieldPos]->ContentType())

   684 			{

   685 			--aMatchCount;

   686 			if (aMatchCount==0)

   687 				{

   688 				Remove(fieldPos); 

   689 				break;

   690 				}

   691 			}

   692 		}

   693 	if (aField.Storage()->IsFull())

   694 		{

   695 		CContactItemField* field=CContactItemField::NewLC(aField);

   696 		InsertL(fieldPos,*field);

   697 		CleanupStack::Pop();	// field

   698 		}

   699 	}

   700 

   701 

   702 EXPORT_C void CContactItemFieldSet::UpdateFieldSyncL(const CContactItemField& aField, TInt aMatchCount)

   703 /**

   704  *  Updates a field in the field set. 

   705  *  Searches the set for a matching field. Deletes the matching set's field if any.

   706  *  Adds the aField to the set anyway.

   707  *  Uses the IsEqualForSyncUpdate() function to compare two CContentType objects,

   708  *  rather than the default equals operator.

   709  *  Takes care to hold the PREF, VoiceDial, and SpeedDial properties in the updated field.  

   710  *

   711  *  @param aField Specifies both the type of the field to update and the updated field's value.

   712  *  @param aMatchCount Gives the offset of the matching field to update in the order of the set

   713  *          (i.e. 1, means update the first matching field in the set;

   714  *                2, means update the second matching field in the set).

   715  */

   716 	{

   717 	TBool mustAddFieldTypePREF=EFalse;

   718 	TBool mustAddFieldTypeVoiceDial=EFalse;

   719 	TUid voiceDialUid=KNullUid;

   720 		

   721 	const CContentType& newContentType=aField.ContentType();

   722 	TInt fieldPos=0;

   723 	for(;fieldPos<iFields->Count();fieldPos++)

   724 		{

   725 		if ((*iFields)[fieldPos]->ContentType().IsEqualForSyncUpdate(newContentType))

   726 			{

   727 			--aMatchCount;

   728 			if (aMatchCount==0)

   729 				{

   730 				const CContentType& contentType=(*iFields)[fieldPos]->ContentType(); 

   731 

   732 				if (contentType.Mapping().iUid==KIntContactFieldVCardMapTEL)

   733 					{

   734 					for(TInt loop=0;loop<contentType.FieldTypeCount();loop++)

   735 						{

   736 						if (contentType.FieldType(loop).iUid>=KUidSpeedDialOneValue && contentType.FieldType(loop).iUid<=KUidSpeedDialNineValue)

   737 							{

   738 							voiceDialUid.iUid=contentType.FieldType(loop).iUid;

   739 							break; //only one speed dial property allowed for a field

   740 							}

   741 						}

   742 					

   743 					if (contentType.ContainsFieldType(KUidContactsVoiceDialField))

   744 						{

   745 						mustAddFieldTypeVoiceDial=ETrue;

   746 						}

   747 					}

   748 

   749 				if (contentType.ContainsFieldType(KUidContactFieldVCardMapPREF) && !newContentType.ContainsFieldType(KUidContactFieldVCardMapPREF))

   750 					{

   751 					mustAddFieldTypePREF=ETrue;

   752 					}	

   753 				break;

   754 				}

   755 			}

   756 		}

   757 	if (aField.Storage()->IsFull())

   758 		{

   759 		if( fieldPos<iFields->Count() )

   760 			{

   761 			Remove(fieldPos);//if updating with full field, then remove old field first

   762 			}

   763 		CContactItemField* field=CContactItemField::NewLC(aField);

   764 		if (mustAddFieldTypePREF)

   765 			{

   766 			field->AddFieldTypeL(KUidContactFieldVCardMapPREF);

   767 			}

   768 

   769 		if (mustAddFieldTypeVoiceDial)

   770 			{

   771 			field->AddFieldTypeL(KUidContactsVoiceDialField);

   772 			}

   773 

   774 		if (voiceDialUid!=KNullUid)

   775 			{

   776 			field->AddFieldTypeL(voiceDialUid);

   777 			}

   778 

   779 		InsertL(fieldPos,*field);

   780 		CleanupStack::Pop(field);	

   781 		}

   782 	else if( fieldPos < iFields->Count() )

   783 		{

   784 		(*iFields)[fieldPos]->ResetStore();//if updating with empty field, just reset the field

   785 		}

   786 	}

   787 

   788 

   789 

   790 TInt CContactItemFieldSet::FieldText(TFieldType aFieldType, TDes  &aText, TInt aStartPosition) const

   791 	{

   792 	TInt fieldPos=FindNext(aFieldType, aStartPosition);

   793 	if (fieldPos!=KErrNotFound)

   794 		(*iFields)[fieldPos]->GetFieldText(aText);

   795 	return fieldPos;

   796 	}

   797 

   798 /** Get the first non-empty text field*/

   799 void CContactItemFieldSet::NonZeroFieldText(TFieldType aFieldType, TDes &aText) const

   800 	{

   801 	TInt fieldPos=-1;

   802 	do

   803 		{

   804 		fieldPos=FindNext(aFieldType,fieldPos+1);

   805 		if (fieldPos==KErrNotFound)

   806 			break;

   807 		(*iFields)[fieldPos]->GetFieldText(aText);

   808 		} while(aText.Length()==0);

   809 	}

   810 

   811 

   812 /** 

   813 Part of the system template update implementation. 

   814 This could be used for a generic update method at a later stage.

   815 @since 7.0

   816 @internalTechnology

   817 */

   818 CArrayFix<TFieldHeader>* CContactItemFieldSet::ConstructFieldHeaderArrayLC(RWriteStream& aTextStream, CStreamStore& aBlobStore)

   819 	{

   820 	CArrayFix<TFieldHeader>* retval = new(ELeave) CArrayFixFlat<TFieldHeader>(5);

   821 	CleanupStack::PushL(retval);

   822 	CContactItemField* field = NULL;

   823 	TPtrC textPointer;

   824 	HBufC* buffer = NULL;

   825 	TInt counter = 0;

   826 	TInt maxFields = 0;

   827 	TInt textFieldIndex = 0;

   828 

   829 	maxFields = Count();

   830 	for (counter=0;counter < maxFields; counter++)

   831 		{

   832 		field = (*iFields)[counter];

   833 		if (!field->IsDeleted() )

   834 			{

   835 			if (field->StorageType()==KStorageTypeText)

   836 				{

   837 				textPointer.Set(field->TextStorage()->Text());

   838 				buffer = textPointer.AllocLC();

   839 				} // if

   840 

   841 			retval->AppendL(field->StoreL(aTextStream,aBlobStore,textFieldIndex));

   842 

   843 			if (buffer && buffer->Length() > 0 )

   844 				{

   845 				field->TextStorage()->SetTextL(*buffer);

   846 				}

   847 

   848 			if (buffer)

   849 				{

   850 				CleanupStack::PopAndDestroy(buffer);

   851 				buffer = NULL;

   852 				}

   853 

   854 			if (field->StorageType()==KStorageTypeText)

   855 				{

   856 				textFieldIndex++;

   857 				}

   858 			}//if

   859 		} // for

   860 

   861 	return retval;

   862 	}

   863 

   864 

   865 

   866 /*

   867  * Iterate through the fields.

   868  * If the current field matches the field we are inserting from the template 

   869  * return the position of the match. 

   870  * 

   871  * @param aSystemTemplateFields System template fieldset

   872  * @param aStartIndex Field to start from

   873  * @param aField Template field

   874  * @return KErrNotFound, if no field matching the template field in the fieldset, 

   875  * else returns position of match in fieldset

   876  */

   877 

   878 TInt CContactItemFieldSet::FieldTypeCount(const CContactItemFieldSet& aSystemTemplateFields, TInt aStartIndex, const CContactItemField& aField) const

   879 	{

   880 	const TInt fieldSetCount = Count();

   881 	for (TInt ii=aStartIndex;ii<fieldSetCount;ii++)

   882 		{

   883 		const CContactItemField& field=*((*iFields)[ii]);

   884 		TInt tfId = field.TemplateFieldId();

   885 		if(tfId==KNullFieldId)

   886 			{

   887 			if (field.ContentType()==aField.ContentType())

   888 				return(ii);

   889 			}

   890 		else

   891 			{

   892 			const CContactItemField* sysField=aSystemTemplateFields.FindById(tfId);

   893 			if (sysField->ContentType()==aField.ContentType())

   894    				return(ii);

   895 			}

   896 		}		

   897 	return KErrNotFound;

   898 	}

   899 	

   900 void CContactItemFieldSet::InternalizeL(RReadStream& aStream)

   901 /** Internalises a CContactItemFieldSet object from a read stream. 

   902 @param aStream Stream from which the object should be internalised. */

   903 	{

   904 	TInt fieldCount = aStream.ReadInt32L(); // Number of fields.	

   905 	

   906 	for(TInt index=0; index<fieldCount; ++index)

   907 		{

   908 		CContactItemField* currentField = CContactItemField::NewLC();	

   909 		currentField->InternalizeL(aStream);	

   910 		iFields->AppendL(currentField);

   911 		CleanupStack::Pop(currentField);	

   912 		}

   913 

   914 	}

   915 

   916 void CContactItemFieldSet::ExternalizeL(RWriteStream& aStream) const 

   917 /** Externalises a CContactItemFieldSet object to a write stream.

   918 @param aStream Stream to which the object should be externalised. */

   919 	{

   920 	TInt fieldCount = Count(); // Number of fields.

   921 	aStream.WriteInt32L(fieldCount);	

   922 	for(TInt index=0; index<fieldCount; ++index)

   923 		{

   924 			(*iFields)[index]->ExternalizeL(aStream);

   925 			

   926 		}

   927 	}		

   928 

   929 

   930 /*

   931  * Constructor. 

   932  * This is marked as private because CContactItem is an abstract base class.

   933  */

   934 CContactItem::CContactItem()

   935 	{

   936 	}

   937 

   938 /** Constructs a new contact item based on a RReadStream.

   939 @param aStream RReadStream containing object to internalize.

   940 @return Pointer to the newly created CContactItem. This is left on the cleanup stack. 

   941 @internalTechnology 

   942 */	

   943 CContactItem* CContactItem::NewLC(RReadStream& aStream)

   944 	{ // static

   945 	TUid ContactItemType;

   946 	ContactItemType.iUid = aStream.ReadInt32L();

   947 

   948 	CContactItem* item = NewLC(ContactItemType);

   949 	item->InternalizeL(aStream);

   950 	

   951 	return item;

   952 	}	

   953 	

   954 /** Constructs a new contact item.

   955 

   956 @return Pointer to the newly created CContactItem. This is left on the cleanup stack. 

   957 @internalTechnology 

   958 */

   959 EXPORT_C CContactItem* CContactItem::NewLC(TUid aType)

   960 	{ // static

   961 	CContactItem* item=NULL;

   962 		

   963 	switch(aType.iUid)

   964 		{

   965 		case KUidContactCardValue:

   966 			item = CContactCard::NewLC();

   967 			break;

   968 			

   969 		case KUidContactGroupValue:

   970 			item = CContactGroup::NewLC();

   971 			break;

   972 						

   973 		case KUidContactOwnCardValue:

   974 			item = CContactOwnCard::NewLC();

   975 			break;

   976 			

   977 		case KUidContactICCEntryValue:

   978 			item=CContactICCEntry::NewL();

   979 			CleanupStack::PushL(item);

   980 			break;

   981 

   982 		case KUidContactTemplateValue:

   983 			item = CContactTemplate::NewLC();

   984 			break;												

   985 			

   986 		case KUidContactCardTemplateValue:

   987 			item = CContactCardTemplate::NewLC();

   988 			break;	

   989 			

   990 		default:

   991 			User::Leave(KErrNotSupported);

   992 			break;																

   993 		

   994 		}		

   995 		

   996 	return item;

   997 	}			

   998 

   999 /*

  1000  * Second-phase construction.

  1001  * Set template ID on which this contact item is based as KNullContactId.

  1002  */

  1003 void CContactItem::ConstructL()

  1004 	{

  1005 	iFieldSet=CContactItemFieldSet::NewL();

  1006 	SetTemplateRefId(KNullContactId);

  1007 	}

  1008 

  1009 /*

  1010  * Second-phase construction overload.

  1011  */

  1012 void CContactItem::ConstructL(const CContactItem* aTemplate)

  1013 	{

  1014 	ConstructL();

  1015 

  1016 	const TUid type = Type();

  1017 	if (type==KUidContactCardTemplate || type==KUidContactOwnCard || type==KUidContactGroup)

  1018 		{

  1019 		SetTemplateRefId(KNullContactId);

  1020 		}

  1021 	else if (aTemplate->TemplateRefId()==KNullContactId) // can only be template

  1022 		{//record the contacts template

  1023 		SetTemplateRefId(aTemplate->Id());

  1024 		}

  1025 

  1026 	const CContactItemFieldSet& fieldSet=aTemplate->CardFields();

  1027 	const TInt fieldCount = fieldSet.Count();

  1028 	for(TInt loop=0;loop<fieldCount;loop++)

  1029 		{

  1030 		const CContactItemField& templateField=fieldSet[loop];

  1031 		if (!templateField.IsTemplateLabelField())

  1032 			{

  1033 			CContactItemField* field=CContactItemField::NewLC(templateField);

  1034 			AddFieldL(*field);

  1035 			CleanupStack::Pop(field);	

  1036 			field->CopyStorageL(templateField);

  1037 			}

  1038 		}

  1039 	}

  1040 

  1041 EXPORT_C CContactItem::~CContactItem()

  1042 /** The destructor frees all resources owned by the contact item, prior to its 

  1043 destruction. */

  1044 	{

  1045 	delete iFieldSet;

  1046 	delete iGuid;

  1047 	}

  1048 

  1049 EXPORT_C TContactItemId CContactItem::Id() const

  1050 /** Gets the contact item's ID.

  1051 

  1052 @return The contact item's ID. */

  1053 	{

  1054 	return iId;

  1055 	}

  1056 	

  1057 /**

  1058 Sets the contact item's ID.

  1059 

  1060 @internalTechnology

  1061 @released

  1062 */	

  1063 EXPORT_C void CContactItem::SetId(TContactItemId aId)

  1064 	{

  1065 	iId = aId;

  1066 	}

  1067 	

  1068 /**

  1069 Returns the contact item's attributes.

  1070 

  1071 @return contact item's attributes

  1072 

  1073 @internalTechnology

  1074 @released

  1075 */		

  1076 EXPORT_C TUint32 CContactItem::Attributes() const

  1077 	{

  1078 	return iAttributes;	

  1079 	}

  1080 

  1081 /**

  1082 Sest the contact item's attributes.

  1083 

  1084 @internalTechnology

  1085 @released

  1086 */			

  1087 EXPORT_C void CContactItem::SetAttributes(TUint32 aAttributes)

  1088 	{

  1089 	iAttributes = aAttributes;	

  1090 	}

  1091 	

  1092 /**

  1093 Sest the contact item's access count.

  1094 

  1095 @internalTechnology

  1096 @released

  1097 */				

  1098 EXPORT_C void CContactItem::SetAccessCount(TUint32 aAccessCount)

  1099 	{

  1100 	iAccessCount = aAccessCount;	

  1101 	}

  1102 	

  1103 /**

  1104 Sest the contact item's creation time.

  1105 

  1106 @internalTechnology

  1107 @released

  1108 */				

  1109 EXPORT_C void CContactItem::SetCreationDate(const TTime& aTime)

  1110 	{

  1111 	iCreationDate = aTime.Int64();	

  1112 	}

  1113 	

  1114 EXPORT_C TContactItemId CContactItem::TemplateRefId() const

  1115 /** Gets the ID of the template which was used to create this contact item.

  1116 

  1117 @return The ID of the template on which this item is based. KNullContactId 

  1118 if the item is not based on a template. */

  1119 	{

  1120 	return iTemplateRefId;

  1121 	}

  1122 

  1123 EXPORT_C TTime CContactItem::LastModified() const

  1124 /** Gets the contact item's last modified date/time.

  1125 

  1126 @return The contact item's last modified date/time. */

  1127 	{

  1128 	return iLastModified;

  1129 	}

  1130 

  1131 EXPORT_C void CContactItem::SetLastModified(const TTime& aLastModified)

  1132 /** Sets the last modified date/time value stored in the local copy of the contact 

  1133 item. This value is returned by LastModified() for this copy of the item.

  1134