/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Implementation of the add contact observer functionality.

*

*/

//User include

#include "addcontactobserver.h"

#include "contactcallback.h"

//System include 

#include "contactservice.h"// for iContactService

#include <MVPbkContactStore.h>// for iContactStore

#include <MVPbkStoreContact.h>// used in many function to get the store contact

#include <MVPbkContactOperationBase.h>//for observer

#include <MVPbkContactLink.h>//for param in ContactsSaved()

#include <MVPbkContactGroup.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldBinaryData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactFieldUriData.h>

/*

-------------------------------------------------------------------------------------

CAddContactObserver::NewL( CContactService* aContactService,

											 	MVPbkContactStore* aContactStore, 

											 	CSingleContact* aStoreContact,

											 	const TDesC8& aGroupId,

											 	const TDesC& aGroupLabel,

											 	TInt aTransId,

											 	MContactCallback* aCallback)

Description        : Static method to create instance of add contact observer.

Return values      : CAddContactObserver*

-------------------------------------------------------------------------------------

*/

CAddContactObserver* CAddContactObserver::NewL(CContactService* aContactService,

											   MVPbkContactStore* aContactStore, 

											   CSingleContact* aStoreContact,

											   const TDesC8& aGroupId,

											   const TDesC& aGroupLabel,

											   TInt aTransId,

											   MContactCallback* aCallback)

    {

    CAddContactObserver* self =  new( ELeave )

                                 CAddContactObserver(aContactService, 

        										     aContactStore, 

        										     aStoreContact,        										     

        										     aTransId,

        										     aCallback);

    CleanupStack::PushL(self);            										     

    self->ConstructL(aGroupId,aGroupLabel);    										   

    CleanupStack::Pop(self);										   

    return self;

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::CAddContactObserver(CVPbkContactManager* aContactManager, 

									    MVPbkContactStore* aContactStore, 

									    CSingleContact* aStoreContact,										 

									    TInt aTransId,

									    MContactCallback* aCallback)

Description        : This is the default constructor

Return values      : N/A										    

-------------------------------------------------------------------------------------

*/

CAddContactObserver::CAddContactObserver( CContactService* aContactService,

										  MVPbkContactStore* aContactStore, 

										  CSingleContact* aStoreContact,										 

										  TInt aTransId,

										  MContactCallback* aCallback )

    {

    iContactService = aContactService;

    iContactStore = aContactStore;

    iStoreContact = aStoreContact;    

    iGroupId = NULL;    

    iGroupLabel = NULL;    

    iTransId = aTransId;

    iCallback = aCallback;

    iLockFlag = EFalse;

    iContact = NULL;

    iGroup = NULL;

    iOp = NULL;

    iErrorID = 0;    

    }

void CAddContactObserver::ConstructL(const TDesC8& aGroupId,

    							     const TDesC& aGroupLabel)

    {

    iGroupId = HBufC8 :: NewL(aGroupId.Length());

    *iGroupId = aGroupId;

    iGroupLabel = HBufC :: NewL(aGroupLabel.Length());

    *iGroupLabel = aGroupLabel;    

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::~CAddContactObserver()

Description        : Destructor

Return values      : N/A										    

-------------------------------------------------------------------------------------

*/

CAddContactObserver::~CAddContactObserver()

    {

    delete iGroupId;

    delete iGroupLabel;

    delete iContact;

  	delete iGroup;

	if(iOp)

	{

	delete iOp;	

	}

    if(iContactStore)

        {

        iContactStore->Close(*this);

        }

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::Cancel()

Description 		: Cancel implementation relevant to AddObserver

Return values		: KErrorNone on Success and KErrGeneral on Failure

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::Cancel()

	{

	iCallback->HandleReturnValue(EOpCancel, KErrNone, iTransId);

	delete this;	

	}

/*

-------------------------------------------------------------------------------------

CAddContactObserver::CreateAndAddFieldToContactL()

Description        : This method creates the contact field and adds to the data base.

Return values      : N/A										    

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::CreateAndAddFieldToContactL()

    {

    TPtrC8 fieldKey(KNullDesC8);

    TPtrC  label(KNullDesC); 

    TPtrC  value(KNullDesC);    

    TBool labelFound = EFalse;

    iErrorID = 0;

    TBuf16<100> bufVal;

    int len =0;

    TBool xspidField = EFalse;

    TBool secTime = EFalse;

    TInt fieldCount = iStoreContact->FieldCount();

	const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());

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

    {

    xspidField = EFalse;

    CSingleContactField* field = iStoreContact->FieldAt(index);

    field->GetFieldDataL(fieldKey, label, value);

    TInt fieldTypeResId = CSearchFields::GetIdFromFieldKey(fieldKey);

    iErrorID =  fieldTypeResId;        

    MVPbkStoreContactField* cntField = 

    			iContact->CreateFieldLC( * contactManager->FieldTypes().Find( fieldTypeResId ) );

    iErrorID = 0;

    TVPbkFieldStorageType storageType = cntField->FieldData().DataType();

    if( EVPbkFieldStorageTypeBinary == storageType )

    	{        

        //(MVPbkContactFieldBinaryData::Cast(cntField->FieldData())).SetBinaryDataL( value8bit );

    	}

    else if( EVPbkFieldStorageTypeDateTime == storageType )

    	{

    	TTime timeVal = field->GetDateTime();

    	(MVPbkContactFieldDateTimeData::Cast(cntField->FieldData())).SetDateTime( timeVal );

    	}

    else if(EVPbkFieldStorageTypeUri == storageType )

        {   

        xspidField = ETrue;

        RPointerArray<HBufC> xspidArray;

        //CleanupClosePushL(xspidArray);

        field->GetXspidDataL(xspidArray);

        TInt count = xspidArray.Count();

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

            {

            if(secTime != EFalse)

            {

            fieldTypeResId = CSearchFields::GetIdFromFieldKey(fieldKey);

            iErrorID =  fieldTypeResId;       

            cntField =  iContact->CreateFieldLC( * contactManager->FieldTypes().Find( fieldTypeResId ) );

            iErrorID = 0;

            storageType = cntField->FieldData().DataType();

            }

            secTime = ETrue;

            HBufC* val = xspidArray[i];            

            bufVal.Copy(val->Des());

            TDes16 desVal = bufVal;

            TPtrC ptrVal; //desVal.Left(0);

            TInt valLen = val->Length();

            len = val->Find(_L(":"));

            if(len != -1)

                {

                TInt trimLen = valLen - len;

                ptrVal.Set(val->Left(valLen - (trimLen)));

                len =0;

                TRAP_IGNORE(cntField->SetFieldLabelL(ptrVal));

                iContact->AddFieldL(cntField);

                CleanupStack::Pop(); //cntField

                }

            else

                {

                CleanupStack::Pop(); //cntField

                User::Leave(KErrArgument);

                }

              //  delete val;

            }

			xspidArray.Reset();

        //CleanupStack::Pop();

        }

    else

    	{

    	(MVPbkContactFieldTextData::Cast(cntField->FieldData())).SetTextL( value );

    	}

    if(xspidField == EFalse)

        {

	TRAP_IGNORE(cntField->SetFieldLabelL(label));

    iContact->AddFieldL(cntField);

    CleanupStack::Pop(); //cntField

        }

    }

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::DoAddL()

Description        : Called for 1) Adding a new contact/group to the contacts database.

                                2) Editing a contact/group from the contacts database.

Return values      : N/A                               

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::DoAddL()

    {

    //if iStoreContact is non-null pointer then it is a new contact or existing contact.

    if( iStoreContact )

        {

        //get contact id from the contact.

    	TPtrC8 cntId = iStoreContact->GetContactId();

    	//If cntId is null then it is new contact, get the fields from the CSingleContact

    	//create new contact, add the fields to it and commit the contact.

    	if( cntId == KNullDesC8 )

            {

            iContact = iContactStore->CreateNewContactLC();

            CleanupStack::Pop(); //contact

            CreateAndAddFieldToContactL();

            iContact->CommitL(*this);

            }

    	else //Edit contact : retrieve contact and update the fields and commit.

        	{

        	const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());

    		MVPbkContactLinkArray* linkArray = contactManager->CreateLinksLC(cntId);

    		const MVPbkContactLink* link = &(linkArray->At(0));

    		CleanupStack::Pop(); //linkArray

    		MVPbkContactOperationBase* iOp =contactManager->RetrieveContactL(*link, *this);

        	}

    }

    //group id is not null and grp label is not null then exiting grp, 

    //retrieve the grp,and edit the label.

    else if( *iGroupId != KNullDesC8 && *iGroupLabel != KNullDesC )

        {

        const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());

    	MVPbkContactLinkArray* linkArray = contactManager->CreateLinksLC(*iGroupId);

    	const MVPbkContactLink* link = &(linkArray->At(0));

    	CleanupStack::Pop(); //linkArray

    	contactManager->RetrieveContactL(*link, *this);

        }

    //if grp id is null and grp label is non-null then, create new grp and set the label.

    else if( *iGroupId == KNullDesC8 && *iGroupLabel != KNullDesC )

        {

    	iGroup = iContactStore->CreateNewContactGroupLC();

    	iGroup->SetGroupLabelL(*iGroupLabel);

    	iGroup->CommitL( *this );

    	CleanupStack::Pop(); //group

        }

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::DoCommitL()

Description        : Commit contact to the contacts database.

Return values      : TInt                               

-------------------------------------------------------------------------------------

*/

TInt CAddContactObserver::DoCommitL( TContactOpResult aResult )

    {

    TInt retVal = KErrGeneral;

	//if lockflag is true, opcode is EContactLock, group id is not null 

	//and grp label is not null then exiting grp, get ptr to grp from 

	//contact and edit the label and commit the same.

	if( iLockFlag && 

		aResult.iOpCode == EContactLock && 

		((*iGroupId != KNullDesC8) && (*iGroupLabel != KNullDesC)) )

    	{

    	MVPbkContactGroup* grpintf = iContact->Group();

    	if(grpintf != NULL)

    	    {

    	grpintf->SetGroupLabelL(*iGroupLabel);

	    (iContact->Group())->CommitL(*this);

		//set lock flag to false, as it is done.

		iLockFlag = EFalse;

		//set return value to ErrNone...completed successfully.

	    retVal = KErrNone;

    	    }

    	}	

	//lock is success, so update the fields in the contact and commit.

	else if( iLockFlag && aResult.iOpCode == EContactLock )

	    {	

		//remove all the fields from the original contact.

		iContact->RemoveAllFields();

		//add new fields to the contact;

		CreateAndAddFieldToContactL( );

		//added all the fields...commit the contact.

		iContact->CommitL( *this );

		//set lock flag to false, as it is done.

		iLockFlag = EFalse;

		//set return value to ErrNone...completed successfully.

		retVal = KErrNone;

	    }

	else if( aResult.iOpCode == EContactCommit )

	    {

		retVal = KErrNone; 

    	}

	return retVal;

    }

/*

-------------------------------------------------------------------------------------

void CAddContactObserver::DoEditContactOrGroupL(MVPbkStoreContact* aContact)

Description        : This method is used to edit the group,it locks 

                     the contact to be edited and performs the edit operation.

Return values      : N/A                                

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::DoEditContactOrGroupL(MVPbkStoreContact* aContact)

    {

	//Edit contact : lock the contact for edit operation.

	iLockFlag = ETrue;

	aContact->LockL(*this);

	if(!iContact )

		{

		iContact = aContact;    

		}

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::ContactOperationCompleted( TContactOpResult aResult )

Description        : Virtual Phonebook Observer method called back once 

                     the contact operation is completed successfully.

Return values      : N/A                                

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::ContactOperationCompleted( TContactOpResult aResult )

    {

	//if lock operation is successfull then it enters here...

	//call DoCommitL(), to commit the contact into the contact store.

	TRAPD(error, error = DoCommitL(aResult));

	if(error == KErrNone)

	    {

	//notify the user with the status of the operation.

	if((aResult.iOpCode != EContactLock) || (error != KErrNone))

	    {

    	//iContactService->RequestComplete(iTransId);

		//iCallback->HandleReturnValue(EOpComplete, error, iTransId);

	    if(iGroupLabel->Compare(KNullDesC) != 0)    //.Compare(KNullDesC)) != 0)

	        {

	        if(iGroup != NULL)

	            {

	        iContactService->RequestComplete(iTransId);

            MVPbkContactLink* link = iGroup->CreateLinkLC();  

            HBufC8* grpId = link->PackLC();

            CleanupStack::Pop(grpId);

            iCallback->HandleReturnId(error, grpId, iTransId);

            CleanupStack::PopAndDestroy();  

            //delete grpId;

            delete this;	  

	            }

	        else

	            {

	            iContactService->RequestComplete(iTransId);

	            iCallback->HandleReturnValue(EOpComplete, error, iTransId);

	            delete this;

	            }

	        }

	    else

	        {

	        if(iContact != NULL)

	            {

	        iContactService->RequestComplete(iTransId);

            MVPbkContactLink* link = iContact->CreateLinkLC();

            HBufC8* cntId = link->PackLC();

            CleanupStack::Pop(cntId);

            iCallback->HandleReturnId(error, cntId, iTransId);

            CleanupStack::PopAndDestroy();

      //      delete cntId;

            delete this;

	            }

	        else

                {

                iContactService->RequestComplete(iTransId);

                iCallback->HandleReturnValue(EOpComplete, error, iTransId);

                delete this;

                }

	        }

	    }

    	}

	else

	    {

	    iContactService->RequestComplete(iTransId);

	    iCallback->HandleReturnValue(EOpError, error, iTransId);

	    delete this;

	    }

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::ContactOperationFailed(TContactOp aOpCode, 

                                            TInt aErrorCode, 

                                            TBool aErrorNotified)

Description        : Virtual Phonebook Observer method called back if 

                     the contact operation is Failed.

Return values      : N/A                               

-------------------------------------------------------------------------------------

*/

void CAddContactObserver::ContactOperationFailed(TContactOp /*aOpCode*/, 

                                                 TInt aErrorCode, 

                                                 TBool /*aErrorNotified*/)

    {

	//operation failed....handle the error

	iContactService->RequestComplete(iTransId);

	iCallback->HandleReturnValue(EOpError, aErrorCode, iTransId);

	delete this;

    }

/*

-------------------------------------------------------------------------------------

CAddContactObserver::ContactOperationFailed(TContactOp aOpCode, 

                                            TInt aErrorCode, 

                                            TBool aErrorNotified)

Description        : Virtual Phonebook Observer method called back when OpenL(),

                     the database open operation is successfull.

Return values      : N/A                                

-------------------------------------------------------------------------------------

*/	    

void CAddContactObserver::StoreReady(MVPbkContactStore& aContactStore)

    {

	iContactStore = &aContactStore;

	TRAPD(error, DoAddL());

    if( error !=  KErrNone )

        {        

       	iContactService->RequestComplete(iTransId);

       	if(error == KErrNotSupported && iErrorID != 0)

            {                        

            iCallback->HandleReturnValue(EInvalidKey, iErrorID, iTransId);    

            }            

        else

            {

            iCallback->HandleReturnValue(EOpComplete, error, iTransId);    

            }    

        delete this;

        }