/*

* Copyright (c) 2002-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:  A virtual phonebook view contact implementation

*

*/

// INCLUDE FILES

#include "CViewContact.h"

#include <MVPbkFieldType.h>

#include <CVPbkSimCntField.h>

#include <CVPbkSimContact.h>

#include "CContactStore.h"

#include "CFieldTypeMappings.h"

#include "CContactView.h"

#include "CContact.h"

#include "CContactOperationCallback.h"

#include "CRemoteStore.h"

#include "VPbkSimStoreError.h"

namespace VPbkSimStore {

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

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

// TViewContactFieldData::TViewContactFieldData

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

// might leave.

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

//

TViewContactFieldData::TViewContactFieldData( const TDesC& aData )

:   iData( aData )

    {

    }

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

// TViewContactFieldData::IsEmpty

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

//

TBool TViewContactFieldData::IsEmpty() const

    {

    return iData.Length() == 0;

    }

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

// TViewContactFieldData::CopyL

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

//

void TViewContactFieldData::CopyL( const MVPbkContactFieldData& /*aFieldData*/ )

    {

    }

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

// TViewContactFieldData::Text

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

//

TPtrC TViewContactFieldData::Text() const

    {

    return iData;

    }

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

// TViewContactFieldData::SetTextL

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

//

void TViewContactFieldData::SetTextL( const TDesC& aText )

    {

    iData.Set( aText );

    }

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

// TViewContactFieldData::SetTextL

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

//

TInt TViewContactFieldData::MaxLength() const

    {

    return iData.Length();

    }

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

// TViewContactField::TViewContactField

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

// might leave.

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

//

TViewContactField::TViewContactField( CViewContact& aParentContact,

    const MVPbkFieldType& aFieldType, const TDesC& aData )

:   iParentContact( aParentContact ),

    iFieldType( aFieldType ),

    iFieldData( aData )

    {

    }

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

// TViewContactField::ParentContact

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

//

MVPbkBaseContact& TViewContactField::ParentContact() const

    {

    return iParentContact;

    }

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

// TViewContactField::MatchFieldType

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

//

const MVPbkFieldType* TViewContactField::MatchFieldType( 

    TInt /*aMatchPriority*/ ) const

    {

    return &iFieldType;

    }

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

// TViewContactField::BestMatchingFieldType

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

//

const MVPbkFieldType* TViewContactField::BestMatchingFieldType() const

    {

    return &iFieldType;

    }

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

// TViewContactField::ConstFieldData

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

//

const MVPbkContactFieldData& TViewContactField::FieldData() const

    {

    return iFieldData;

    }

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

// TViewContactField::IsSame

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

//

TBool TViewContactField::IsSame( 

    const MVPbkBaseContactField& aOther ) const

    {

    if ( &aOther.ParentContact() == &ParentContact() &&

         &aOther.FieldData() == &FieldData() )

        {

        return ETrue;

        }

    return EFalse;

    }

// Destructor

CViewContactFieldCollection::~CViewContactFieldCollection()

    {

    iFields.Close();

    }

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

// CViewContactFieldCollection::SetParentContact

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

//

void CViewContactFieldCollection::SetParentContact( 

    CViewContact& aParentContact )

    {

    iParentContact = &aParentContact;

    }

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

// CViewContactFieldCollection::ResetFields

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

//

void CViewContactFieldCollection::ResetFields()

    {

    iFields.Reset();

    }

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

// CViewContactFieldCollection::AppendFieldL

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

//

void CViewContactFieldCollection::AppendFieldL( TViewContactField& aNewField )

    {

    iFields.AppendL( aNewField );

    }

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

// CViewContactFieldCollection::ParentContact

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

//

MVPbkBaseContact& CViewContactFieldCollection::ParentContact() const

    {

    return *iParentContact;

    }

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

// CViewContactFieldCollection::FieldCount

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

//

TInt CViewContactFieldCollection::FieldCount() const

    {

    return iFields.Count();

    }

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

// CViewContactFieldCollection::FieldAt

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

//

const MVPbkBaseContactField& CViewContactFieldCollection::FieldAt( 

    TInt aIndex ) const

    {

    return iFields[aIndex];

    }

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

// CViewContact::CViewContact

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

// might leave.

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

//

CViewContact::CViewContact( CContactView& aView, 

    const MVPbkFieldTypeList& aSortOrder )

    :   iView( aView ),

        iSortOrder( &aSortOrder )

    {

    }

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

// CViewContact::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CViewContact::ConstructL()

    {

    iAsyncOp = new( ELeave ) VPbkEngUtils::CVPbkAsyncOperation;

    iFieldCollection.SetParentContact( *this );

    }

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

// CViewContact::NewL

// Two-phased constructor.

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

//

CViewContact* CViewContact::NewL( CContactView& aView,

    const MVPbkFieldTypeList& aSortOrder )

    {

    CViewContact* self = new( ELeave ) CViewContact( aView, aSortOrder );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CViewContact::~CViewContact()

    {

    delete iStoreOperation;

    delete iAsyncOp;    

    }

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

// CViewContact::SetSimContactL

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

//

void CViewContact::SetSimContactL( MVPbkSimContact& aSimContact )

    {

    // View contact must have the same fields as in the sort order that was

    // given by VPbk client.

    iFieldCollection.ResetFields();

    CFieldTypeMappings& mappings = iView.Store().FieldTypeMappings();

    TInt count = aSimContact.FieldCount();

    TInt typeCount = iSortOrder->FieldTypeCount();

    // Loop all field types in the sort order and try to find fields

    // from the sim contact.

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

        {

        const CVPbkSimCntField* simField = NULL;

        const MVPbkFieldType& sortOrderType = iSortOrder->FieldTypeAt( i );

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

            {

            const MVPbkFieldType* vpbkType = mappings.Match( *iSortOrder, 

                aSimContact.ConstFieldAt( j ).Type() );

            if ( vpbkType && vpbkType == &sortOrderType )

                {

                simField = &aSimContact.ConstFieldAt( j );

                break;

                }

            }

        if ( simField )

            {

            // SIM field was found for the sort order type

            TViewContactField field( *this, sortOrderType, simField->Data() );

            iFieldCollection.AppendFieldL( field );

            }

        else

            {

            // SIM field was NOT found for the sort order type. Set empty data,

            TViewContactField field( *this, sortOrderType, KNullDesC );

            iFieldCollection.AppendFieldL( field );

            }

        }

    iSimContact = &aSimContact;

    }

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

// CViewContact::SimIndex

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

//

TInt CViewContact::SimIndex() const

    {

    if ( iSimContact )

        {

        return iSimContact->SimIndex();

        }

    return KErrNotFound;

    }

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

// CViewContact::SetSortOrder

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

//

void CViewContact::SetSortOrder( const MVPbkFieldTypeList& aSortOrder )

    {

    iSortOrder = &aSortOrder;

    }

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

// CViewContact::NativeContact

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

//

const MVPbkSimContact* CViewContact::NativeContact() const

    {

    return iSimContact;

    }

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

// CViewContact::View

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

//

CContactView& CViewContact::View() const

    {

    return iView;

    }

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

// CViewContact::Fields

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

//

const MVPbkBaseContactFieldCollection& CViewContact::Fields() const

    {

    return iFieldCollection;

    }

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

// CViewContact::IsSame

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

//

TBool CViewContact::IsSame( const MVPbkStoreContact& aOtherContact ) const

    {

    if ( &iView.ContactStore() == &aOtherContact.ContactStore() )

        {

        const CVPbkSimContact& simContact = 

            static_cast<const CContact&>( aOtherContact ).SimContact();

        return SimIndex() == simContact.SimIndex();

        }

    return EFalse;

    }

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

// CViewContact::IsSame

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

//

TBool CViewContact::IsSame( const MVPbkViewContact& aOtherContact ) const

    {

    return aOtherContact.IsSame(*this, &iView.ContactStore());

    }

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

// CViewContact::IsSame

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

//

TBool CViewContact::IsSame(const MVPbkViewContact& aOtherContact, 

                           const MVPbkContactStore* aContactStore) const

    {

    if (aContactStore == &iView.ContactStore())

        {

        return static_cast<const CViewContact&>(aOtherContact).SimIndex() == 

            SimIndex();

        }

    return EFalse;

    }

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

// CViewContact::IsSame

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

//

TBool CViewContact::IsSame(const MVPbkStoreContact& aOtherContact, 

                           const MVPbkContactStore* aContactStore) const

    {

    if (aContactStore == &iView.ContactStore())

        {

        const CVPbkSimContact& simContact = 

            static_cast<const CContact&>( aOtherContact ).SimContact();

        return SimIndex() == simContact.SimIndex();

        }

    return EFalse;

    }

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

// CViewContact::CreateLinkLC

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

//

MVPbkContactLink* CViewContact::CreateLinkLC() const

    {

    return iView.Store().CreateLinkLC( SimIndex() );

    }

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

// CViewContact::DeleteL

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

//

void CViewContact::DeleteL( MVPbkContactObserver& aObserver ) const

    {

    if ( iStoreOperation )

        {

        User::Leave( KErrInUse );

        }

    // From the client point of view the MVPbkStoreContact is constant but

    // implementation needs a non const contact.

    RVPbkStreamedIntArray indexArray;

    CleanupClosePushL( indexArray );

    indexArray.AppendIntL( SimIndex() );

    iStoreOperation = iView.Store().NativeStore().DeleteL( indexArray, 

        const_cast<CViewContact&>(*this));

    iObserver = &aObserver;

    CleanupStack::PopAndDestroy(); // indexArray 

    }

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

// CViewContact::MatchContactStore

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

//        

TBool CViewContact::MatchContactStore(const TDesC& aContactStoreUri) const

    {

    return iView.MatchContactStore(aContactStoreUri);

    }

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

// CViewContact::MatchContactStoreDomain

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

//        

TBool CViewContact::MatchContactStoreDomain(

        const TDesC& aContactStoreDomain) const

    {

    return iView.MatchContactStoreDomain(aContactStoreDomain);

    }

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

// CViewContact::CreateBookmarkLC

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

//

MVPbkContactBookmark* CViewContact::CreateBookmarkLC() const

    {

    return iView.Store().CreateBookmarkLC( SimIndex() );

    }

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

// CViewContact::ParentView

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

//

MVPbkContactViewBase& CViewContact::ParentView() const

    {

    return iView;

    }

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

// CViewContact::ParentView

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

//

void CViewContact::ReadL( MVPbkContactObserver& aObserver ) const

    {

    MVPbkContactObserver::TContactOpResult opResult;

    opResult.iExtension = NULL;

    opResult.iOpCode = MVPbkContactObserver::EContactRead;

    opResult.iStoreContact = iView.Store().ReadContactL( SimIndex() );

    CreateReadCallbackL( aObserver, opResult );

    }

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

// CViewContact::ReadAndLockL

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

//

void CViewContact::ReadAndLockL( MVPbkContactObserver& aObserver ) const

    {

    MVPbkContactObserver::TContactOpResult opResult;

    opResult.iExtension = NULL;

    opResult.iOpCode = MVPbkContactObserver::EContactReadAndLock;

    CContact* cnt = iView.Store().ReadContactL( SimIndex() );

    cnt->SetLock( ETrue );

    opResult.iStoreContact = cnt;

    CreateReadCallbackL( aObserver, opResult );

    }

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

// CViewContact::Expandable

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

//

MVPbkExpandable* CViewContact::Expandable() const

    {

    return NULL;

    }

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

// CViewContact::ContactEventComplete

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

//