/*

* Copyright (c) 2008 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:  Handles conversion between PIM API Contact Items and Contacts

 *                Model Contact Cards

 *

*/

// CLASS HEADER

#include "cpimcontactitemadapter.h"

// INTERNAL INCLUDES

#include "cpimcontactcategorymanager.h"

#include "pimpanics.h"

#include "mpimcontactitem.h"

#include "mpimitemdata.h"

#include "cpimimagescaler.h"

#include "cpimcontactfieldinfo.h"

#include "logger.h"

// EXTERNAL INCLUDES

#include <cntitem.h> // CContactCard etc.

#include <cntfldst.h> // CContactTextField etc.

#include <tz.h>

#include <tzconverter.h>

// UNNAMED LOCAL NAMESPACE

namespace

{

// Phonebook maps Syncronisation field values with specified

// hard-coded string values. At the time implementing, the header

// was not exported so it is necessary to define own constants

// with same values

_LIT(KPIMContactClassPrivate, "private");

_LIT(KPIMContactClassPublic, "public");

_LIT(KPIMContactClassConfidential, "none");

}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CPIMContactItemAdapter* CPIMContactItemAdapter::NewL(

    CPIMContactCategoryManager& aCategoryManager)

{

    JELOG2(EPim);

    CPIMContactItemAdapter* self =

        new(ELeave) CPIMContactItemAdapter(aCategoryManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

// destructor

CPIMContactItemAdapter::~CPIMContactItemAdapter()

{

    JELOG2(EPim);

    delete iImageScaler;

    delete iFieldInfo;

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::CardL

// Converts from a PIM item data to a Contacts Model contact card.

// Returns: A contact card with the same information as given in

//          the parameter item. The ownership of the card is

//          transferred to the caller.

// -----------------------------------------------------------------------------

//

CContactCard* CPIMContactItemAdapter::CardL(const MPIMContactItem& aItem)

{

    JELOG2(EPim);

    CContactCard* card = CContactCard::NewLC();

    const MPIMItemData& item = aItem.ItemData();

    __ASSERT_DEBUG((aItem.ContactItemIdL() == 0), User::Panic(

                       KPIMPanicCategory, EPIMPanicInvalidItemID));

    CArrayFix<TPIMField>* fields = item.FieldsLC();

    TInt fieldCount = fields->Count();

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

    {

        ConvertFieldL(aItem, *card,

                      static_cast<TPIMContactField>(fields->At(i)));

    }

    // Set default values if not present in PIM item

    if (item.CountValues(EPIMContactClass) == 0)

    {

        CContentType* type = CContentType::NewL(KUidContactFieldClass,

                                                KUidContactFieldVCardMapClass);

        CleanupStack::PushL(type);

        // Add value to the contact field

        CContactItemField* field = CContactItemField::NewLC(KStorageTypeText,

                                   *type);

        field->SetUserFlags(EContactCategoryNone);

        CContactTextField* textField = field->TextStorage();

        textField->SetTextL(KPIMContactClassPrivate());

        card->AddFieldL(*field);

        CleanupStack::Pop(field);

        CleanupStack::PopAndDestroy(type);

    }

    CleanupStack::PopAndDestroy(fields);

    CleanupStack::Pop(card);

    return card;

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::FillItemL

// Converts from a Contacts Model contact card to the PIM representation.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::FillItemL(MPIMContactItem& aItem, // Item data container to fill with the data

                                       const CContactCard& aCard) // Contact Card to convert

{

    JELOG2(EPim);

    // convert fields

    CContactItemFieldSet& fieldSet = aCard.CardFields();

    TInt fieldCount = fieldSet.Count();

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

    {

        ConvertFieldL(fieldSet[i], aItem);

    }

    // convert categories

    MPIMItemData& item = aItem.ItemData();

    CContactIdArray* groupArray = aCard.GroupsJoinedLC();

    TInt groupCount = groupArray->Count();

    for (TInt i = 0; i < groupCount; i++)

    {

        HBufC* label = iCategoryManager.GroupLabelL((*groupArray)[i]);

        CleanupStack::PushL(label);

        // Add item to this category if it doesn't belong to it already

        if (item.FindCategory(*label) == KErrNotFound)

        {

            item.AddNewCategoryL(*label);

        }

        CleanupStack::PopAndDestroy(label);

    }

    CleanupStack::PopAndDestroy(groupArray);

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::UpdateCardL

// Updates the data in the Contacts Model contact card to match

// the data in the PIM item data container.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::UpdateCardL(const MPIMContactItem& aItem, // Item from which the data is read

        CContactCard& aCard) // The card which is updated

{

    JELOG2(EPim);

    CleanCard(aCard);

    const MPIMItemData& itemData = aItem.ItemData();

    // Get fields

    CArrayFix<TPIMField>* fields = itemData.FieldsLC();

    TInt fieldCount = fields->Count();

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

    {

        ConvertFieldL(aItem, aCard, (TPIMContactField)(fields->At(i)));

    }

    CleanupStack::PopAndDestroy(); // fields

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::UpdateCategoriesL

// Updates the category information in the database.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::UpdateCategoriesL(const MPIMContactItem& aItem, // Item containing the new categories

        const CContactCard& aCard) // Item to update

{

    JELOG2(EPim);

    const CDesCArray& pimCategories = aItem.ItemData().Categories();

    const TInt pimCategoryCount = pimCategories.Count();

    TBool* newCategoryTable = new(ELeave) TBool[pimCategoryCount];

    CleanupArrayDeletePushL(newCategoryTable);

    TInt i = 0;

    for (i = 0; i < pimCategoryCount; i++)

    {

        newCategoryTable[i] = ETrue;

    }

    CContactIdArray* cardCategories = aCard.GroupsJoinedLC();

    TContactItemId id = aItem.ContactItemIdL();

    // first remove extra groups

    const TInt cardCategoryCount = cardCategories->Count();

    for (i = 0; i < cardCategoryCount; i++)

    {

        TContactItemId groupId = (*cardCategories)[i];

        HBufC* groupLabel = iCategoryManager.GroupLabelL(groupId);

        TInt pos;

        TInt found = pimCategories.Find(*groupLabel, pos, ECmpNormal);

        delete groupLabel;

        if (found != 0)

        {

            // removed group

            iCategoryManager.RemoveFromGroupL(id, groupId);

        }

        else

        {

            // old group

            newCategoryTable[pos] = EFalse;

        }

    }

    // then add new categories

    for (i = 0; i < pimCategoryCount; i++)

    {

        if (newCategoryTable[i])

        {

            TPtrC category = pimCategories[i];

            iCategoryManager.AddToGroupL(id, category);

        }

    }

    CleanupStack::PopAndDestroy(2); // cardCategories, newCategoryTable

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::ContactsModelFieldType

// Other items were commented in the header

// -----------------------------------------------------------------------------

//

CArrayFix<TInt>* CPIMContactItemAdapter::ContactsModelFieldTypeL(

    TPIMContactField aContactField) const

{

    JELOG2(EPim);

    return iFieldInfo->MatchPIMFieldL(aContactField);

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::CPIMContactItemAdapter

// C++ constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CPIMContactItemAdapter::CPIMContactItemAdapter(

    CPIMContactCategoryManager& aCategoryManager) :

        iCategoryManager(aCategoryManager)

{

    JELOG2(EPim);

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

inline void CPIMContactItemAdapter::ConstructL()

{

    JELOG2(EPim);

    iFieldInfo = CPIMContactFieldInfo::NewL();

    iImageScaler = CPIMImageScaler::NewL();

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::CleanCardL

// Deletes all the supported fields from the contact card.

// Those fields which are not supported are left as is.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::CleanCard(CContactCard& aCard)

{

    JELOG2(EPim);

    // convert fields

    CContactItemFieldSet& fieldSet = aCard.CardFields();

    TInt fieldCount = fieldSet.Count();

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

    {

        if (IsSupportedField(fieldSet[i]))

        {

            // as the field is removed, the array shrinks

            aCard.RemoveField(i--);

            fieldCount--;

        }

    }

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::IsSupportedFieldL

// Checks if we support this particular contact field.

// Returns:     ETrue if the field is supported

//              EFalse otherwise

// -----------------------------------------------------------------------------

//

TBool CPIMContactItemAdapter::IsSupportedField(CContactItemField& aField)

{

    JELOG2(EPim);

    const CContentType& type = aField.ContentType();

    if (type.FieldTypeCount() == 0)

    {

        // we don't support unknown types

        return EFalse;

    }

    TFieldType fieldTypeUid = type.FieldType(0);

    TInt fieldType = fieldTypeUid.iUid;

    switch (fieldType)

    {

    case KUidContactFieldAddressValue:

    {

        // Label addresses are also stored in the database using

        // KUidContactFieldAddressValue, but we don't support them

        if (type.ContainsFieldType(KUidContactFieldVCardMapADR))

        {

            return ETrue;

        }

        else

        {

            return EFalse;

        }

    }

    case KUidContactFieldPictureValue:

    {

        // Thumbnails are supported while pictures are not

        if (type.ContainsFieldType(KUidContactFieldVCardMapPHOTO))

        {

            return ETrue;

        }

        else

        {

            return EFalse;

        }

    }

    case KUidContactFieldSIPIDValue:

    case KUidContactFieldFamilyNameValue:

    case KUidContactFieldGivenNameValue:

    case KUidContactFieldSecondNameValue:

    case KUidContactFieldFamilyNamePronunciationValue:

    case KUidContactFieldGivenNamePronunciationValue:

    case KUidContactFieldAdditionalNameValue:

    case KUidContactFieldPrefixNameValue:

    case KUidContactFieldSuffixNameValue:

    case KUidContactFieldPhoneNumberValue:

    case KUidContactFieldFaxValue:

    case KUidContactFieldEMailValue:

    case KUidContactFieldUrlValue:

    case KUidContactFieldPostOfficeValue:

    case KUidContactFieldExtendedAddressValue:

    case KUidContactFieldPostCodeValue:

    case KUidContactFieldLocalityValue:

    case KUidContactFieldRegionValue:

    case KUidContactFieldCountryValue:

    case KUidContactFieldCompanyNameValue:

    case KUidContactFieldNoteValue:

    case KUidContactFieldBirthdayValue:

    case KUidContactFieldJobTitleValue:

    case KUidContactFieldDTMFValue:

    case KUidContactFieldIMAddressValue:

    case KUidContactFieldDepartmentNameValue:

    case KUidContactFieldAssistantValue:

    case KUidContactFieldChildrenValue:

    case KUidContactFieldSpouseValue:

    case KUidContactFieldAnniversaryValue:

    case KUidContactFieldClassValue:

    {

        return ETrue;

    }

    default:

    {

        return EFalse;

    }

    }

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::ConvertFieldL

// Converts a field from a PIM Item to a Contact Card.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::ConvertFieldL(const MPIMContactItem& aItem, // item to read the field from

        CContactCard& aCard, // card to write the field to

        TPIMContactField aField) // field to convert

{

    JELOG2(EPim);

    const MPIMItemData& itemData = aItem.ItemData();

    // These are indexes in PIM Item address values

    TInt plainAddressIndex = KErrNotFound;

    TInt homeAddressIndex = KErrNotFound;

    TInt workAddressIndex = KErrNotFound;

    if (aField == EPIMContactAddr)

    {

        AddressAttributesL(itemData, plainAddressIndex, homeAddressIndex,

                           workAddressIndex);

        ConvertAddressFieldL(itemData, aCard, aField, plainAddressIndex,

                             KPIMAttrNone);

        ConvertAddressFieldL(itemData, aCard, aField, homeAddressIndex,

                             EPIMContactAttrHome);

        ConvertAddressFieldL(itemData, aCard, aField, workAddressIndex,

                             EPIMContactAttrWork);

        return;

    }

    TInt valueCount = itemData.CountValues(aField);

    for (TInt i = 0; i < valueCount; i++)

    {

        switch (aField)

        {

        case EPIMContactUid:

        case EPIMContactRevision:

        {

            // uid and revision fields are totally ignored

            break;

        }

        case EPIMContactBirthday:

        case EPIMContactExtAnniversary:

        {

            ConvertDateFieldL(itemData, aCard, aField, i);

            break;

        }

        case EPIMContactEmail:

        case EPIMContactNickname:

        case EPIMContactNote:

        case EPIMContactOrg:

        case EPIMContactTel:

        case EPIMContactTitle:

        case EPIMContactUrl:

        case EPIMContactExtSip:

        case EPIMContactExtDtmf:

        case EPIMContactExtWvUserId:

        case EPIMContactExtDepartment:

        case EPIMContactExtAssistantName:

        case EPIMContactExtChildren:

        case EPIMContactExtSpouse:

        case EPIMContactExtVoip:

        case EPIMContactExtPTT:

        case EPIMContactExtSWIS:

        {

            ConvertStringFieldL(itemData, aCard, aField, i);

            break;

        }

        case EPIMContactName:

        {

            ConvertNameFieldL(itemData, aCard, aField, i);

            break;

        }

        case EPIMContactPhoto:

        {

            ConvertPhotoFieldL(itemData, aCard, aField, i);

            break;

        }

        case EPIMContactClass:

        {

            ConvertClassFieldL(itemData, aCard, aField, i);

            break;

        }

        case EPIMContactFormattedName:

        case EPIMContactFormattedAddr:

        case EPIMContactPhotoUrl:

        case EPIMContactPublicKey:

        case EPIMContactPublicKeyString:

        default:

        {

            __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,

                                               EPIMPanicUnsupportedField));

            return;

        }

        }

    }

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::ConvertFieldL

// Converts a field from a Contact Card to a PIM Item.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::ConvertFieldL(const CContactItemField& aField, // field to read data from

        MPIMContactItem& aItem) // field to write the data to

{

    JELOG2(EPim);

    TStorageType type = aField.StorageType();

    switch (type)

    {

    case KStorageTypeText:

    {

        ConvertTextFieldL(aField, aItem);

        break;

    }

    case KStorageTypeStore:

    {

        ConvertStoreFieldL(aField, aItem);

        break;

    }

    case KStorageTypeContactItemId:

    {

        break;

    }

    case KStorageTypeDateTime:

    {

        ConvertDateFieldL(aField, aItem);

        break;

    }

    default:

    {

        __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,

                                           EPIMPanicUnsupportedField));

    }

    }

}

// -----------------------------------------------------------------------------

// CPIMContactItemAdapter::ConvertTextFieldL

// Converts a text field from a Contact Card to a PIM Item.

// -----------------------------------------------------------------------------

//

void CPIMContactItemAdapter::ConvertTextFieldL(const CContactItemField& aField, // field to read data from

        MPIMContactItem& aItem) // field to write the data to

{