/*

* 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 copy policy for copying to sim store

*

*/

// INCLUDE FILES

#include "CPsu2ContactCopyPolicy.h"

#include "CPsu2SimContactProcessor.h"

#include "CPsu2CopyToSimFieldInfoArray.h"

// From Phonebook 2 

#include <MPbk2FieldProperty.h>

#include <CPbk2FieldPropertyArray.h>

#include <CPbk2PresentationContact.h>

#include <CPbk2SortOrderManager.h>

#include <Pbk2ContactNameFormatterFactory.h>

#include <MPbk2ContactNameFormatter.h>

#include <CPbk2StorePropertyArray.h>

#include <Pbk2ContactFieldCopy.h>

// From Virtual Phonebook

#include <MVPbkContactFieldCopyObserver.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkFieldType.h>

#include <MVPbkContactStore.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactObserver.h>

#include <MVPbkContactCopyObserver.h>

#include <MVPbkContactOperationBase.h>

#include <VPbkContactStoreUris.h>

#include <CVPbkFieldTypeRefsList.h>

#include <CVPbkContactFieldIterator.h>

namespace {

// ============================ LOCAL FUNCTIONS ================================

/**

* A dummy operation that completes the operation successfully

*/

NONSHARABLE_CLASS( CFieldNotSupportedOperation ):  public CActive,

                                          public MVPbkContactOperationBase

    {

    public: // Construction and destruction

        /**

        * Two-phased constructor.

        * @param aCopyObserver Copy observer

        * @return a new instance of this class

        */

        static CFieldNotSupportedOperation* NewL(

            MVPbkContactFieldCopyObserver& aCopyObserver);

        /**

        * Destructor

        */

        ~CFieldNotSupportedOperation();

    public: // Functions from base class

        /**

        * From CActive

        */

        void RunL();

        /**

        * From CActive

        */

        void DoCancel();

    private:   

        CFieldNotSupportedOperation(

            MVPbkContactFieldCopyObserver& aCopyObserver);

        void IssueRequest();

    private:    // Data

        MVPbkContactFieldCopyObserver& iCopyObserver;

    };

/**

* An operation that adds field to the sim contact

* if the conversion is found

*/

NONSHARABLE_CLASS( CAddFieldOperation ): public CActive,

                           public MVPbkContactOperationBase

    {

    public: // Construction and destruction

        /**

        * Two-phased constructor.

        * @param aCopyPolicy    Copy policy

        * @param aContact       Contact

        * @param aFieldType     Field type

        * @param aFieldData     Field data

        * @param aFieldLabel    Field label

        * @param aCopyObserver  Copy observer

        * @param aNameFormatter Name formatter

        * @return a new instance of this class

        */

        static CAddFieldOperation* NewL(

                CPsu2ContactCopyPolicy& aCopyPolicy,

                MVPbkStoreContact& aContact, 

                const MVPbkFieldType& aFieldType,

                const TDesC& aFieldData,

                const TDesC* aFieldLabel,

                MVPbkContactFieldCopyObserver& aCopyObserver,

                MPbk2ContactNameFormatter& aNameFormatter );

        ~CAddFieldOperation();

    public: // Functions from base classes

        /**

        * From CActive

        */

        void RunL();

        /**

        * From CActive

        */

        void DoCancel();

        /**

        * From CActive

        */

        TInt RunError(TInt aError);

    private: // Construction

        /**

        * C++ contructor

        */

        CAddFieldOperation(CPsu2ContactCopyPolicy& aCopyPolicy,

            MVPbkContactFieldCopyObserver& aCopyObserver,

            MPbk2ContactNameFormatter& aNameFormatter );

        /**

        * 2nd phase constructor

        */

        void ConstructL(

                MVPbkStoreContact& aContact, 

                const MVPbkFieldType& aFieldType,

                const TDesC& aFieldData,

                const TDesC* aFieldLabel);

    private:    // New functions

        void IssueRequest(TInt aResult);

    private: // Data

        /// Ref: Copy policy

        CPsu2ContactCopyPolicy& iCopyPolicy;

        /// Ref: copy observer

        MVPbkContactFieldCopyObserver& iCopyObserver;

        /// Ref: for title field copying

        MPbk2ContactNameFormatter& iNameFormatter;

        /// Own: Field to be added

        MVPbkStoreContactField* iField;

        /// Ref: contact to add the fields to

        MVPbkStoreContact* iContact;

    };

/**

* A class for commiting a sim contact. Splits contacts if necessary.

*/

NONSHARABLE_CLASS( CSaveContactOperation ): public CActive,

                                  public MVPbkContactOperationBase,

                                  public MVPbkContactObserver

    {

    public: // Construction and destruction

        /** 

         * Static constructor

         *

         * @param aContactToCommit      Store contact pointer, this class 

         *                              takes the ownership of a contact

         * @param aCopyObserver         Copy observer

         * @param aSimContactProcessor  Sim contact processor

         * @return New instance of this classs

         */

        static CSaveContactOperation* NewL(

                MVPbkStoreContact* aContactToCommit, 

                MVPbkContactCopyObserver& aCopyObserver,

                CPsu2SimContactProcessor& aSimContactProcessor);

        /** 

         * Static constructor

         *

         * @param aSourceContact        Store contact reference

         * @param aCopyObserver         Copy observer

         * @param aSimContactProcessor  Sim contact processor

         * @return New instance of this classs

         */

        static CSaveContactOperation* NewL(

                MVPbkStoreContact& aSourceContact, 

                MVPbkContactCopyObserver& aCopyObserver,

                CPsu2SimContactProcessor& aSimContactProcessor);

        /** 

         * Destructor

         */                

        ~CSaveContactOperation();

    public: // Functions from base classes

        /**

        * From CActive

        */

        void RunL();

        /**

        * From CActive

        */

        void DoCancel();

        /**

        * From CActive

        */

        TInt RunError(TInt aError);        

    public: // from MVPbkContactObserver

        void ContactOperationCompleted(TContactOpResult aResult);

        void ContactOperationFailed(TContactOp aOpCode, TInt aErrorCode, 

            TBool aErrorNotified);

    private: // Implementation

        CSaveContactOperation(MVPbkContactCopyObserver& aCopyObserver,

            CPsu2SimContactProcessor& aSimContactProcessor);

        void ConstructL(MVPbkStoreContact& aContact);

        MVPbkStoreContact* NextSimContact();

        void HandleContactOperationCompletedL();

        void IssueRequest(TInt aResult);

    private: // Data

        /// Ref: copy observer

        MVPbkContactCopyObserver& iCopyObserver;

        CPsu2SimContactProcessor& iSimContactProcessor;

        /// Own: a new contact in the case of copying contact

        MVPbkStoreContact* iContact;

        /// Own: the current sim contact to copy

        MVPbkStoreContact* iCurrentSimContact;

        /// An array of 'to be copied' sim contacts

        RPointerArray<MVPbkStoreContact> iSimContacts;

        /// Own: for results

        CVPbkContactLinkArray* iLinkArray;

    };

/**

* A class for copy title operation

*/

NONSHARABLE_CLASS( CCopyTitlesOperation )

    :   public CActive,

        public MVPbkContactOperationBase

    {

    public: // Construction and destruction

        /**

         * Static constructor

         *

         * @param aSourceContact    Copy source store contact

         * @param aTargetContact    Copy target store contact 

         * @param aCopyObserver     Copy observer

         * @param aNameFormatter    Name formatter

         * @return New instance of this class

         */

        static CCopyTitlesOperation* NewL(

            const MVPbkStoreContact& aSourceContact,

            MVPbkStoreContact& aTargetContact,

            MVPbkContactFieldsCopyObserver& aCopyObserver,

            MPbk2ContactNameFormatter& aNameFormatter,

            CPsu2SimContactProcessor& aSimContactProcessor);

        /**

         * Destructor

         */

        ~CCopyTitlesOperation();

    private: // From CActive

        void RunL();

        void DoCancel();

    private:

        CCopyTitlesOperation( const MVPbkStoreContact& aSourceContact,

            MVPbkStoreContact& aTargetContact,

            MVPbkContactFieldsCopyObserver& aCopyObserver,

            MPbk2ContactNameFormatter& aNameFormatter,

            CPsu2SimContactProcessor& aSimContactProcessor);

        void ConstructL();

        void IssueRequest();

    private: // Data

        /// The source of the title fields

        const MVPbkStoreContact& iSourceContact;

        /// Target of the copy

        MVPbkStoreContact& iTargetContact;

        /// An observer for asyncrhonous operation

        MVPbkContactFieldsCopyObserver& iCopyObserver;

        /// The name formatter for title field checking 

        MPbk2ContactNameFormatter& iNameFormatter;

        CPsu2SimContactProcessor& iSimContactProcessor;

    };

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

// CFieldNotSupportedOperation::CFieldNotSupportedOperation

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

// might leave.

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

//

CFieldNotSupportedOperation::CFieldNotSupportedOperation(

        MVPbkContactFieldCopyObserver& aCopyObserver)

        :   CActive(EPriorityStandard),

            iCopyObserver(aCopyObserver)

    {

    CActiveScheduler::Add(this);

    }

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

// CFieldNotSupportedOperation::NewL

// Two-phased constructor.

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

//

CFieldNotSupportedOperation* CFieldNotSupportedOperation::NewL(

        MVPbkContactFieldCopyObserver& aCopyObserver)

    {

    CFieldNotSupportedOperation* self= 

        new(ELeave) CFieldNotSupportedOperation(aCopyObserver);

    self->IssueRequest();

    return self;

    }

// Destructor

CFieldNotSupportedOperation::~CFieldNotSupportedOperation()

    {

    Cancel();

    }

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

// CFieldNotSupportedOperation::RunL

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

//    

void CFieldNotSupportedOperation::RunL()

    {

    iCopyObserver.FieldAddingFailed( *this, KErrNotSupported );

    }

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

// CFieldNotSupportedOperation::DoCancel

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

//    

void CFieldNotSupportedOperation::DoCancel()

    {

    // Notghing to cancel in the dummy operation

    }

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

// CFieldNotSupportedOperation::IssueRequest

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

//        

void CFieldNotSupportedOperation::IssueRequest()

    {

    TRequestStatus* st = &iStatus;

    User::RequestComplete(st, KErrNone);

    SetActive();

    }

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

// CAddFieldOperation::CAddFieldOperation

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

// might leave.

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

//    

CAddFieldOperation::CAddFieldOperation(

        CPsu2ContactCopyPolicy& aCopyPolicy, 

        MVPbkContactFieldCopyObserver& aCopyObserver,

        MPbk2ContactNameFormatter& aNameFormatter) 

        :   CActive( EPriorityStandard ),

            iCopyPolicy(aCopyPolicy),

            iCopyObserver(aCopyObserver),

            iNameFormatter( aNameFormatter )

    {

    CActiveScheduler::Add(this);

    }

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

// CAddFieldOperation::NewL

// Two-phased constructor.

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

//  

CAddFieldOperation* CAddFieldOperation::NewL(

        CPsu2ContactCopyPolicy& aCopyPolicy,

        MVPbkStoreContact& aContact, 

        const MVPbkFieldType& aFieldType,

        const TDesC& aFieldData,

        const TDesC* aFieldLabel,

        MVPbkContactFieldCopyObserver& aCopyObserver,

        MPbk2ContactNameFormatter& aNameFormatter)

    {

    CAddFieldOperation* self = new(ELeave) CAddFieldOperation(

            aCopyPolicy, aCopyObserver, aNameFormatter );

    CleanupStack::PushL(self);

    self->ConstructL(

        aContact, aFieldType, aFieldData, aFieldLabel);

    CleanupStack::Pop(self);

    return self;    

    }

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

// CAddFieldOperation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAddFieldOperation::ConstructL(

        MVPbkStoreContact& aContact, 

        const MVPbkFieldType& aFieldType,

        const TDesC& aFieldData,

        const TDesC* aFieldLabel)

    {

    TInt opResult = KErrNone;

    iContact = &aContact;

    const MVPbkFieldType* simType = NULL;

    if ( iNameFormatter.IsTitleFieldType( aFieldType ) )

        {

        // Check it the contact already has a title field

        HBufC* curTitle = iNameFormatter.GetContactTitleOrNullL( 

            aContact.Fields(), 

            MPbk2ContactNameFormatter::EPreserveLeadingSpaces );

        if ( !curTitle )

            {

            // Contact didn't have title so add to the SIM's name type

            simType = &iCopyPolicy.SimFieldInfos().SimNameType();

            }

        delete curTitle;

        }

    else

        {

        // Type was not title type. Try to make conversion.

        simType = iCopyPolicy.SimFieldInfos().ConvertToSimType(aFieldType);    

        }

    const MVPbkContactStoreProperties& props = 

        aContact.ParentStore().StoreProperties();

    if (simType && props.SupportedFields().ContainsSame( *simType ) )

        {

        // If data is 0 then don't add field but complete with success

        if ( aFieldData.Length() > 0 )

            {

            CPbk2PresentationContact* cnt = 

                CPbk2PresentationContact::NewL(aContact, 

                    iCopyPolicy.FieldProperties());

            CleanupStack::PushL(cnt);

            if (cnt->IsFieldAdditionPossibleL( *simType ))

                {

                iField = aContact.CreateFieldLC( *simType );

                CleanupStack::Pop();

                if (aFieldLabel && iField->SupportsLabel())

                    {

                    iField->SetFieldLabelL(*aFieldLabel);

                    }

                MVPbkContactFieldTextData& data = 

                    MVPbkContactFieldTextData::Cast(iField->FieldData());

                data.SetTextL(aFieldData.Left(data.MaxLength()));

                }

            else

                {

                opResult = KErrOverflow;

                }

            CleanupStack::PopAndDestroy(cnt);    

            }

        }

    else

        {

        opResult = KErrNotSupported;

        }

    IssueRequest(opResult);

    }

// Destructor

CAddFieldOperation::~CAddFieldOperation()

    {

    delete iField;

    }

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

// CAddFieldOperation::RunL

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

//        

void CAddFieldOperation::RunL()

    {

    if (iField)

        {

        iContact->AddFieldL(iField);

        iField = NULL; // Ownership taken by iContact

        iCopyObserver.FieldAddedToContact(*this);

        }

    else if ( iStatus.Int() == KErrNone )

        {

        iCopyObserver.FieldAddedToContact(*this);

        }

    else

        {

        iCopyObserver.FieldAddingFailed(*this, iStatus.Int());

        }

    }

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

// CAddFieldOperation::DoCancel

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

//            

void CAddFieldOperation::DoCancel()

    {

    // Do nothing

    }