/*

* Copyright (c) 2004-2007 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:  The virtual phonebook default attribute operation

*

*/

#include "CDefaultAttributeOperation.h"

#include "CContactStore.h"

#include "TContactField.h"

#include "CContact.h"

#include "VPbkCntModelUid.h"

#include "CContactFilter.h"

#include <CVPbkDefaultAttribute.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkContactAttributeManager.h>

#include <MVPbkContactAttribute.h>

#include <CVPbkAsyncOperation.h>

#include <CVPbkAsyncCallback.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <VPbkStoreUriLiterals.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkContactFindObserver.h>

// From Contacts Model

#include <cntitem.h>

namespace VPbkCntModel {

namespace {

	struct TFieldTypePair

	    {

	    TInt iProperty;

	    TInt iUid;

	    };

	static const TFieldTypePair fieldTypeMap[] =

	    {

	    /// default phone number field type

	    {EVPbkDefaultTypePhoneNumber, KIntVPbkDefaultFieldPref},

	    /// default video number field type

	    {EVPbkDefaultTypeVideoNumber, KIntVPbkDefaultFieldVideo},

	    /// default sms field type

	    {EVPbkDefaultTypeSms, KIntVPbkDefaultFieldSms},

	    /// default mms field type

	    {EVPbkDefaultTypeMms, KIntVPbkDefaultFieldMms},

	    /// default email field type

	    {EVPbkDefaultTypeEmail, KIntVPbkDefaultFieldPref},

	    /// default email over sms field type

	    {EVPbkDefaultTypeEmailOverSms, KIntVPbkDefaultFieldEmailOverSms},

	    /// default poc field type

	    {EVPbkDefaultTypePOC, KIntVPbkDefaultFieldPoc},

	    /// default voip field type

	    {EVPbkDefaultTypeVoIP, KIntVPbkDefaultFieldVoip},

        /// default chat field type

        {EVPbkDefaultTypeChat, KIntVPbkDefaultFieldChat},

        /// default url field type

        {EVPbkDefaultTypeOpenLink, KIntVPbkDefaultFieldOpenLink},

	    // Always the last one

	    {EVPbkLastDefaultType, 0}

	    };

	TFieldType FindFieldTypeForProperty(TVPbkDefaultType aProperty)

	    {

	    for (TInt i = 0; fieldTypeMap[i].iProperty != EVPbkLastDefaultType;

	         ++i)

	        {

	        if (aProperty == fieldTypeMap[i].iProperty)

	            {

	            return TFieldType::Uid(fieldTypeMap[i].iUid);

	            }

	        }

	    return KNullUid;

	    }	    

} // unnamed namespace

CDefaultAttributeOperation::CDefaultAttributeOperation(

        TOperationMode aOperationMode,

        CContactStore& aContactStore,

        MVPbkStoreContactField& aField,

        MVPbkSetAttributeObserver& aObserver) :

    iOperationMode(aOperationMode),

    iContactStore(aContactStore),

    iField(&aField),

    iSetObserver(&aObserver)

    {

    }

CDefaultAttributeOperation::CDefaultAttributeOperation(

        TOperationMode aOperationMode,

        CContactStore& aContactStore,

        MVPbkContactFindObserver& aObserver) :

    iOperationMode(aOperationMode),

    iContactStore(aContactStore),

    iFindObserver(&aObserver)

    {

    }

void CDefaultAttributeOperation::ConstructL(

        const CVPbkDefaultAttribute& aAttribute)

    {

    iAsyncOperation = new(ELeave) VPbkEngUtils::CVPbkAsyncOperation;

    iAttribute = static_cast<CVPbkDefaultAttribute*>(aAttribute.CloneLC());

    CleanupStack::Pop();

    }

CDefaultAttributeOperation* CDefaultAttributeOperation::NewSetLC(

        CContactStore& aContactStore,

        MVPbkStoreContactField& aField,

        const CVPbkDefaultAttribute& aAttribute,

        MVPbkSetAttributeObserver& aObserver)

    {

    CDefaultAttributeOperation* self = new(ELeave) CDefaultAttributeOperation(

            ESet, aContactStore, aField, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aAttribute);

    return self;

    }

CDefaultAttributeOperation* CDefaultAttributeOperation::NewRemoveLC(

        CContactStore& aContactStore,

        MVPbkStoreContactField& aField,

        const CVPbkDefaultAttribute& aAttribute,

        MVPbkSetAttributeObserver& aObserver)

    {

    CDefaultAttributeOperation* self = new(ELeave) CDefaultAttributeOperation(

            ERemove, aContactStore, aField, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aAttribute);

    return self;

    }

CDefaultAttributeOperation* CDefaultAttributeOperation::NewListLC(

        CContactStore& aContactStore,

        const CVPbkDefaultAttribute& aAttribute,

        MVPbkContactFindObserver& aObserver)

    {

    CDefaultAttributeOperation* self = new(ELeave) CDefaultAttributeOperation(

            EList, aContactStore, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aAttribute);

    return self;

    }

CDefaultAttributeOperation::~CDefaultAttributeOperation()

    {

    delete iContactFilter;

    delete iAsyncOperation;

    delete iAttribute;

    }

void CDefaultAttributeOperation::StartL()

    {

    if (iOperationMode == EList)

        {

        VPbkEngUtils::MAsyncCallback* callback =

            VPbkEngUtils::CreateAsyncCallbackLC(

                *this,

                &CDefaultAttributeOperation::DoListOperationL,

                &CDefaultAttributeOperation::ListOperationError,

                *iFindObserver);

        iAsyncOperation->CallbackL(callback);

        CleanupStack::Pop(callback);

        }

    else

        {

        VPbkEngUtils::MAsyncCallback* callback =

            VPbkEngUtils::CreateAsyncCallbackLC(

                *this,

                &CDefaultAttributeOperation::DoSetOperationL,

                &CDefaultAttributeOperation::SetOperationError,

                *iSetObserver);

        iAsyncOperation->CallbackL(callback);

        CleanupStack::Pop(callback);

        }

    }

void CDefaultAttributeOperation::DoListOperationL(

        MVPbkContactFindObserver& /*aObserver*/)

    {

    delete iContactFilter;

    iContactFilter = NULL;

    iContactFilter = CContactFilter::NewL(*this, iContactStore);

    iContactFilter->StartL();

    }

void CDefaultAttributeOperation::ListOperationError(

        MVPbkContactFindObserver& aObserver,

        TInt aError)

    {

    aObserver.FindFailed(aError);

    }

void CDefaultAttributeOperation::DoSetOperationL(

        MVPbkSetAttributeObserver& aObserver)

    {

    if (&iField->ContactStore() == &iContactStore)

        {

        CContact& contact = static_cast<CContact&>(iField->ParentContact());

        TContactField& field = static_cast<TContactField&>(*iField);

        if (iOperationMode == ESet)

            {

	        TFieldType fieldType = FindFieldTypeForProperty(iAttribute->DefaultType());

	        if (fieldType == KNullUid)

		        {

		        User::Leave(KErrNotSupported);

		        }

		    field.NativeField()->AddFieldTypeL(fieldType);

            }

        else if (iOperationMode == ERemove)

            {

            if (iAttribute->DefaultType() == CVPbkDefaultAttribute::KDefaultTypeNotDefined)

                {

                // If field contains any default type, remove it

                for (TInt n = 0;

                	fieldTypeMap[n].iProperty != EVPbkLastDefaultType;

                	++n)

                	{

					TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid);

                    if (field.NativeField()->ContentType().ContainsFieldType(fieldType))

                        {

                        field.NativeField()->RemoveFieldType(fieldType);

                        }

                	}

                }

            else

                {

		        TFieldType fieldType = FindFieldTypeForProperty(iAttribute->DefaultType());

		        if (fieldType == KNullUid)

			        {

			        User::Leave(KErrNotSupported);

			        }

                // Remove specified type from field

                field.NativeField()->RemoveFieldType(fieldType);

                }

            }

        }

    aObserver.AttributeOperationComplete(*this);

    }

void CDefaultAttributeOperation::SetOperationError(

        MVPbkSetAttributeObserver& aObserver,

        TInt aError)

    {

    aObserver.AttributeOperationFailed(*this, aError);

    }

void CDefaultAttributeOperation::Cancel()

    {

    iAsyncOperation->Purge();

    }

TBool CDefaultAttributeOperation::IsIncluded(MVPbkStoreContact& aContact)

	{

	TBool result(EFalse);

	CContact& contact = static_cast<CContact&>(aContact);

	CContactItemFieldSet& fields = contact.NativeContact()->CardFields();

    const TInt count = fields.Count();

    for (TInt i = 0; i < count && !result; ++i)

        {

		if (iAttribute->DefaultType() == CVPbkDefaultAttribute::KDefaultTypeNotDefined)

			{

			for (TInt n = 0;

            	fieldTypeMap[n].iProperty != EVPbkLastDefaultType;

            	++n)

            	{

				TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid);

                if (fields[i].ContentType().ContainsFieldType(fieldType))

                    {

                    result = ETrue;

                    break;

                    }

            	}

			}

		else

			{

			TFieldType fieldType = FindFieldTypeForProperty(iAttribute->DefaultType());

	        if (fields[i].ContentType().ContainsFieldType(fieldType))

	            {

	            result = ETrue;

	            break;

	        	}

			}

        }

    return result;

	}

void CDefaultAttributeOperation::FilteringDoneL(MVPbkContactLinkArray* aLinkArray)

	{

	iFindObserver->FindCompleteL(aLinkArray);

	}

void CDefaultAttributeOperation::FilteringError(TInt aError)

	{

	iFindObserver->FindFailed(aError);

	}

} // namespace VPbkCntModel

// End of File