/*
* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include "cntvcardutils.h"
// System includes
#include <badesca.h>
#include <conlist.h>
#include <s32mem.h>
// User includes
#include <cntfldst.h>
#include <cntfield.h>
#include <cntdef.h>
#include <cntitem.h>
// Constants
const TInt KVCardImportAddressArrayGranularity = 4;
const TInt KContactGivenName = 1;
const TInt KContactFamilyName = 0;
const TInt KContactAdditionalName = 2;
const TInt KContactPrefixName = 3;
const TInt KContactSuffixName = 4;
const TInt KContactPostOffice = 0;
const TInt KContactExtendedAddress = 1;
const TInt KContactAddress = 2;
const TInt KContactLocality = 3;
const TInt KContactRegion = 4;
const TInt KContactPostcode = 5;
const TInt KContactCountry = 6;
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
const TInt KContactMaxFieldNumber = 32;
#endif
/**
* Delete name fields from a contact
*
* @param aContact Contact item
*/
void CVCardToContactsAppConverter::DeleteNameFields(CContactItem& aContact)
{
const CContactItemFieldSet& fieldSet = aContact.CardFields();
//
DeleteField(aContact, fieldSet, KUidContactFieldGivenName, KUidContactFieldVCardMapUnusedN);
DeleteField(aContact, fieldSet, KUidContactFieldFamilyName, KUidContactFieldVCardMapUnusedN);
DeleteField(aContact, fieldSet, KUidContactFieldAdditionalName, KUidContactFieldVCardMapUnusedN);
DeleteField(aContact, fieldSet, KUidContactFieldPrefixName, KUidContactFieldVCardMapUnusedN);
DeleteField(aContact, fieldSet, KUidContactFieldSuffixName, KUidContactFieldVCardMapUnusedN);
}
/**
* Delete a specific field from the contact card
*
* @param aContact The contact
* @param aFieldSet The contact's field set
* @param aFieldType The type of field to delete from the field set
* @param aMapping The additional mapping which the field must contain for it to be deleted
*/
void CVCardToContactsAppConverter::DeleteField(CContactItem& aContact, const CContactItemFieldSet& aFieldSet, TFieldType aFieldType, TUid aMapping)
{
const TInt pos = aFieldSet.Find(aFieldType, aMapping);
if (pos != KErrNotFound)
aContact.RemoveField(pos);
}
void CVCardToContactsAppConverter::MergeSpecifiedNameFieldL(CContactItem& aContact, TFieldType aFieldType, CVCardItemAndLabel& aNames, TInt aOption, TInt aNameIndex)
/**
* Merge specific name fields from a contact
*
* @param aContact Contact item to add fields to
* @param aFieldType Field type of field to add (TFieldType)
* @param aNames An object containing the name and labels for 'N' property fields
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aNameIndex Index into aNames
*/
{
CContactItemFieldSet& oldfieldset=aContact.CardFields();
const TInt pos = oldfieldset.Find(aFieldType, KUidContactFieldVCardMapUnusedN);
const TBool processWhitespace = (aOption & CContactVCardConverter::EConnectWhitespace);
// First check whether the field is present in the contact card
// Also verify that the array of address sub-values actually contains a specific
// value for the requested index.
if (aNames.ItemCount() > aNameIndex)
{
const TPtrC pValue = aNames.Item(aNameIndex);
const TInt length = pValue.Length();
if (processWhitespace)
{
TBool isSingleSpace = EFalse;
if (length == 1)
{
isSingleSpace = (pValue[0] == KContactVCardSpaceCharacter);
}
if ((pos != KErrNotFound) && (length || isSingleSpace))
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (length && !isSingleSpace)
{
// This means the PC side field is unsupported, so ignore the corresponding contents.
TInt insertPos = 0;
SetNameFieldL(aNames, aContact, aOption, aNameIndex, aFieldType, insertPos);
}
}
else
{
if (pos != KErrNotFound)
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (length)
{
// This means the PC side field is not empty, so add the corresponding contents.
TInt insertPos = 0;
SetNameFieldL(aNames, aContact, aOption, aNameIndex, aFieldType, insertPos);
}
}
}
}
void CVCardToContactsAppConverter::MergeNameFieldsL(CContactItem& aContact, CVCardItemAndLabel& aNames, TInt aOption, TBool aTreatAsPrn)
/**
* Merge name fields from a contact
*
* @param aContact Contact item to add fields to
* @param aNames An object containing the name and labels for 'N' property fields
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
{
if(aTreatAsPrn)
{
MergeSpecifiedNameFieldL(aContact, KUidContactFieldGivenNamePronunciation, aNames, aOption, KContactGivenName);
MergeSpecifiedNameFieldL(aContact, KUidContactFieldFamilyNamePronunciation, aNames, aOption, KContactFamilyName);
}
else
{
MergeSpecifiedNameFieldL(aContact, KUidContactFieldPrefixName, aNames, aOption, KContactPrefixName);
MergeSpecifiedNameFieldL(aContact, KUidContactFieldGivenName, aNames, aOption, KContactGivenName);
MergeSpecifiedNameFieldL(aContact, KUidContactFieldAdditionalName, aNames, aOption, KContactAdditionalName);
MergeSpecifiedNameFieldL(aContact, KUidContactFieldFamilyName, aNames, aOption, KContactFamilyName);
MergeSpecifiedNameFieldL(aContact, KUidContactFieldSuffixName, aNames, aOption, KContactSuffixName);
}
}
void CVCardToContactsAppConverter::MergeSpecifiedAddressFieldL(CContactItem& aContact, const CVCardAddress& aAddress, const TUid& aFieldUid, const TUid& aMappingUid, TInt aAddressIndex, TInt aOption)
/**
* Merge specific address fields from a contact
*
* @param aContact Contact item to add fields to
* @param aUid The Uid of the contact
* @param aFieldUid Contacts database Field ID
* @param aMappingUid VCard Mapping ID
* @param aAddress An object containing the name and labels for 'ADR' property fields
* @param aAddressIndex Index into aAddress
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
{
CContactItemFieldSet& oldfieldset = aContact.CardFields();
TInt pos = 0;
const TBool processWhitespace = (aOption & CContactVCardConverter::EConnectWhitespace);
if (aAddress.Mapping() == KNullUid)
{
TBool fieldFound = EFalse;
TInt startPos = KContactFieldSetSearchAll;
while(!fieldFound && !(pos == KErrNotFound))
{
pos = oldfieldset.FindNext(aMappingUid, startPos);
startPos = pos + 1;
if (pos != KErrNotFound )
{
CContactItemField& tempField = oldfieldset[pos];
const CContentType& tempContentType = tempField.ContentType();
TBool additionalMapFound = EFalse;
additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapHOME);
additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapWORK);
additionalMapFound |= tempContentType.ContainsFieldType(KUidContactFieldVCardMapPREF);
if (!additionalMapFound)
{
fieldFound = ETrue;
}
}
}
}
else
{
pos = oldfieldset.Find(aAddress.Mapping(), aMappingUid);
}
// First check whether the field is present in the contact card
// Also verify that the array of address sub-values actually contains a specific
// value for the requested index.
if (aAddress.ItemCount() > aAddressIndex)
{
const TPtrC pValue = aAddress.Item(aAddressIndex);
const TInt length = pValue.Length();
if (processWhitespace)
{
TBool isSingleSpace = EFalse;
if (length == 1)
{
isSingleSpace = (pValue[0] == KContactVCardSpaceCharacter);
}
if ((length || isSingleSpace) && (pos != KErrNotFound))
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (length && !isSingleSpace)
{
TInt insertPos = 0;
SetAddressFieldL(aAddress, aContact, aOption, aAddressIndex, aFieldUid, insertPos, aMappingUid);
}
}
else
{
if (pos != KErrNotFound)
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (length)
{
// This means the PC side field is not empty, so add the corresponding contents.
TInt insertPos = 0;
SetAddressFieldL(aAddress, aContact, aOption, aAddressIndex, aFieldUid, insertPos, aMappingUid);
}
}
}
}
void CVCardToContactsAppConverter::MergeAddressFieldsL(CContactItem& aContact, const CVCardAddress& aAddress, TInt aOption)
/**
* Merge a specific field from the contact card
*
* @param aContact Contact item to add fields to
* @param aUid The Uid of the contact
* @param aAddresses Address of locally stored contact
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
{
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldPostOffice, KUidContactFieldVCardMapPOSTOFFICE, KContactPostOffice, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldExtendedAddress, KUidContactFieldVCardMapEXTENDEDADR, KContactExtendedAddress, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldAddress, KUidContactFieldVCardMapADR, KContactAddress, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldLocality, KUidContactFieldVCardMapLOCALITY, KContactLocality, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldRegion, KUidContactFieldVCardMapREGION, KContactRegion, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldPostcode, KUidContactFieldVCardMapPOSTCODE, KContactPostcode, aOption);
MergeSpecifiedAddressFieldL(aContact, aAddress, KUidContactFieldCountry, KUidContactFieldVCardMapCOUNTRY, KContactCountry, aOption);
}
TBool CVCardToContactsAppConverter::MergeVCardWithContactItemL(CContactItem &aContact, CParserVCard& aVCard, TUnknownPropertyBehaviour aUnknownPropertyBehaviour, TInt aOption)
/**
* Merge a vCard with an existing contact item
*
* @param aContact Contact item to add fields to
* @param aVCard vCard parser object
* @param aUnknownPropertyBehaviour Specifies how extension properties are handled
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @return ETrue if contact item should be deleted, EFalse otherwise
*/
{
TInt ii = 0;
TInt count = 0;
//
TBool deleteContact = ETrue;
iUnknownPropertyBehaviour = aUnknownPropertyBehaviour;
TTime lastModified;
GetVCardModifiedTimeL(aVCard, lastModified);
// We're performing a merge
SetImportType(ECntVCardImportTypeMerge);
// Get Name
CVCardItemAndLabel* names = GetContactNameLC(aVCard, aOption);
if (names && names->ItemCount())
{
MergeNameFieldsL(aContact, *names, aOption);
deleteContact = EFalse;
}
CleanupStack::PopAndDestroy(names);
// Get Name pronunciation
names = GetContactNamePrnLC(aVCard, aOption);
if (names && names->ItemCount())
{
MergeNameFieldsL(aContact, *names, aOption, ETrue);
}
CleanupStack::PopAndDestroy(names);
// Create address container
RPointerArray<CVCardAddress> addresses(KVCardImportAddressArrayGranularity);
CleanupStack::PushL(TCleanupItem(CVCardItemAndLabel::CleanUpResetDestroyAndCloseArray, &addresses));
// Get addresses from the vCard. This actually only retrieves four types of addresses:
// HOME, WORK, PREF and now additionally, 'general' addresses
GetAddressesL(aVCard, aOption, addresses);
// Import each of the located address field into the contact card
count = addresses.Count();
for (ii=0; ii<count; ii++)
{
const CVCardAddress* address = addresses[ii];
MergeAddressFieldsL(aContact, *address, aOption);
deleteContact = EFalse;
}
// Finished with addresses now, so clean up
CleanupStack::PopAndDestroy(&addresses);
// Get Organization related information from the vCard. This actually only retrieves the Company and the Department Name
CDesCArrayFlat* orgList = new (ELeave)CDesCArrayFlat(4);
CleanupStack::PushL(orgList);
TInt orgCount = GetVCardPropertyAsArrayOfValuesL(aVCard, KVersitTokenORG, *orgList);
if(orgCount)
{
MergeOrgDetailsL(aContact,*orgList,aOption);
deleteContact = EFalse;
}
CleanupStack::PopAndDestroy(orgList); // orgList
// Get Single Instance of Class Field from the vCard.
HBufC* singleClass = NULL;
singleClass = HBufC::NewLC(256);
TPtr ptr(singleClass->Des());
TInt classCount = GetSingleInstanceL(aVCard, KVersitTokenClass, ptr);
if(classCount)
{
MergeSingleInstanceL(aContact,ptr,KUidContactFieldClass, KUidContactFieldVCardMapClass,aOption);
deleteContact = EFalse;
}
CleanupStack::PopAndDestroy(singleClass);
// Get other properties
CArrayPtr<CParserProperty>* arrayOfProperties = aVCard.ArrayOfProperties();
CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy, arrayOfProperties));
count = arrayOfProperties->Count();
//Within this loop we store the content type of the last field updated.
//If the content type of the current field matches, we update fieldCount
//This holds the position of the field to update, to prevent us from
//overwriting the field we just updated.
TInt fieldCount = 0;
CContactItemField* oldField = NULL;
CContactItemField* newField = NULL;
for (ii = 0; ii < count; ii++)
{
if (((*arrayOfProperties)[ii]->Name() != KVersitTokenADR) && ((*arrayOfProperties)[ii]->Name() != KVersitTokenORG) && ((*arrayOfProperties)[ii]->Name() != KVersitTokenClass))
{
TBool unsupportedProperty=EFalse;
newField = GetVCardPropertyAsContactFieldLC((*arrayOfProperties)[ii], aOption,unsupportedProperty);
if (newField)
{
TInt ttnumber;
if (!oldField)
{
fieldCount = 1;
ttnumber = 1;
if (aOption & CContactVCardConverter::ETTFormat)
{
ttnumber = GetVCardPropertyTTNumber((*arrayOfProperties)[ii]);
}
}
else if (newField->ContentType().IsEqualForSyncUpdate(oldField->ContentType()))
{
ttnumber = ++fieldCount;
}
else
{
fieldCount = 1;
ttnumber = 1;
if (aOption & CContactVCardConverter::ETTFormat)
{
ttnumber = GetVCardPropertyTTNumber((*arrayOfProperties)[ii]);
}
}
if (oldField)
{
CleanupStack::Pop(); //newField
CleanupStack::PopAndDestroy(oldField);
oldField = NULL;
CleanupStack::PushL(newField);
}
oldField = newField;
aContact.CardFields().UpdateFieldSyncL(*newField, ttnumber);
if(newField->Storage()->IsFull())
{
deleteContact = EFalse;
}
newField = NULL;
}
else if (unsupportedProperty)
{
CleanupStack::Pop();
deleteContact = EFalse;
}
else{
CleanupStack::Pop();
}
}
}
//Remove all empty fields after merge
CContactItemFieldSet &fieldset = aContact.CardFields();
TInt i = 0;
for(; i < fieldset.Count(); ++i)
{
if( !fieldset[i].Storage()->IsFull() )
{
fieldset.Remove( i-- );
}
}
if (newField)
//coverity [dead_error_begin]
{
CleanupStack::PopAndDestroy(newField);
newField = NULL;
}
if (oldField)
{
CleanupStack::PopAndDestroy(oldField);
oldField = NULL;
}
if (lastModified != Time::NullTTime())
{
aContact.SetLastModified(lastModified);
}
CleanupStack::PopAndDestroy(arrayOfProperties);
return(deleteContact);
}
/**
* Set a name field. Only creates a field if the specified name text is not empty.
*
* @param aNames An object containing the name and labels for 'N' property fields
* @param aContact Contact item to add fields to
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aIndex Array position of field to use
* @param aFieldType Field type of field to add (TFieldType)
* @param aInsertPos Position in contact field set to add field
*/
void CVCardToContactsAppConverter::SetNameFieldL(const CVCardItemAndLabel& aNames, CContactItem& aContact, TInt aOption, TInt aIndex, TFieldType aFieldType, TInt& aInsertPos) const
{
const TInt count = aNames.ItemCount();
const TInt labelCount = aNames.LabelCount();
//
if (aIndex >= 0 && aIndex < count)
{
const TPtrC pFieldText(aNames.Item(aIndex));
TBool addField = EFalse;
if (CContactVCardConverter::EConnectWhitespace & aOption)
{
addField = CContactVCardConverter::ContainsImportableData(pFieldText, CContactVCardConverter::EPropertyValueComposite, ImportType());
}
else
{
addField = (pFieldText.Length());
}
// Only add the field if it contains some data
if (addField)
{
CContactItemField* contactItemField = CContactItemField::NewLC(KStorageTypeText, aFieldType);
contactItemField->SetMapping(KUidContactFieldVCardMapUnusedN);
if ((aOption & CContactVCardConverter::EIncludeX) && (aIndex >= 0 && aIndex < labelCount))
contactItemField->SetLabelL(aNames.Label(aIndex));
//
HBufC* encodedText = EncodeL(pFieldText, ETrue);
contactItemField->TextStorage()->SetText(encodedText); // takes ownership
aContact.InsertFieldL(*contactItemField, aInsertPos++);
CleanupStack::Pop(contactItemField);
}
}
}
HBufC* CVCardToContactsAppConverter::EncodeL(const TDesC& aText, TBool aTextTobeTruncated) const
{
const TUid KUidTextToEtextNoTrim={0x10281B4C};
// Make a copy of aText and truncate if necessary.
TPtr truncText(const_cast<TUint16*>(aText.Ptr()),aText.Length());
if(aTextTobeTruncated)
truncText.SetLength(aText.Length()>KCntMaxTextFieldLength ? KCntMaxTextFieldLength : aText.Length());
else
truncText.SetLength(aText.Length());
HBufC8* text=HBufC8::NewLC(truncText.Length()*2);
TPtr8 ptr = text->Des();
TInt i;
for (i=0; i < truncText.Length(); i++)
{
ptr.Append(truncText[i] & 0x00FF);
ptr.Append((truncText[i] >> 8) & 0x00FF);
}
CCnaConverterList* convList=CCnaConverterList::NewLC();
CConverterBase* conv = convList->NewConverterL(KUidTextToEtextNoTrim);
if (!conv)
{
CleanupStack::PopAndDestroy(); // convList
User::Leave(KErrNotSupported);
}
CleanupStack::PushL(conv);
CBufFlat* decodeBuffer = CBufFlat::NewL(256);
CleanupStack::PushL(decodeBuffer);
CBufFlat* encodedBuffer = CBufFlat::NewL(256);
CleanupStack::PushL(encodedBuffer);
decodeBuffer->InsertL(0,ptr);
RBufReadStream readStream;
RBufWriteStream writeStream;
readStream.Open(*decodeBuffer);
writeStream.Open(*encodedBuffer);
conv->ConvertObjectL(readStream, writeStream);
readStream.Close();
TInt size=encodedBuffer->Size();
HBufC* writeBuf=HBufC::NewLC(size);
TPtr resulttext = writeBuf->Des();
for(i = 0; i < (size - 1); i += 2)
{
resulttext.Append((encodedBuffer->Ptr(0)[i + 1] << 8) |
encodedBuffer->Ptr(0)[i]);
}
writeStream.CommitL();
writeStream.Close();
CleanupStack::Pop(); // writebuf
CleanupStack::PopAndDestroy(2); // buffers
CleanupStack::PopAndDestroy(2); //conv+convList
CleanupStack::PopAndDestroy(); //text
return writeBuf;
}
/**
* Set name fields
*
* @param aNames An object containing the name and labels for 'N' property fields
* @param aContact Contact item to add fields to
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aTreatAsPronunciation If true, save name data in pronunciation fields, otherwise save as an actual name (the default)
*/
void CVCardToContactsAppConverter::SetNameFieldsL(const CVCardItemAndLabel& aNames, CContactItem& aContact, TInt aOption, TBool aTreatAsPronunciation) const
{
TInt insertPos=0;
if( aTreatAsPronunciation )
{
SetNameFieldL(aNames, aContact, aOption, KContactGivenName, KUidContactFieldGivenNamePronunciation, insertPos);
SetNameFieldL(aNames, aContact, aOption, KContactFamilyName, KUidContactFieldFamilyNamePronunciation, insertPos);
}
else
{
SetNameFieldL(aNames, aContact, aOption, KContactPrefixName, KUidContactFieldPrefixName, insertPos);
SetNameFieldL(aNames, aContact, aOption, KContactGivenName, KUidContactFieldGivenName, insertPos);
SetNameFieldL(aNames, aContact, aOption, KContactAdditionalName, KUidContactFieldAdditionalName, insertPos);
SetNameFieldL(aNames, aContact, aOption, KContactFamilyName, KUidContactFieldFamilyName, insertPos);
SetNameFieldL(aNames, aContact, aOption, KContactSuffixName, KUidContactFieldSuffixName, insertPos);
}
}
void CVCardToContactsAppConverter::SetAddressFieldL(const CVCardAddress& aAddress, CContactItem& aContact, TInt aOption, TInt aIndex, TFieldType aFieldType, TInt& aInsertPos, TUid aMapping) const
/**
* Set an address field
*
* @param aAddress An object containing the name and labels for 'ADR' property fields
* @param aContact Contact item to add fields to
* @param aOption Import preferences (available options defined in CContactVCardConverter::TOptions)
* @param aIndex Array position of field to use
* @param aFieldType Contact field type for address field
* @param aInsertPos Position in contact field set to add field
* @param aMapping vCard field mapping (eg. KUidContactFieldVCardMapPOSTCODE)
*/
{
const TInt count = aAddress.ItemCount();
if (aIndex >= 0 && aIndex < count)
{
const TPtrC pFieldText(aAddress.Item(aIndex));
TBool doInsert = ETrue; // By default we process the data, but if the TimeIS flag is set, then we need to check the content first.
if (CContactVCardConverter::EConnectWhitespace & aOption)
{
doInsert = (CContactVCardConverter::ContainsImportableData(pFieldText, CContactVCardConverter::EPropertyValueComposite, ImportType()));
}
if (doInsert)
{
CContentType* content = CContentType::NewL(aFieldType, aMapping);
CleanupStack::PushL(content);
if (aAddress.Mapping() != KNullUid) // KNullUid corresponds to general address
{
content->AddFieldTypeL(aAddress.Mapping());
}
CContactItemField* contactItemField = CContactItemField::NewLC(KStorageTypeText, *content);
if ((aOption & CContactVCardConverter::EIncludeX) && (aIndex >= 0 && aIndex < aAddress.LabelCount()))
{
// get the correct label
TBuf<25> labelName(KContactVarVCardXDashEPOCCNTMODEL);
labelName.AppendFormat(KContactVarVCardLABELn, aIndex);
TInt position=KErrNotFound;
TInt err = aAddress.FindLabel(labelName, position);
if (err==KErrNone && position!=KErrNotFound)
contactItemField->SetLabelL(aAddress.Label(position));
}
HBufC* encodedText = EncodeL(pFieldText, ETrue);
contactItemField->TextStorage()->SetText(encodedText); // takes ownership
// The contact takes ownership of the field.
aContact.InsertFieldL(*contactItemField, aInsertPos++);
CleanupStack::Pop(contactItemField);
CleanupStack::PopAndDestroy(content);
}
}
}
void CVCardToContactsAppConverter::SetAddressFieldsL(const CVCardAddress& aAddress, CContactItem& aContact, TInt aOption) const
/**
* Set the address fields
*
* @param aAddressses An object containing the name and labels for 'ADR' property fields
* @param aContact Contact item to add fields to
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
{
TInt insertPos = 0;
SetAddressFieldL(aAddress, aContact, aOption, KContactPostOffice, KUidContactFieldPostOffice, insertPos, KUidContactFieldVCardMapPOSTOFFICE);
SetAddressFieldL(aAddress, aContact, aOption, KContactExtendedAddress, KUidContactFieldExtendedAddress, insertPos, KUidContactFieldVCardMapEXTENDEDADR);
SetAddressFieldL(aAddress, aContact, aOption, KContactAddress, KUidContactFieldAddress, insertPos, KUidContactFieldVCardMapADR);
SetAddressFieldL(aAddress, aContact, aOption, KContactLocality, KUidContactFieldLocality, insertPos, KUidContactFieldVCardMapLOCALITY);
SetAddressFieldL(aAddress, aContact, aOption, KContactRegion, KUidContactFieldRegion, insertPos, KUidContactFieldVCardMapREGION);
SetAddressFieldL(aAddress, aContact, aOption, KContactPostcode, KUidContactFieldPostcode, insertPos, KUidContactFieldVCardMapPOSTCODE);
SetAddressFieldL(aAddress, aContact, aOption, KContactCountry, KUidContactFieldCountry, insertPos, KUidContactFieldVCardMapCOUNTRY);
}
/**
* Convert aVCard into a ContactItem. This method leaves a CContactItem instance on the cleanup stack upon exit.
*
* @param aVCard vCard parser object
* @param aAgentContact Agent contact item. Note that this object is passed by reference but is not
* left on the cleanup stack upon exit from this function. Clients shoul re-Push
* this object if needed.
* @param aUnknownPropertyBehaviour Specifies how extension properties are handled
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*
* @return A CContactItem instance (on the cleanup stack) that has been constructed from
* the vCard data.
*/
CContactItem* CVCardToContactsAppConverter::GetVCardAsContactItemLC(CParserVCard& aVCard, TUnknownPropertyBehaviour aUnknownPropertyBehaviour, TInt aOption)
{
TInt ii=0;
TInt count = 0;
//
iUnknownPropertyBehaviour = aUnknownPropertyBehaviour;
TTime lastModified;
TBuf<KUidStringLength> uidstring;
GetVCardModifiedTimeL(aVCard, lastModified);
GetVCardUidStringL(aVCard, uidstring);
//
CContactCard* mainContact = CContactCard::NewLC();
//
// We're performing an initial import
SetImportType(ECntVCardImportTypeFirstSync);
// Get Name
CVCardItemAndLabel* names = GetContactNameLC(aVCard, aOption);
if (names && names->ItemCount())
SetNameFieldsL(*names, *mainContact, aOption);
CleanupStack::PopAndDestroy(names);
// Get Name pronunciation
names = GetContactNamePrnLC(aVCard, aOption);
if (names && names->ItemCount())
{
SetNameFieldsL(*names, *mainContact, aOption, ETrue);
}
CleanupStack::PopAndDestroy(names);
// Create address container
RPointerArray<CVCardAddress> addresses(KVCardImportAddressArrayGranularity);
CleanupStack::PushL(TCleanupItem(CVCardItemAndLabel::CleanUpResetDestroyAndCloseArray, &addresses));
// Get addresses
GetAddressesL(aVCard, aOption, addresses);
// Import each address field into the contact card
count = addresses.Count();
for (ii=0; ii<count; ii++)
{
const CVCardAddress* address = addresses[ii];
SetAddressFieldsL(*address, *mainContact, aOption);
}
// Finished with addresses now, so clean up
CleanupStack::PopAndDestroy(&addresses);
// Get Organization related information from the vCard. This actually only retrieves the Company and the Department Name
CDesCArrayFlat* orgList = new (ELeave)CDesCArrayFlat(4);
CleanupStack::PushL(orgList);
TInt orgCount = GetVCardPropertyAsArrayOfValuesL(aVCard, KVersitTokenORG, *orgList);
if(orgCount)
{
SetOrgDetailsL(*mainContact, *orgList, aOption);
}
CleanupStack::PopAndDestroy(orgList); // orgList
// Get Single Instance of Class Field from the vCard.
HBufC* singleClass = NULL;
singleClass = HBufC::NewLC(256);
TPtr ptr(singleClass->Des());
TInt classCount = GetSingleInstanceL(aVCard, KVersitTokenClass, ptr);
if(classCount)
{
SetSingleInstanceL(*mainContact, ptr, KUidContactFieldClass, KUidContactFieldVCardMapClass,aOption);
}
CleanupStack::PopAndDestroy(singleClass);
// Get other properties
CArrayPtr<CParserProperty>* arrayOfProperties = aVCard.ArrayOfProperties();
CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,arrayOfProperties));
//
if (arrayOfProperties)
{
count = arrayOfProperties->Count();
for (ii=0; ii<count; ii++)
{
CParserProperty* property = arrayOfProperties->At(ii);
// Address fields are handled in the above sections
if ((property->Name() != KVersitTokenADR) && (property->Name() != KVersitTokenORG) && (property->Name() != KVersitTokenClass))
{
// NOTE: This method can return a NULL object pushed onto the cleanup stack, so must
// always be popped!
TBool unsupportedProperty=EFalse;
CContactItemField* field = GetVCardPropertyAsContactFieldLC(property, aOption,unsupportedProperty);
if (field)
{
mainContact->AddFieldL(*field);
}
CleanupStack::Pop(field);
}
}
// Email and Tel properties should only have a single Pref parameter
AdjustForPrefRule(*mainContact, KUidContactFieldEMail, KUidContactFieldVCardMapEMAILINTERNET);
AdjustForPrefRule(*mainContact, KUidContactFieldPhoneNumber, KUidContactFieldVCardMapTEL);
}
//
if (lastModified != Time::NullTTime())
{
mainContact->SetLastModified(lastModified);
}
//
mainContact->SetUidStringL(uidstring);
//
CleanupStack::PopAndDestroy(); // arrayOfProperties->ResetAndDestroy()
//
return mainContact;
}
/**
* Extract the last modified date of the vCard.
* If there is no 'REV' property the last modified time is returned as as NULL TTime value.
*
* @param aVCard vCard parser object
* @param aLastModified Last modified time
*/
void CVCardToContactsAppConverter::GetVCardModifiedTimeL(CParserVCard& aVCard,TTime& aLastModified)
{
CArrayPtr<CParserProperty>* arrayOfRevisions=aVCard.PropertyL(KVersitTokenREV,TUid::Uid(KVersitPropertyDateTimeUid),EFalse);
if (arrayOfRevisions && arrayOfRevisions->Count())
{
CleanupStack::PushL(arrayOfRevisions);
CParserPropertyValueDateTime* revision=(static_cast<CParserPropertyValueDateTime*>((*arrayOfRevisions)[0]->Value()));
aLastModified=revision->Value()->iDateTime;
if (revision->Value()->iRelativeTime != TVersitDateTime::EIsUTC )
// The REV property isn't in UTC time, so let's (try to) convert it
{
CArrayPtr<CParserProperty>* arrayOfTimeZones=aVCard.PropertyL(KVersitTokenTZ, TUid::Uid(KVersitPropertyTimeZoneUid),EFalse);
if (arrayOfTimeZones && arrayOfTimeZones->Count())
// If we have the TZ property, adjust the machine local timestamp.
// If we don't have the TZ property, we'll just pretend that the REV
// property was already a UTC value.
{
CleanupStack::PushL(arrayOfTimeZones);
CParserPropertyValueTimeZone* timeZone =
static_cast<CParserPropertyValueTimeZone*> ((*arrayOfTimeZones)[0]->Value());
// Subtract the offset: UTC + Offset = Local => UTC = Local - Offset.
TTimeIntervalSeconds utcOffset = timeZone->Value().Int();
aLastModified -= utcOffset;
CleanupStack::PopAndDestroy(arrayOfTimeZones);
}
}
CleanupStack::PopAndDestroy(arrayOfRevisions);
}
else
{
aLastModified=Time::NullTTime();
}
}
/**
* Extract the vCard 'UID' property from the vCard.
*
* @param aVCard vCard parser object
* @param aUidString UID property value
*/
void CVCardToContactsAppConverter::GetVCardUidStringL(CParserVCard& aVCard,TDes& aUidString) const
{
const CArrayPtr<CParserProperty>* arrayOfProperties=aVCard.PropertyL(KVersitTokenUID,TUid::Uid(KVersitPropertyHBufCUid),EFalse);
if (arrayOfProperties)
{
TInt count=arrayOfProperties->Count();
if (count)
{
CParserPropertyValueHBufC* uidstring=(STATIC_CAST(CParserPropertyValueHBufC*,(*arrayOfProperties)[0]->Value()));
if (uidstring->Value().Length() > KUidStringLength )
aUidString=uidstring->Value().Left(KUidStringLength) ; // truncate
else
aUidString=uidstring->Value();
}
delete arrayOfProperties;
}
}
/**
* Convert aVCardProperty into contact field.
*
* @param aProperty vCard property
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aUnsupportedProperty Return whether or not the field is supported by the PC PIM, only relevant when using the EConnectWhitespace flag
* @return Contact field or a NULL pointer (pushed onto the cleanup stack) in the case where
* it wasn't possible to create a contact field for this vCard property.
*/
CContactItemField* CVCardToContactsAppConverter::GetVCardPropertyAsContactFieldLC(CParserProperty* aProperty,TInt aOption,TBool& aUnsupportedProperty)
{
TUid mappingUid;
TStorageType storageType;
CContentType* content=MapVCardPropertyToContentAndStorageTypeL(*aProperty,storageType);
CleanupStack::PushL(content);
mappingUid=content->Mapping();
TBool noConversion=EFalse;
aUnsupportedProperty=EFalse;
if (mappingUid==KUidContactFieldVCardMapNotRequired)
{
noConversion=ETrue;
}
else
{ /*Could preserve unknown non X- if VCard version no>2.1*/
switch (iUnknownPropertyBehaviour)
{
case EDiscardAllUnknownProperties:
if (mappingUid==KUidContactFieldVCardMapUnknownXDash)
noConversion=ETrue;
/* fall through */
case EDiscardNonXDashUnknownProperties:
if (mappingUid==KUidContactFieldVCardMapUnknown)
noConversion=ETrue;
/* fall through */
default:
break;
}
}
CContactItemField* contactItemField=NULL;
if (!noConversion)
{
TBool validImportableDataFound = ETrue;
contactItemField=CContactItemField::NewLC(storageType,*content);
if ((mappingUid==KUidContactFieldVCardMapUnknown) ||(mappingUid==KUidContactFieldVCardMapUnknownXDash))
{
TBool propertyTobeTruncated = PropertyTobeTruncated(aProperty->Name());
HBufC* encodedText = EncodeL(STATIC_CAST(CParserPropertyValueHBufC*,aProperty->Value())->Value(), propertyTobeTruncated);
contactItemField->TextStorage()->SetText(encodedText); // takes ownership
contactItemField->SetHidden(ETrue);
}
else
{
switch (contactItemField->StorageType())
{
case KStorageTypeText:
{
TInt id = aProperty->Value()->Uid().iUid;
if(mappingUid == KUidContactFieldVCardMapORGPronunciation)
{ // this should be treated as an array instead of a single string
id = KVersitPropertyCDesCArrayUid;
}
switch (id)
{
case KVersitPropertyCDesCArrayUid:
{
TBool doConvert = ETrue;
TBool pushed = EFalse;
CParserPropertyValueCDesCArray* propertyValueWrapper=NULL;
if(mappingUid == KUidContactFieldVCardMapORGPronunciation)
{ // Treat a SOUND with X-IRMC-ORG param as an array
const CParserPropertyValueHBufC* valueScalar = static_cast<CParserPropertyValueHBufC*>(aProperty->Value());
if(valueScalar)
{
propertyValueWrapper = valueScalar->TreatAsArrayPropertyLC(*aProperty);
pushed= ETrue;
}
}
else
{
propertyValueWrapper = static_cast<CParserPropertyValueCDesCArray*>(aProperty->Value());
}
CDesCArray* propertyValue = NULL;
if (propertyValueWrapper)
{
propertyValue = propertyValueWrapper->Value();
}
if ((CContactVCardConverter::EConnectWhitespace & aOption) && propertyValue)
{
doConvert = TextArrayContainsImportableData(*propertyValue);
if (doConvert)
{
RemoveWhitespaceFromCompositePropertyL(*propertyValue);
}
}
if (doConvert && propertyValue)
{
TInt count = propertyValue->MdcaCount();
HBufC *txt=HBufC::NewL(0);
CleanupStack::PushL(txt);
// concatenate the array
for (TInt ii=0;ii<count;ii++)
{
TInt mdcaLen=propertyValue->MdcaPoint(ii).Size();
if (mdcaLen>0)
{
if (txt->Length()>0)
{
txt->Des().Append(TChar('\n'));
}
txt=txt->ReAllocL(txt->Length()+mdcaLen+1); // +1 In case we add '\n'
CleanupStack::Pop(); // txt(old value)
CleanupStack::PushL(txt);
TPtrC temp(propertyValue->MdcaPoint(ii));
txt->Des().Append(temp);
}
}
TBool propertyTobeTruncated = PropertyTobeTruncated(aProperty->Name());
HBufC* encodedText = EncodeL(*txt, propertyTobeTruncated);
CleanupStack::PopAndDestroy(txt);
contactItemField->TextStorage()->SetText(encodedText); // takes ownership
}
else
{
validImportableDataFound = EFalse;
}
if(pushed)
{
CleanupStack::PopAndDestroy(propertyValueWrapper);
}
}
break;
case KVersitPropertyHBufCUid:
{
TBool doConvert = ETrue;
CParserPropertyValueHBufC* propertyValueWrapper = static_cast<CParserPropertyValueHBufC*>(aProperty->Value());
const TPtrC propertyValue(propertyValueWrapper->Value());
if (CContactVCardConverter::EConnectWhitespace & aOption)
{
if (propertyValue==KSingleSpacePropertyValue)
{
aUnsupportedProperty=ETrue;
}
doConvert = (CContactVCardConverter::ContainsImportableData(propertyValue, CContactVCardConverter::EPropertyValueSingle, ImportType()));
}
if (doConvert)
{
TBool propertyTobeTruncated = PropertyTobeTruncated(aProperty->Name());
HBufC* encodedText = EncodeL(propertyValue, propertyTobeTruncated);
contactItemField->TextStorage()->SetText(encodedText); // takes ownership
}
else
{
validImportableDataFound = EFalse;
}
}
break;
default:;
}
}
break;
case KStorageTypeDateTime:
{
switch (aProperty->Value()->Uid().iUid)
{
case KVersitPropertyDateTimeUid:
STATIC_CAST(CContactDateField*,contactItemField->Storage())->SetTime(STATIC_CAST(CParserPropertyValueDateTime*,aProperty->Value())->Value()->iDateTime);
break;
case KVersitPropertyDateUid:
STATIC_CAST(CContactDateField*,contactItemField->Storage())->SetTime(STATIC_CAST(CParserPropertyValueDate*,aProperty->Value())->Value()->iDateTime);
break;
default:
break;
}
}
break;
case KStorageTypeStore:
{
STATIC_CAST(CContactStoreField*,contactItemField->Storage())->SetThingL(STATIC_CAST(CParserPropertyValueBinary*,aProperty->Value())->Value());
}
break;
default:
break;
}
}
if (aOption & CContactVCardConverter::EIncludeX)
{
TBuf8<KContactMaxVCardPropertyNameLength> paramName;
paramName=KContactVCardXDashEPOCCNTMODEL;
paramName.Append(KContactVCardFIELDHIDDEN);
if (aProperty->Param(paramName))
contactItemField->SetHidden(ETrue);
paramName.Zero();
paramName=KContactVCardXDashEPOCCNTMODEL;
paramName.Append(KContactVCardFIELDREADONLY);
if (aProperty->Param(paramName))
contactItemField->SetReadOnly(ETrue);
paramName.Zero();
paramName=KContactVCardXDashEPOCCNTMODEL;
paramName.Append(KContactVCardFIELDLABEL);
if (aProperty->Param(paramName))
contactItemField->SetLabel(aProperty->Param(paramName)->ValueL());
}
CleanupStack::Pop(contactItemField);
// The field is only added to the contact card if it was found to contain
// legitimate importable data (i.e. has content that does not simply consist of LWSP characters).
// This is important, since TimeIS sync drivers can create vCard objects (pushed over to the device)
// that contain only space characters for their Versit 'Property Parameter Values'.
if (!validImportableDataFound)
{
delete contactItemField;
contactItemField = NULL;
}
}
CleanupStack::PopAndDestroy(content);
// We may be pushing a NULL pointer back onto the cleanup stack, but clients of this
// method understand this feature.
CleanupStack::PushL(contactItemField);
return(contactItemField);
}
/**
* Find a vCard property parameter in a vCard property
*
* @param aVCardProperty vCard property
* @return Property parameter number
*/
TInt CVCardToContactsAppConverter::GetVCardPropertyTTNumber(CParserProperty* aVCardProperty)
{
TInt ii;
TBuf8<KContactMaxVCardPropertyNameLength> paramName;
for (ii=1;ii<=KContactMaxFieldNumber;ii++)
{
paramName.Format(_L8("%d"),ii);
if (aVCardProperty->Param(paramName))
{
return (ii);
}
}
return 1; // Default to 1 if no number found
}
/**
* Extract the contact name fields from the vCard 'N' property.
* This method takes values from the 'N' vCard property and returns the family name,
* given name, middle name, prefix and suffix.
*
* Only the first instance of the 'N' property is used.
*
* @param aVCard vCard parser object
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @return An instance of CVCardItemAndLabel which encapsulates the names and their associated
* labels contained within the vCard or a NULL pointer pushed onto the cleanup stack
* if it wasn't possible to construct the object.
*/
CVCardItemAndLabel* CVCardToContactsAppConverter::GetContactNameLC(CParserVCard& aVCard, TInt aOption)
{
CVCardItemAndLabel* names = NULL;
CArrayPtr<CParserProperty>* arrayOfProperties=aVCard.PropertyL(KVersitTokenN,TUid::Uid(KVersitPropertyCDesCArrayUid));
if (arrayOfProperties && arrayOfProperties->Count())
{
CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,arrayOfProperties));
//
//
CParserProperty* property = arrayOfProperties->At(0);
CDesCArray& items = *static_cast<CParserPropertyValueCDesCArray*>(property->Value())->Value();
names = MakeNamesFromItemsL(items, aOption, property );
CleanupStack::PopAndDestroy(arrayOfProperties);
}
// Clients of this method assume that something is pushed onto the Cleanup Stack, so
// this might potentially be NULL.
CleanupStack::PushL(names);
return names;
}
/**
* Extract the contact name fields from the vCard 'N' property.
* This method takes values from the 'N' vCard property and returns the family name,
* given name, middle name, prefix and suffix.
*
* Only the first instance of the 'N' property is used.
*
* @param aVCard vCard parser object
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @return An instance of CVCardItemAndLabel which encapsulates the names and their associated
* labels contained within the vCard or a NULL pointer pushed onto the cleanup stack
* if it wasn't possible to construct the object.
*/
CVCardItemAndLabel* CVCardToContactsAppConverter::GetContactNamePrnLC(CParserVCard& aVCard, TInt aOption)
{
CVCardItemAndLabel* names = NULL;
CArrayPtr<CParserProperty>* arrayOfProperties=aVCard.PropertyL(KVersitTokenSOUND,TUid::Uid(KVersitPropertyHBufCUid), EFalse);
if (arrayOfProperties )
{
CleanupStack::PushL(arrayOfProperties);
TInt count = arrayOfProperties->Count();
const CParserProperty* property=NULL;
for (TInt index=0;index<count;index++)
{
property = arrayOfProperties->At(index);
if(property->Param(KVersitParam8NamePrn))
{
index=count;
}
else
{
property=NULL;
}
}
if (property) // property is the 1st SOUND property with an X-IRMC-N parameter
{
const CParserPropertyValueHBufC* valueScalar = static_cast<CParserPropertyValueHBufC*>(property->Value());
if(valueScalar)
{
CParserPropertyValueCDesCArray* valueArray = valueScalar->TreatAsArrayPropertyLC(*property);
names = MakeNamesFromItemsL( *valueArray->Value(), aOption, property );// valueArray will never be NULL
CleanupStack::PopAndDestroy(valueArray);
}
}
CleanupStack::PopAndDestroy(arrayOfProperties);
}
// Clients of this method assume that something is pushed onto the Cleanup Stack, so
// this might potentially be NULL.
CleanupStack::PushL(names);
return names;
}
CVCardItemAndLabel* CVCardToContactsAppConverter::MakeNamesFromItemsL(const CDesCArray& aItems, TInt aOption, const CParserProperty* aProperty )
{
CVCardItemAndLabel* names = CVCardItemAndLabel::NewLC();
const TInt fieldcount = aItems.Count();
//
for(TInt ii=0; ii<fieldcount; ii++)
{
const TPtrC pField(aItems.MdcaPoint(ii));
names->AddItemL(pField);
if (aOption & CContactVCardConverter::EIncludeX)
{
TBuf8<KContactMaxVCardPropertyNameLength> paramName(KContactVCardXDashEPOCCNTMODEL);
paramName.AppendFormat(KContactVCardLABELn,ii);
//
if(aProperty->Param(paramName))
{
HBufC* value = aProperty->Param(paramName)->ValueL();
CleanupStack::PushL(value);
names->AddLabelL(*value);
CleanupStack::PopAndDestroy(value);
}
}
}
CleanupStack::Pop(names);
return names;
}
/**
* Extract specific address properties
* @param aProperties An array of vCard properties which should be searched
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aParamMustMatch A property parameter which must be found in the specified vCard property. If this
* has a NULL (KNullDesC) value then the property is treated as satisfying this condition
* @param aParamMustNotMatch1 A property parameter which must not be found in the specified vCard property. If this
* has a NULL (KNullDesC) value then the property is treated as satisfying this condition
* @param aParamMustNotMatch2 Another property parameter which must not be found in the specified vCard property. If this
* has a NULL (KNullDesC) value then the property is treated as satisfying this condition
* @param aMapping The address mapping which is being searched for (e.g. HOME, WORK, etc)
* @return An address object which contains the name and labels (optionally) located in aProperties for this particular mapping
*/
CVCardAddress* CVCardToContactsAppConverter::GetSpecifiedAddressLC(const CArrayPtr<CParserProperty>& aProperties, TInt aOption, const TDesC8& aParamMustMatch, const TDesC8& aParamMustNotMatch1, const TDesC8& aParamMustNotMatch2, TUid aMapping)
{
CVCardAddress* address = NULL;
const TInt propertyCount = aProperties.Count();
//
for (TInt ii=0; ii<propertyCount; ii++)
{
CParserProperty* property = aProperties[ii];
// DEF084708, also get and compare for ADDR;TYPE=HOME etc in addition to ADDR;HOME.
// The param to be matched (or not matched) can be found either as the param name (ADDR;HOME)
// or in the param value of param name - TYPE (case ADDR;TYPE=HOME)
CParserParam* paramType = property->Param(KVersitParam8Type);
if (
(property->Name() == KVersitTokenADR) &&
(property->Value()->Uid() == TUid::Uid(KVersitPropertyCDesCArrayUid)) &&
(!aParamMustMatch.Length() || property->Param(aParamMustMatch) != NULL ||
(paramType != NULL && paramType->Value().CompareF(aParamMustMatch) == 0)) &&
(!aParamMustNotMatch1.Length() || (property->Param(aParamMustNotMatch1) == NULL &&
(paramType == NULL || paramType->Value().CompareF(aParamMustNotMatch1) != 0))) &&
(!aParamMustNotMatch2.Length() || (property->Param(aParamMustNotMatch2) == NULL &&
(paramType == NULL || paramType->Value().CompareF(aParamMustNotMatch2) != 0)))
)
{
CDesCArray& items = *static_cast<CParserPropertyValueCDesCArray*>(property->Value())->Value();
const TInt fieldcount = items.Count();
// Create the address
address = CVCardAddress::NewLC(aMapping);
for(TInt jj = 0; jj < fieldcount; jj++)
{
const TPtrC pField(items.MdcaPoint(jj));
address->AddItemL(pField);
//
if (aOption & CContactVCardConverter::EIncludeX)
{
TBuf8<KContactMaxVCardPropertyNameLength> paramName(KContactVCardXDashEPOCCNTMODEL);
paramName.AppendFormat(KContactVCardLABELn, jj);
//
if (property->Param(paramName))
{
HBufC* value = property->Param(paramName)->ValueL();
CleanupStack::PushL(value);
address->AddLabelL(*value);
CleanupStack::PopAndDestroy(value);
}
}
}
// End for-loop now we've found the specified item
break;
}
}
// Have to push something to ensure cleanup stack is balanced
if (!address)
CleanupStack::PushL((TAny*) NULL);
return address;
}
/**
* Extract home and work address properties from the vCard
*
* @param aVCard vCard parser object
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aAddresses An array reference which contains any located address fields upon exit from this method
*/
void CVCardToContactsAppConverter::GetAddressesL(CParserVCard& aVCard, TInt aOption, RPointerArray<CVCardAddress>& aAddresses)
{
CArrayPtr<CParserProperty>* arrayOfProperties = aVCard.ArrayOfProperties(EFalse);
if (arrayOfProperties)
{
// Find ADR;HOME
CVCardAddress* home = GetSpecifiedAddressLC(*arrayOfProperties,
aOption,
KVersitParam8Home, // Must be ADR;HOME and not ADR;HOME;WORK
KVersitParam8Work,
KNullDesC8,
KUidContactFieldVCardMapHOME
);
if (home)
User::LeaveIfError(aAddresses.Append(home));
CleanupStack::Pop(home);
// Find ADR;WORK
CVCardAddress* work = GetSpecifiedAddressLC(*arrayOfProperties,
aOption,
KVersitParam8Work, // Must be ADR;WORK
KNullDesC8,
KNullDesC8,
KUidContactFieldVCardMapWORK
);
if (work)
User::LeaveIfError(aAddresses.Append(work));
CleanupStack::Pop(work);
// Find ADR;PREF
CVCardAddress* pref = GetSpecifiedAddressLC(*arrayOfProperties,
aOption,
KVersitParam8Pref, // Must be ADR;PREF and not ADR;HOME or ADR;WORK
KVersitParam8Home,
KVersitParam8Work,
KUidContactFieldVCardMapPREF
);
if (pref)
User::LeaveIfError(aAddresses.Append(pref));
CleanupStack::Pop(pref);
// Find general ADR: address
CVCardAddress* general = GetSpecifiedAddressLC(*arrayOfProperties,
aOption,
KNullDesC8, // Just has to be ADR
KVersitParam8Home,
KVersitParam8Work,
KNullUid
);
if (general)
User::LeaveIfError(aAddresses.Append(general));
CleanupStack::Pop(general);
}
}
/**
* Map vCard property to contacts field content and storage type
*
* @param aVCardProperty vCard property
* @param aStorageType Type of contact field storage (TStorageType)
* @return Content type for vCard property
*/
CContentType* CVCardToContactsAppConverter::MapVCardPropertyToContentAndStorageTypeL(const CParserProperty& aVCardProperty, TStorageType& aStorageType)
{
TUid mapping=KUidContactFieldNone;
TFieldType fieldType=KUidContactFieldNone;
TPtrC8 vpropNameConst = aVCardProperty.Name();
aStorageType=KStorageTypeStore;
switch (aVCardProperty.Value()->Uid().iUid)
{
case KVersitPropertyCDesCArrayUid:
{
aStorageType=KStorageTypeText;
if (vpropNameConst.CompareF(KVersitTokenN)==0)
{
fieldType=KUidContactFieldFamilyName;
mapping=KUidContactFieldVCardMapUnusedN;
}
else if (vpropNameConst.CompareF(KVersitTokenADR)==0)
{
fieldType=KUidContactFieldAddress;
mapping=KUidContactFieldVCardMapADR;
}
else if (vpropNameConst.CompareF(KVersitTokenChildren) == 0)
{
mapping = KUidContactFieldVCardMapChildren;
fieldType = KUidContactFieldChildren;
}
}
break;
case KVersitPropertyDateTimeUid:
aStorageType=KStorageTypeDateTime;
if (vpropNameConst.CompareF(KVersitTokenREV)==0)
mapping=KUidContactFieldVCardMapNotRequired;
break;
case KVersitPropertyDateUid:
aStorageType=KStorageTypeDateTime;
if (vpropNameConst.CompareF(KVersitTokenBDAY)==0)
{
mapping=KUidContactFieldVCardMapBDAY;
fieldType=KUidContactFieldBirthday;
}
else if (vpropNameConst.CompareF(KVersitTokenAnniversary) == 0)
{
mapping = KUidContactFieldVCardMapAnniversary;
fieldType = KUidContactFieldAnniversary;
}
break;
case KVCardPropertyAgentUid:
aStorageType = KStorageTypeContactItemId ;
if (vpropNameConst.CompareF(KVersitTokenAGENT) == 0)
{
mapping = KUidContactFieldVCardMapAGENT;
}
break;
case KVersitPropertyTimeZoneUid:
aStorageType=KStorageTypeStore;
if(vpropNameConst.CompareF(KVersitTokenTZ) == 0)
{
mapping=KUidContactFieldVCardMapNotRequired;
}
break;
//////////////
default: // aka case KVersitPropertyHBufCUid:
aStorageType=KStorageTypeText;
mapping = KUidContactFieldVCardMapUnknown; // Initialize to something sensible
switch (vpropNameConst[0])
{
case 'B':
case 'b':
if (vpropNameConst.CompareF(KVersitTokenBDAY)==0)
{
mapping=KUidContactFieldVCardMapBDAY;
fieldType=KUidContactFieldBirthday;
}
break;
case 'E':
case 'e':
if (vpropNameConst.CompareF(KVersitTokenEMAIL)==0)
{
fieldType=KUidContactFieldEMail;
mapping=KUidContactFieldVCardMapEMAILINTERNET;
}
break;
case 'F':
case 'f':
if (vpropNameConst.CompareF(KVersitTokenFN)==0)
mapping=KUidContactFieldVCardMapUnusedFN;
break;
case 'G':
case 'g':
if (vpropNameConst.CompareF(KVersitTokenGEO)==0)
{
fieldType=KUidContactFieldGEO;
mapping=KUidContactFieldVCardMapGEO;
}
break;
case 'K':
case 'k':
if (vpropNameConst.CompareF(KVersitTokenKEY)==0)
{
if(aVCardProperty.Value()->Uid().iUid == KVersitPropertyBinaryUid)
{
aStorageType = KStorageTypeStore;
}
mapping=KUidContactFieldVCardMapKEY;
}
break;
case 'L':
case 'l':
if (vpropNameConst.CompareF(KVersitTokenLABEL)==0)
mapping=KUidContactFieldVCardMapLABEL;
else if (vpropNameConst.CompareF(KVersitTokenLOGO)==0)
{
aStorageType=KStorageTypeStore;
mapping=KUidContactFieldVCardMapLOGO;
}
break;
case 'M':
case 'm':
if (vpropNameConst.CompareF(KVersitTokenMAILER)==0)
mapping=KUidContactFieldVCardMapMAILER;
break;
case 'N':
case 'n':
if (vpropNameConst.CompareF(KVersitTokenNOTE)==0)
{
fieldType=KUidContactFieldNote;
mapping=KUidContactFieldVCardMapNOTE;
}
break;
case 'P':
case 'p':
if (vpropNameConst.CompareF(KVersitTokenPHOTO)==0)
{
mapping=KUidContactFieldVCardMapPHOTO;
aStorageType=KStorageTypeStore;
}
break;
case 'R':
case 'r':
if (vpropNameConst.CompareF(KVersitTokenROLE)==0)
mapping=KUidContactFieldVCardMapROLE;
break;
case 'S':
case 's':
if (vpropNameConst.CompareF(KVersitTokenSOUND)==0)
{
if(aVCardProperty.Param(KVersitParam8CompanyPrn))
{
mapping = KUidContactFieldVCardMapORGPronunciation;
fieldType=KUidContactFieldCompanyNamePronunciation;
}
else if(aVCardProperty.Param(KVersitParam8NamePrn))
{// this is handled elsewhere
mapping = KUidContactFieldVCardMapNotRequired;
}
else // if we ever support any of the other pronunication extensions we'd have to add the checking here
{
mapping=KUidContactFieldVCardMapSOUND;
}
}
break;
case 'T':
case 't':
if (vpropNameConst.CompareF(KVersitTokenTEL)==0)
{
fieldType=KUidContactFieldPhoneNumber;
mapping=KUidContactFieldVCardMapTEL;
}
else if (vpropNameConst.CompareF(KVersitTokenTITLE)==0)
{
fieldType=KUidContactFieldJobTitle;
mapping=KUidContactFieldVCardMapTITLE;
}
else if (vpropNameConst.CompareF(KVersitTokenTZ)==0)
{
mapping=KUidContactFieldVCardMapNotRequired;
}
break;
case 'U':
case 'u':
if (vpropNameConst.CompareF(KVersitTokenURL)==0)
{
mapping=KUidContactFieldVCardMapURL;
fieldType=KUidContactFieldUrl;
}
else if (vpropNameConst.CompareF(KVersitTokenUID)==0)
{
mapping=KUidContactFieldVCardMapNotRequired;
}
break;
case 'V':
case 'v':
if (vpropNameConst.CompareF(KVersitTokenVERSION)==0)
{
mapping=KUidContactFieldVCardMapNotRequired;
}
break;
case 'X':
case 'x':
if (vpropNameConst.CompareF(KVersitTokenSECONDNAME)==0)
{
mapping=KUidContactFieldVCardMapSECONDNAME;
fieldType=KUidContactFieldSecondName;
}
else if (vpropNameConst.CompareF(KVersitTokenSIPID)==0)
{
mapping=KUidContactFieldVCardMapSIPID;
fieldType=KUidContactFieldSIPID;
}
else if (vpropNameConst.CompareF(KVersitTokenWVID)==0)
{
mapping=KUidContactFieldVCardMapWV;
fieldType=KUidContactFieldIMAddress;
}
else if (vpropNameConst.CompareF(KVersitTokenAssistant) == 0)
{
mapping = KUidContactFieldVCardMapAssistant;
fieldType = KUidContactFieldAssistant;
}
else if (vpropNameConst.CompareF(KVersitTokenAssistantTel) == 0)
{
mapping = KUidContactFieldVCardMapAssistantTel;
fieldType = KUidContactFieldPhoneNumber;
}
else if (vpropNameConst.CompareF(KVersitTokenAnniversary) == 0)
{
mapping = KUidContactFieldVCardMapAnniversary;
fieldType = KUidContactFieldAnniversary;
}
else if (vpropNameConst.CompareF(KVersitTokenSpouse) == 0)
{
mapping = KUidContactFieldVCardMapSpouse;
fieldType = KUidContactFieldSpouse;
}
else if (vpropNameConst.Length()>=2)
{
if (vpropNameConst.Left(2).CompareF(KVersitTokenXDash)==0)
mapping=KUidContactFieldVCardMapUnknownXDash;
else
mapping=KUidContactFieldVCardMapUnknown;
}
break;
default:
break; // Leave mapping set to KUidContactFieldVCardMapUnknown
};
};
CContentType* type=CContentType::NewL();
CleanupStack::PushL( type );
type->SetMapping(mapping);
if (mapping==KUidContactFieldVCardMapPHOTO || mapping==KUidContactFieldVCardMapLOGO)
{
type->AddFieldTypeL(KUidContactFieldPicture);
TFieldType bitmapFormat;
GetBitMapFormat(aVCardProperty, bitmapFormat);
if (bitmapFormat.iUid!=KUidContactFieldNone.iUid)
{
type->AddFieldTypeL(bitmapFormat);
}
}
if(fieldType!=KUidContactFieldNone)
{
type->AddFieldTypeL(fieldType);
}
CArrayPtr<CParserParam>* paramArray = NULL ;
paramArray = aVCardProperty.ParamArray();
// parameters
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Internet))
{
type->AddFieldTypeL(KUidContactFieldVCardMapINTERNET);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Home))
{
type->AddFieldTypeL(KUidContactFieldVCardMapHOME);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Work))
{
type->AddFieldTypeL(KUidContactFieldVCardMapWORK);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Voice))
{
type->AddFieldTypeL(KUidContactFieldVCardMapVOICE);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Fax))
{
type->RemoveFieldType(KUidContactFieldPhoneNumber);
type->AddFieldTypeL(KUidContactFieldFax);
type->AddFieldTypeL(KUidContactFieldVCardMapFAX);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Pref))
{
type->AddFieldTypeL(KUidContactFieldVCardMapPREF);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Cell))
{
type->AddFieldTypeL(KUidContactFieldVCardMapCELL);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Pager))
{
type->AddFieldTypeL(KUidContactFieldVCardMapPAGER);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Bbs))
{
type->AddFieldTypeL(KUidContactFieldVCardMapBBS);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Modem))
{
type->AddFieldTypeL(KUidContactFieldVCardMapMODEM);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Car))
{
type->AddFieldTypeL(KUidContactFieldVCardMapCAR);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Isdn))
{
type->AddFieldTypeL(KUidContactFieldVCardMapISDN);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Video))
{
type->AddFieldTypeL(KUidContactFieldVCardMapVIDEO);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Msg))
{
type->AddFieldTypeL(KUidContactFieldVCardMapMSG);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8Dom))
{
type->AddFieldTypeL(KUidContactFieldVCardMapDOM);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8X509))
{
type->AddFieldTypeL(KUidContactFieldVCardMapX509);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParam8PGP))
{
type->AddFieldTypeL(KUidContactFieldVCardMapPGP);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParamPOC))
{
type->AddFieldTypeL(KUidContactFieldVCardMapPOC);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParamSWIS))
{
type->AddFieldTypeL(KUidContactFieldVCardMapSWIS);
}
if (IsParameterValuePresent(paramArray, KVersitTokenTYPE, KVersitParamVOIP))
{
type->AddFieldTypeL(KUidContactFieldVCardMapVOIP);
}
CleanupStack::Pop(type);
return(type);
}
/*
* Gets the bitmap format. This is done by looking for the name and value items in the parameter eg. TYPE=GIF
* the if construct assumes that this is present in the vcf file. It is also possible to just have the format without
* the TYPE string and this is stored in the name part of the parameter so need to check through all supported formats
* to find if one is present, this is done in the else construct.
*
* @param aVCardProperty and aBitmapFormat
* @return void.
*/
void CVCardToContactsAppConverter::GetBitMapFormat(const CParserProperty& aVCardProperty, TFieldType& aBitmapFormat)
{
aBitmapFormat.iUid=KUidContactFieldNone.iUid;
CParserParam* param=aVCardProperty.Param(KVersitTokenTYPE);
if (param)
{
TFieldType bitmapFormat=MapVCardPhotoTypeToFieldType(param->Value());
if (bitmapFormat.iUid!=KUidContactFieldNone.iUid)
{
aBitmapFormat.iUid = bitmapFormat.iUid;
}
} //if
else
{
const TInt KNumberOfBitmaps = 16;
//Set up table of bitmap formats
const TBufC8<5> bitmapString[] =
{
KVersitParam8Gif(),
KVersitParam8Jpeg(),
KVersitParam8Bmp(),
KVersitParam8Tiff(),
KVersitParam8Pict(),
KVersitParam8Cgm(),
KVersitParam8Wmf(),
KVersitParam8Ps(),
KVersitParam8Pdf(),
KVersitParam8Mpeg(),
KVersitParam8Mpeg2(),
KVersitParam8Avi(),
KVersitParam8Qtime(),
KVersitParam8Dib(),
KVersitParam8Pmb(),
KVersitParam8Met()
};
// Loop through the table looking for a param whose name matches the bitmap format
for (TInt i=0; i < KNumberOfBitmaps - 1; ++i)
{
CParserParam* paramNameCheck = aVCardProperty.Param(bitmapString[i]);
if (paramNameCheck)
{//ok found something
TFieldType bitmapFormat=MapVCardPhotoTypeToFieldType(paramNameCheck->Name());
aBitmapFormat.iUid = bitmapFormat.iUid;
break;
}
}
} //else
}
TFieldType CVCardToContactsAppConverter::MapVCardPhotoTypeToFieldType(/*const CParserParam& aParserParam*/TPtrC8 aBitmapStringPtr)
{
if (aBitmapStringPtr.Length()<2)
{
return KUidContactFieldNone; //no bitmap type token are less than 2 characters long
}
TChar firstChar(aBitmapStringPtr[0]);
firstChar=firstChar.GetUpperCase();
switch (firstChar)
{
case 'G':
return KUidContactFieldVCardMapGIF;
case 'C':
return KUidContactFieldVCardMapCGM;
case 'W':
return KUidContactFieldVCardMapWMF;
case 'B':
return KUidContactFieldVCardMapBMP;
case 'D':
return KUidContactFieldVCardMapDIB;
case 'P':
{
TChar secondChar(aBitmapStringPtr[1]);
switch (secondChar.GetUpperCase())
{
case 'S':
return KUidContactFieldVCardMapPS;
case 'M':
return KUidContactFieldVCardMapPMB;
case 'D':
return KUidContactFieldVCardMapPDF;
case 'I':
return KUidContactFieldVCardMapPICT;
default:
return KUidContactFieldNone;
}
}
case 'T':
return KUidContactFieldVCardMapTIFF;
case 'J':
return KUidContactFieldVCardMapJPEG;
case 'M':
switch (aBitmapStringPtr.Length())
{
case 3:
return KUidContactFieldVCardMapMET;
case 4:
return KUidContactFieldVCardMapMPEG;
case 5:
return KUidContactFieldVCardMapMPEG2;
default:
return KUidContactFieldNone;
}
case 'A':
return KUidContactFieldVCardMapAVI;
case 'Q':
return KUidContactFieldVCardMapQTIME;
default:
return KUidContactFieldNone;
}
}
/**
* Checks each field in an array to see if one or more contain importable data. Assuming one field within
* the array does, then the whole array should be imported.
*
* @param aArray The array of text fields to be checked for importable data
* @return Whether the array should be imported.
*/
TBool CVCardToContactsAppConverter::TextArrayContainsImportableData(const CDesCArray& aArray) const
{
// Text arrays are implicitly composite in nature
const TInt count = aArray.Count();
for(TInt i=0; i<count; i++)
{
const TPtrC pItem(aArray.MdcaPoint(i));
if (CContactVCardConverter::ContainsImportableData(pItem, CContactVCardConverter::EPropertyValueComposite, ImportType()))
return ETrue;
}
//
return EFalse;
}
/**
* Remove single space character entries from the specified composite property array and replace them
* with null values.
*
* The TimeIS sync engines use spaces and NULLs to indicate special behaviour. Space = supported
* but empty property. NULL = unsupported property.
*
* Contacts model fields do not support composite properties themselves. Instead, the following
* method is used to converted a composite (array) property to a non composite value:
*
* CContactTextField::SetStandardTextArray(...)
*
* This method simply concatenates all the array values into one non-composite value. A CRLF
* is added between each sub-field. Therefore, if a composite property reads thus:
*
* {"A","B"}
*
* contacts model will store the result as "A\r\n\B".
*
* In the case where a composite property from TimeIS contains a supported but empty field value,
* without special handling, the space character (implicit meaning: "supported but empty")
* will be interpreted literally and stored within the contacts model field as real data.
*
* For example: {"Symbian"," "}
*
* The implied meaning of this (in terms of PC sync) is:
*
* OrgName: Symbian
* OrgUnit: (a supported field of the PC PIM, but contains no data at this time).
*
* In the above example, without special processing, the resultant contacts model field would read thus:
*
* "Symbian\r\n "
*
* The trailing space would also be exported during any synchronisation, and therefore introduce
* unexpected data in the sync chain.
*
* This method simply ensures that single space characters are mapped back to their 'real' meaning,
* i.e. a NULL.
*
* @param aArray The composite property which needs fixing up
*/
void CVCardToContactsAppConverter::RemoveWhitespaceFromCompositePropertyL(CDesCArray& aArray)
{
const TInt count = aArray.Count();
for(TInt i=0; i<count; i++)
{
TPtrC pItem(aArray[i]);
if (pItem == KContactVCardCompositeSupportedButEmptyFieldValue)
{
aArray.Delete(i);
aArray.InsertL(i, KContactVCardEmptyFieldValue);
}
}
}
/**
* Get a Pointer to the First Instance of the specified Property's value in the VCard Object
*
* @param aVCard A vCard Object containing Array of Properties
* @param aToken A String with desired Property Name
* @param A buffer descriptor expected to contain the first instance of desired property Value on return
* @return Count of Class Properties found
*/
TInt CVCardToContactsAppConverter::GetSingleInstanceL(const CParserVCard& aVCard,const TDesC8& aToken, TDes& aClass)
{
CArrayPtr<CParserProperty>* arrayOfProp=aVCard.PropertyL(aToken, TUid::Uid(KVersitPropertyHBufCUid), EFalse);
if(arrayOfProp)
{
CleanupStack::PushL(arrayOfProp);
TInt propCount = arrayOfProp->Count();
CParserProperty* property = arrayOfProp->At(0);
CParserPropertyValueHBufC* propertyAsHBufC = static_cast<CParserPropertyValueHBufC*>(property->Value());
aClass = propertyAsHBufC->Value();
if( !aClass.Length() )
{
propCount = 0;
}
CleanupStack::PopAndDestroy(arrayOfProp);
return propCount;
}
return 0;
}
/**
* Add a specific field into a contact
*
* @param aContact Contact item to add fields to
* @param aValue Reference to first Instance of the Property Value
* @param aFieldType Field type of field to add (TFieldType)
* @param aMapping vCard mapping Id of the field to add.
* @param aNames An object containing the name and labels for 'N' property fields
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
void CVCardToContactsAppConverter::SetSingleInstanceL(CContactItem& aContact,const TDes& aValue,const TFieldType& aFieldType, const TUid& aMapping, TInt aOption)
{
//
TBool addField = EFalse;
if (CContactVCardConverter::EConnectWhitespace & aOption)
{
addField = CContactVCardConverter::ContainsImportableData(aValue, CContactVCardConverter::EPropertyValueSingle, ImportType());
}
else
{
addField = (aValue.Length());
}
// Only add the field if it contains some data
if (addField)
{
CContactItemField* contactItemField = CContactItemField::NewLC(KStorageTypeText, aFieldType);
contactItemField->SetMapping(aMapping);
contactItemField->TextStorage()->SetStandardTextL(aValue);
aContact.AddFieldL(*contactItemField);
CleanupStack::Pop(contactItemField);
}
}
/**
* Merge a specific field from a contact
*
* @param aContact Contact item to add fields to
* @param aValue Pointer to first Instance of the Property Value
* @param aFieldType Field type of field to add (TFieldType)
* @param aMapping vCard mapping Id of the field to add.
* @param aNames An object containing the name and labels for 'N' property fields
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
void CVCardToContactsAppConverter::MergeSingleInstanceL(CContactItem& aContact, const TDes& aValue,const TFieldType& aFieldType, const TUid& aMapping, TInt aOption)
{
CContactItemFieldSet& oldfieldset = aContact.CardFields();
const TInt pos = oldfieldset.Find(aFieldType, aMapping);
const TBool processWhitespace = (aOption & CContactVCardConverter::EConnectWhitespace);
// First check whether the field is present in the contact card
// Also verify that the array of address sub-values actually contains a specific
// value for the requested index.
const TInt Klength = aValue.Length();
if (processWhitespace)
{
TBool isSingleSpace = EFalse;
if (Klength == 1)
{
isSingleSpace = (aValue[0] == KContactVCardSpaceCharacter);
}
if ((pos != KErrNotFound) && (Klength || isSingleSpace))
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (Klength && !isSingleSpace)
{
// This means the PC side field is unsupported, so ignore the corresponding contents.
SetSingleInstanceL(aContact, aValue, aFieldType,aMapping,aOption);
}
}
else
{
if (pos != KErrNotFound)
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (Klength)
{
// This means the PC side field is not empty, so add the corresponding contents.
SetSingleInstanceL(aContact, aValue, aFieldType,aMapping,aOption);
}
}
}
/**
* Get an Array containing Property's values from a VCard
*
* @param aVCard A vCard Object containing Array of Properties
* @param aToken A String with desired Property Name
* @param A Composite Descriptor array with desired vCard Property's Values on return
* @return Count of desired properties found.
*/
TInt CVCardToContactsAppConverter::GetVCardPropertyAsArrayOfValuesL(const CParserVCard& aVCard, const TDesC8& aToken, CDesCArray& aItems)
{
CArrayPtr<CParserProperty>* arrayOfProp =aVCard.PropertyL(aToken,TUid::Uid(KVersitPropertyCDesCArrayUid),EFalse);
TInt propCount = 0;
if(arrayOfProp)
{
CleanupStack::PushL(arrayOfProp);
propCount = arrayOfProp->Count();
CParserProperty* property = arrayOfProp->At(0);
CDesCArray& value = *static_cast<CParserPropertyValueCDesCArray*>(property->Value())->Value();
if(value.Count())
{
for(TInt i = 0;i < value.Count();i++)
{
aItems.AppendL(value.MdcaPoint(i));
}
}
else
{
propCount = 0;
}
CleanupStack::PopAndDestroy(arrayOfProp);
}
return propCount;
}
/**
* Add Organization Information like Company Name and Department Name into contact
*
* @param aContact Contact item to add fields to
* @param aItems A CDesC Array containing the Property's value
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
*/
void CVCardToContactsAppConverter::SetOrgDetailsL(CContactItem& aContact,CDesCArray& aItems,const TInt aOption)
{
TInt orgCount = aItems.MdcaCount();
SetSpecificFieldL(aContact, aItems, KUidContactFieldCompanyName, KUidContactFieldVCardMapORG, aOption, 0, 1);
SetSpecificFieldL(aContact, aItems, KUidContactFieldDepartmentName, KUidContactFieldVCardMapDepartment, aOption, 1, orgCount);
}
/**
* Add a specific field from the Array of Property's values into contact
*
* @param aContact Contact item to add fields to
* @param aItems A CDesC Array containing the Property's values
* @param aFieldType Field type of field to add (TFieldType)
* @param aMapping vCardMapping Id of field to add
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aStartIndex Starting Index in the Property Value Array
* @param aEndIndex Ending Index in the Property Value Array
*/
void CVCardToContactsAppConverter::SetSpecificFieldL(CContactItem& aContact,CDesCArray& aItems,const TUid& aFieldType,const TUid& aMapping,TInt aOption, TInt aStartIndex, TInt aEndIndex)
{
TBool doConvert = ETrue;
TInt ii = 0;
CDesCArrayFlat* orgList = new (ELeave)CDesCArrayFlat(4);
CleanupStack::PushL(orgList);
for (ii = aStartIndex;ii < aEndIndex;ii++)
{
orgList->AppendL(aItems.MdcaPoint(ii));
}
if ((CContactVCardConverter::EConnectWhitespace & aOption) && orgList)
{
doConvert = TextArrayContainsImportableData(*orgList);
if (doConvert)
{
RemoveWhitespaceFromCompositePropertyL(*orgList);
}
}
if (doConvert)
{
CContactItemField* contactItemField = CContactItemField::NewLC(KStorageTypeText, aFieldType);
contactItemField->SetMapping(aMapping);
contactItemField->TextStorage()->SetStandardTextArray(orgList);
aContact.AddFieldL(*contactItemField);
CleanupStack::Pop(contactItemField);
}
CleanupStack::PopAndDestroy(orgList); // orgList
}
/**
* Merge Organization Information like Company Name and Department Name into contact
*
* @param aContact Contact item to add fields to
* @param aItems A CDesC Array containing the Property's value
* @param aFieldType Field type of field to add (TFieldType)
* @param aMapping vCardMapping Id of field to add
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aStartIndex Starting Index in the Property Value Array
* @param aEndIndex Ending Index in the Property Value Array
*/
void CVCardToContactsAppConverter::MergeOrgDetailsL(CContactItem& aContact, CDesCArray& aItems, TInt aOption)
{
TInt orgCount = aItems.MdcaCount();
MergeSpecificFieldL(aContact, aItems, KUidContactFieldCompanyName, KUidContactFieldVCardMapORG, aOption, 0, 1);
MergeSpecificFieldL(aContact, aItems, KUidContactFieldDepartmentName, KUidContactFieldVCardMapDepartment, aOption, 1, orgCount);
}
/**
* Merge specific Field from the array of Property's values into contact
*
* @param aContact Contact item to add fields to
* @param aItems A CDesC Array containing the Property's value
* @param aFieldType Field type of field to add (TFieldType)
* @param aMapping vCardMapping Id of field to add
* @param aOption Import preferences (available options defined in CContactDatabase::TOptions)
* @param aStartIndex Starting Index in the Property Value Array
* @param aEndIndex Ending Index in the Property Value Array
*/
void CVCardToContactsAppConverter::MergeSpecificFieldL(CContactItem& aContact, CDesCArray& aItems, const TFieldType& aFieldType, const TUid& aMapping, TInt aOption, TInt aStartIndex, TInt aEndIndex)
{
CContactItemFieldSet& oldfieldset = aContact.CardFields();
const TInt pos = oldfieldset.Find(aFieldType, aMapping);
const TBool processWhitespace = (aOption & CContactVCardConverter::EConnectWhitespace);
// First check whether the field is present in the contact card
// Also verify that the array of address sub-values actually contains a specific
// value for the requested index.
if(aItems.MdcaCount() > aStartIndex)
{
const TPtrC pValue = aItems.MdcaPoint(aStartIndex);
const TInt Klength = pValue.Length();
if (processWhitespace)
{
TBool isSingleSpace = EFalse;
if (Klength == 1)
{
isSingleSpace = (pValue[0] == KContactVCardSpaceCharacter);
}
if ((pos != KErrNotFound) && (Klength || isSingleSpace))
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (Klength && !isSingleSpace)
{
// This means the PC side field is unsupported, so ignore the corresponding contents.
SetSpecificFieldL(aContact, aItems, aFieldType, aMapping, aOption, aStartIndex, aEndIndex);
}
}
else
{
if (pos != KErrNotFound)
{
// This means the PC side field is empty, so delete the corresponding device-side field.
aContact.RemoveField(pos);
}
if (Klength)
{
// This means the PC side field is not empty, so add the corresponding contents.
SetSpecificFieldL(aContact, aItems, aFieldType, aMapping, aOption, aStartIndex, aEndIndex);
}
}
}
else if(pos != KErrNotFound)
{
aContact.RemoveField(pos);
}
}
/**
* Check if a specific field from vCard should be truncated or not.
*
* @param aPropertyName vCard property's name
*
* @return ETrue if the property must be truncated and EFalse otherwise
*
*/
TBool CVCardToContactsAppConverter::PropertyTobeTruncated(const TPtrC8& aPropertyName) const
{
//Test is the field is one that has to be truncated
if( aPropertyName == KVersitTokenN || aPropertyName == KVersitTokenORG ||
aPropertyName == KVersitTokenTEL || aPropertyName == KVersitTokenEMAIL )
return ETrue;
//
return EFalse;
}
/**
* Check if a specific parameter value exists in a parameter array.
*
* @param aParamArray Array of property parameters in which value has to be searched.
* @param aParamName A parameter name whose corresponding parameter value present in aParamArray has to be matched with aParamValue.
* @param aParamValue A parameter value which will be used to search.
* @return TBool ETrue if value is found in parameter array, otherwise EFalse.
*/
TBool CVCardToContactsAppConverter::IsParameterValuePresent(CArrayPtr<CParserParam>* aParamArray, const TDesC8& aParamName, const TDesC8& aParamValue)
{
if(!aParamArray)
{
return EFalse;
}
const TInt count = aParamArray->Count();
for (TInt ii = 0; ii < count; ii++)
{
if((*aParamArray)[ii]->Name().CompareF(aParamValue) == 0)
{
return ETrue;
}
else if((*aParamArray)[ii]->Name().CompareF(aParamName) == 0)
{
if((*aParamArray)[ii]->Value().CompareF(aParamValue) == 0)
{
return ETrue;
}
}
}
return EFalse;
}
/**
* If there are multiple EMAIL and TEL properties in a vCard, then there should only be a single EMAIL or TEL property
* with a PREF parameter. If more than one EMAIL or TEL properties contain a PREF parameter,then only the first property
* with the PREF parameter is stored and the other properties are stored with their other parameters but without the
* PREF parameter.
*
* @param aMainContact, Contact item for the vCard
* @param aFieldType, the fieldtype in conjuction with the mapping is used to search for fields.
* @param aMapping, the mapping is used for searching a field i.e. EMAIL or TEL fields.
*/
void CVCardToContactsAppConverter::AdjustForPrefRule(CContactItem& aContact, TFieldType aFieldType, TUid aMapping)
{
TInt pos = 0;
TInt prefCount = 0;
CContactItemFieldSet& contactItemFieldSet = aContact.CardFields();
pos = contactItemFieldSet.FindNext(aFieldType, aMapping, pos);
while (pos != KErrNotFound)
{
CContactItemField& contactItemField = contactItemFieldSet[pos];
const CContentType& contentType = contactItemField.ContentType();
TBool pref = contentType.ContainsFieldType(KUidContactFieldVCardMapPREF);
if (pref)
{
++prefCount;
if (prefCount > 1)
{
contactItemField.RemoveFieldType(KUidContactFieldVCardMapPREF);
}
}
++pos;
pos = contactItemFieldSet.FindNext(aFieldType, aMapping, pos);
}
}