/*

* 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 PIM contact list <-> Contacts Model conversions

 *

*/

// CLASS HEADER

#include "cpimcontactlistadapter.h"

// INTERNAL INCLUDES

#include "cpimcontactcategorymanager.h"

#include "cpimcontactitemadapter.h"

#include "mpimcontactitem.h"

#include "mpimitemdata.h"

#include "logger.h"

// EXTERNAL INCLUDES

#include <badesca.h>

#include <cntdb.h>

#include <cntitem.h> // CContactGroup

#include <cntfilt.h> // CCntFilter

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

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

// CPIMContactListAdapter::NewL

// Two-phased constructor.

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

//

CPIMContactListAdapter* CPIMContactListAdapter::NewL(

    java::util::FunctionServer* aFuncServer)

{

    JELOG2(EPim);

    CPIMContactListAdapter* self =

        new(ELeave) CPIMContactListAdapter(aFuncServer);

    CallMethodL(self, &CPIMContactListAdapter::ConstructL, self->iFuncServer);

    return self;

}

// Destructor

CPIMContactListAdapter::~CPIMContactListAdapter()

{

    JELOG2(EPim);

    Close();

}

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

// CPIMContactListAdapter::HandleDatabaseEventL

// Tests the contact database observer event type and handles it. The ID of

// a contact affected by the change event, if relevant, can be retrieved

// via TContactDbObserverEvent::iContactId.

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

//

void CPIMContactListAdapter::HandleDatabaseEventL(

    TContactDbObserverEvent aEvent) // information about the change event

{

    JELOG2(EPim);

    switch (aEvent.iType)

    {

    case EContactDbObserverEventGroupAdded:

    {

        ExternalGroupChangeL(aEvent.iContactId, EPIMExternalChangeNew);

        break;

    }

    case EContactDbObserverEventGroupChanged:

    {

        ExternalGroupChangeL(aEvent.iContactId, EPIMExternalChangeModified);

        break;

    }

    case EContactDbObserverEventGroupDeleted:

    {

        ExternalGroupChangeL(aEvent.iContactId, EPIMExternalChangeRemoved);

        break;

    }

    case EContactDbObserverEventContactAdded:

    {

        ExternalItemChangeL(aEvent.iContactId, EPIMExternalChangeNew);

        break;

    }

    case EContactDbObserverEventContactChanged:

    {

        ExternalItemChangeL(aEvent.iContactId, EPIMExternalChangeModified);

        break;

    }

    case EContactDbObserverEventContactDeleted:

    {

        ExternalItemChangeL(aEvent.iContactId, EPIMExternalChangeRemoved);

        break;

    }

    default:

    {

        // we don't care about other changes

        return;

    }

    }

}

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

// CPIMContactListAdapter::GetCategoriesL

// Provides all categories currently existing in the native database.

// Returns: Array of categories

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

//

const CDesCArray& CPIMContactListAdapter::GetCategoriesL()

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iCategoryManager, User::Leave(KErrNotReady));

    return iCategoryManager->CallGetCategoriesL();

}

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

// CPIMContactListAdapter::AddCategoryL

// Adds a new category to the native database.

// If the category already  exists, nothing is done and the method returns

// successfully.

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

//

void CPIMContactListAdapter::AddCategoryL(const TDesC& aNewCategory)

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iCategoryManager, User::Leave(KErrNotReady));

    CallMethodL(iCategoryManager, &CPIMContactCategoryManager::AddCategoryL,

                aNewCategory, iFuncServer);

}

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

// CPIMContactListAdapter::DeleteCategoryL

// Deletes an existing category.

// If there is no such category, nothing is done and the method returns

// successfully.

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

//

void CPIMContactListAdapter::DeleteCategoryL(const TDesC& aCategory)

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iCategoryManager, User::Leave(KErrNotReady));

    CallMethodL(iCategoryManager, &CPIMContactCategoryManager::DeleteCategoryL,

                aCategory, iFuncServer);

}

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

// CPIMContactListAdapter::RenameCategoryL

// Renames an existing category.

// Entries in the old category are moved to the new category.

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

//

void CPIMContactListAdapter::RenameCategoryL(const TDesC& aOldCategory, // The old category name

        const TDesC& aNewCategory) // The new category name

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iCategoryManager, User::Leave(KErrNotReady));

    CallMethodL(iCategoryManager, &CPIMContactCategoryManager::RenameCategoryL,

                aOldCategory, aNewCategory, iFuncServer);

}

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

// CPIMContactListAdapter::IsCategoriesExternallyModified

// Checks whether there have been external changes to the categories in

// the native database after last call to

// GetExternalCategoryModifications or list adapter creation.

// Returns: ETrue: If there are any external changes

//          EFalse: Otherwise

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

//

TBool CPIMContactListAdapter::IsCategoriesExternallyModified()

{

    JELOG2(EPim);

    if (iCategoryChanges)

    {

        return ETrue;

    }

    return EFalse;

}

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

// CPIMContactListAdapter::GetExternalCategoryModificationsL

// Provides the external changes to the categories in the native database.

// Returns: An array of category state change objects. The ownership

//          of the array is transferred to the caller. Note that the

//          array elements contain heap-allocated data.

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

//

RPointerArray<CPIMCategoryStateChange>*

CPIMContactListAdapter::GetExternalCategoryModificationsL()

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::IsDatabaseReadyL, iFuncServer);

    RPointerArray<CPIMCategoryStateChange>* retval = iCategoryChanges;

    iCategoryChanges = NULL;

    return retval;

}

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

// CPIMContactListAdapter::IsItemsExternallyModified

// Checks whether there have been external changes to the items in

// the native database after last call to

// GetExternalItemModifications or list adapter creation.

// Returns: EExternalChangesMinor: If there are any external changes

//          EExternalChangesNone: Otherwise

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

//

MPIMListAdapter::TExternalItemChangeClass CPIMContactListAdapter::IsItemsExternallyModified()

{

    JELOG2(EPim);

    if ((iItemChanges || iFirstItemChanges))

    {

        return MPIMListAdapter::EExternalChangesMinor;

    }

    return MPIMListAdapter::EExternalChangesNone;

}

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

// CPIMContactListAdapter::GetExternalItemModificationsL

// Provides the external changes to the items in the native database.

// Returns: An array of item state change objects. The ownership

//          of the array is transferred to the caller. Note that the

//          array elements contain heap-allocated data.

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

//

RPointerArray<CPIMItemStateChange>*

CPIMContactListAdapter::GetExternalItemModificationsL()

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::IsDatabaseReadyL, iFuncServer);

    // the first time,

    // we check for all cards

    if (iFirstItemChanges)

    {

        //FilterAllContactsL();

        CallMethodL(this, &CPIMContactListAdapter::FilterAllContactsL,

                    iFuncServer);

        iFirstItemChanges = EFalse;

    }

    RPointerArray<CPIMItemStateChange>* retval = iItemChanges;

    iItemChanges = NULL;

    return retval;

}

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

// CPIMContactListAdapter::Close

// Used to inform the list adapter that the list has been closed.

// The list adapter may then release all resources it has reserved.

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

//

void CPIMContactListAdapter::Close()

{

    JELOG2(EPim);

    CallMethod(this, &CPIMContactListAdapter::DoClose, iFuncServer);

}

void CPIMContactListAdapter::DoClose()

{

    JELOG2(EPim);

    if (iCategoryChanges)

    {

        iCategoryChanges->ResetAndDestroy();

        delete iCategoryChanges;

        iCategoryChanges = NULL;

    }

    if (iItemChanges)

    {

        iItemChanges->ResetAndDestroy();

        delete iItemChanges;

        iItemChanges = NULL;

    }

    delete iNotifier;

    iNotifier = NULL;

    delete iItemAdapter;

    iItemAdapter = NULL;

    delete iCategoryManager;

    iCategoryManager = NULL;

    delete iDatabase;

    iDatabase = NULL;

    delete iMinimalFieldsViewDef;

    iMinimalFieldsViewDef = NULL;

}

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

// CPIMContactListAdapter::GetPimListAdapter

// Provides access to the MPIMListAdapter representation of this

// MPIMContactListAdapter object.

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

//

MPIMListAdapter* CPIMContactListAdapter::GetPimListAdapter()

{

    JELOG2(EPim);

    return this;

}

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

// CPIMContactListAdapter::CreateContactItemL

// Creates a new contact item (entry) in the native database.

// The adapter creates a new native database entry, sets its data

// according to the data in aContactItem, adds it to the database

// and sets the Item ID of aContactItem. aContactItem must

// contain valid data and have Item ID KPIMNullItemID.

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

//

void CPIMContactListAdapter::CreateContactItemL(MPIMContactItem& aContactItem) // The contact item to add

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::DoCreateContactItemL,

                aContactItem, iFuncServer);

    ReadContactItemL(aContactItem);

}

void CPIMContactListAdapter::DoCreateContactItemL(MPIMContactItem& aContactItem) // The contact item to add

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iItemAdapter || iDatabase, User::Leave(KErrNotReady));

    CContactCard* card = iItemAdapter->CardL(aContactItem);

    CleanupStack::PushL(card);

    // Leaves with KErrDiskFull if there is not enough disk

    // space to create a new contact item

    TContactItemId id = iDatabase->AddNewContactL(*card);

    // Set new item id. If this leaves it means that

    // SetContactItemIdL leaved with KErrOutNoMemory

    TRAPD(err, aContactItem.SetContactItemIdL(id));

    if (KErrNone != err)

    {

        TBuf8<KPIMItemIdDesSize> entryId;

        entryId.Num(static_cast<TUint>(id));

        DoRemoveContactItemL(entryId);

        User::Leave(err);

    }

    iItemAdapter->UpdateCategoriesL(aContactItem, *card);

    CleanupStack::PopAndDestroy(card);

    // update possible changes (e.g. dropped attributes) to the item

    aContactItem.PrepareForLoadL();

}

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

// CPIMContactListAdapter::ReadContactItemL

// Reads an existing contact item from the native database.

// The adapter maps the Item ID in aContactItem to a native database

// entry identifier, reads the entry and sets the data of

// aContactItem according to the data in the native entry. This operation

// is very performance sensitive, so it must be used with cause and only

// when the full contact item is needed

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

//

void CPIMContactListAdapter::ReadContactItemL(MPIMContactItem& aContactItem) // The contact item to be read

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::DoCallReadContactItemL,

                aContactItem, iFuncServer);

}

void CPIMContactListAdapter::DoCallReadContactItemL(

    MPIMContactItem& aContactItem) // The contact item to be read

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iItemAdapter || iDatabase, User::Leave(KErrNotReady));

    const TContactItemId id = aContactItem.ContactItemIdL();

    __ASSERT_ALWAYS(id != 0, User::Leave(KErrArgument));

    // If the contact item contains data we don't want to overwrite it

    // so we create a mask item view definition if needed. Otherwise

    // we just read full contact item from the database

    CContactItemViewDef* itemViewDef = CContactItemViewDef::NewLC(

                                           CContactItemViewDef::EMaskFields,

                                           CContactItemViewDef::EIncludeHiddenFields);

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

    TInt count = fields->Count();

    // Mask fields and do not include. Note that if there is no fields in the

    // item the view should provide all possible fields from the database

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

    {

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

        // Get Contacts Model fields mapped to PIM fields

        CArrayFix<TInt>* fieldArray = iItemAdapter->ContactsModelFieldTypeL(

                                          field);

        CleanupStack::PushL(fieldArray);

        // Add retrieved fields to the item view definition

        TInt fieldCount = fieldArray->Count();

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

        {

            const TUid fieldUid =

                { fieldArray->At(j) };

            // Do not add the field to the view if it already contains

            // this type of a field (e.g the field is a name array element)

            if (itemViewDef->Find(fieldUid) == KErrNotFound)

            {

                itemViewDef->AddL(fieldUid);

            }

        }

        CleanupStack::PopAndDestroy(fieldArray);

    }

    DoReadContactItemL(aContactItem, *itemViewDef);

    CleanupStack::PopAndDestroy(2, itemViewDef);

}

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

// CPIMContactListAdapter::ReadMinimalContactItemL

// This version reads a minimal contact item from the native database by using

// contact database view definition. The view definition is initialized in

// the constructor of this class and needs to be up to date with currently

// required contact fields when the item is read for the first time. This

// function was introduced due to improve poor performance of the PIM API

// ContactList

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

void CPIMContactListAdapter::ReadMinimalContactItemL(

    MPIMContactItem& aContactItem)

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::DoCallReadMinimalContactItemL,

                aContactItem, iFuncServer);

}

void CPIMContactListAdapter::DoCallReadMinimalContactItemL(

    MPIMContactItem& aContactItem)

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iItemAdapter || iDatabase, User::Leave(KErrNotReady));

    TContactItemId id = aContactItem.ContactItemIdL();

    __ASSERT_ALWAYS(id != 0, User::Leave(KErrArgument));

    // Reset item for reading

    aContactItem.PrepareForLoadL();

    // Use contact database filtering. Currently only all name elements

    // are retrieved from the database to improve performance of the list

    DoReadContactItemL(aContactItem, *iMinimalFieldsViewDef);

}

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

// CPIMContactListAdapter::ReadMinimalContactItemL

// This version reads a minimal contact item from the native database by using

// contact database view definition. The view definition is initialized in

// the constructor of this class and it can be modified to fetch specified fields

// by the matching item given as an argument to this function

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

void CPIMContactListAdapter::ReadMinimalContactItemL(

    MPIMContactItem& aContactItem, const MPIMContactItem& aMatchingContactItem)

{

    JELOG2(EPim);

    // Get fields from the matching item and add those to the view definition

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

    TInt count = fields->Count();

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

    {

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

        // Get Contacts Model fields mapped to PIM fields

        CArrayFix<TInt>* fieldArray = iItemAdapter->ContactsModelFieldTypeL(

                                          field);

        CleanupStack::PushL(fieldArray);

        // Add retrieved fields to the item view definition

        TInt fieldCount = fieldArray->Count();

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

        {

            const TUid fieldUid =

                { fieldArray->At(j) };

            // Do not add the field to the view if it already contains

            // this type of a field (e.g the field is a name array element)

            if (iMinimalFieldsViewDef->Find(fieldUid) == KErrNotFound)

            {

                iMinimalFieldsViewDef->AddL(fieldUid);

            }

        }

        CleanupStack::PopAndDestroy(fieldArray);

    }

    CleanupStack::PopAndDestroy(fields);

    // Read contact item using minimal field definition

    ReadMinimalContactItemL(aContactItem);

    // Reset the view definition to its previous state

    InitializeMinimalViewDefinitionL();

}

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

// CPIMContactListAdapter::ReadContactFieldL

// Reads one field from the contact database

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

//

void CPIMContactListAdapter::ReadContactFieldL(MPIMContactItem& aContactItem,

        TPIMContactField aContactField)

{

    JELOG2(EPim);

    CallMethodL(this, &CPIMContactListAdapter::DoReadContactFieldL,

                aContactItem, aContactField, iFuncServer);

}

void CPIMContactListAdapter::DoReadContactFieldL(MPIMContactItem& aContactItem,

        TPIMContactField aContactField)

{

    JELOG2(EPim);

    __ASSERT_ALWAYS(iItemAdapter || iDatabase, User::Leave(KErrNotReady));

    TContactItemId id = aContactItem.ContactItemIdL();

    __ASSERT_ALWAYS(id != 0, User::Leave(KErrArgument));

    // Create new view definition

    CContactItemViewDef* itemViewDef = CContactItemViewDef::NewLC(

                                           CContactItemViewDef::EIncludeFields,

                                           CContactItemViewDef::EIncludeHiddenFields);

    CArrayFix<TInt>* fieldArray = iItemAdapter->ContactsModelFieldTypeL(

                                      aContactField);

    CleanupStack::PushL(fieldArray);

    // Add retrieved fields to the item view definition

    TInt fieldCount = fieldArray->Count();

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

    {

        const TUid fieldUid =

            { fieldArray->At(i) };

        itemViewDef->AddL(fieldUid);

    }

    // The view cannot be empty so check the field count in debug builds

    __ASSERT_DEBUG(itemViewDef->Count() > 0, User::Panic(KPIMPanicCategory,

                   EPIMPanicInvalidState));

    CleanupStack::PopAndDestroy(fieldArray);