/*

* 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 organise groups observer functionality.

*

*/

//User includes

#include "organisegroupsobserver.h"

#include "contactcallback.h"

//System include

#include <cvpbkcontactmanager.h>// for iContactManager

#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 <CVPbkContactLinkArray.h>

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

// Static method to create instance of organise groups observer.

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

COrganiseGroupsObserver* COrganiseGroupsObserver::NewL(  CContactService* aContactService,

														  const TDesC8& aGroupId, 

												 		  RPointerArray<TDesC8>& aContactIdArray,

												 		  TBool aAssociateFlag,

												 		  TInt aTransId,

												 		  MContactCallback* aCallback,

												 		  MVPbkContactStore* aContactStore ) 

    {

    COrganiseGroupsObserver* self = new( ELeave ) COrganiseGroupsObserver( );

    CleanupStack::PushL(self);

    self->ConstructL(aContactService, aGroupId, 

    				 aContactIdArray, aAssociateFlag, aTransId, aCallback, aContactStore );

	CleanupStack::Pop(self);

	return self;

    }

//Constructor.

COrganiseGroupsObserver::COrganiseGroupsObserver()

    {

    }

//second-phase constructor

void COrganiseGroupsObserver::ConstructL( CContactService* aContactService,

	    						const TDesC8& aGroupId , 

	    						RPointerArray<TDesC8>& aContactIdArray,

	    						TBool aAssociateFlag,

	    						TInt aTransId,

	    						MContactCallback* aCallback,

				                MVPbkContactStore* aContactStore )

    {

	iContactService = aContactService;

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

	*iGroupId = aGroupId;

	iAssociateFlag = aAssociateFlag;

	iTransId = aTransId;

	iCallback = aCallback;

    iContactStore = aContactStore;

	iContactLinkArray = CVPbkContactLinkArray::NewL();

    iContactManager = &(iContactService->GetContactManager());

	ConvertContactIdsToLinkArrayL( aContactIdArray );

	iOp =NULL;

    }

/*

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

COrganiseGroupsObserver::Cancel()

Description 		: Cancel implementation relevant to OrganiseObserver

Return values		: KErrorNone on Success and KErrGeneral on Failure

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

*/

void COrganiseGroupsObserver::Cancel()

	{

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

	delete this;	

	}

//Get MVPbkContactLinkArray from the dynamic array, which is having contact ids.

void COrganiseGroupsObserver::ConvertContactIdsToLinkArrayL( RPointerArray<TDesC8>& aContactIdArray )

    {

	TInt contactIdCount = aContactIdArray.Count();		

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

	    {

		//get the id from the contact id array

		TPtrC8 contactId = *aContactIdArray[index]; 

		//construct link using contact mngr's CreateLinksLC

		MVPbkContactLinkArray* tmpLinkArray = iContactManager->CreateLinksLC(contactId);

		iLinkArrayToDelete.AppendL(tmpLinkArray);

		iContactLinkArray->AppendL(const_cast<MVPbkContactLink*> (&(tmpLinkArray->At(0))) );		

		CleanupStack::Pop(); //tmpLinkArray

	    }

    }

//Destructor.

COrganiseGroupsObserver::~COrganiseGroupsObserver()

    {

	TInt count = iLinkArrayToDelete.Count();

    if( count )

        {

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

        	{

        	delete iLinkArrayToDelete[index];

        	}

        }

    iLinkArrayToDelete.Reset();

    if(iContactLinkArray)

        {

        iContactLinkArray->Reset();

        delete iContactLinkArray;

        iContactLinkArray = NULL;    

        }      

    delete iLinkArray;

    if(iOp)

    	{

    	delete iOp;

    	}

    if(iContactStore)

    	{

    	iContactStore->Close(*this);    	

    	}

    delete iGroupId;        

    }

//DoGetGroupL : gets the group from the contact manager.

void COrganiseGroupsObserver::DoGetGroupL()

    {

	iLinkArray = iContactManager->CreateLinksLC( *iGroupId );

	iOp = iContactManager->RetrieveContactL( iLinkArray->At(0), *this );

	CleanupStack::Pop();

    }

//Enteres when OpenL() is successfull

void COrganiseGroupsObserver::StoreReady( MVPbkContactStore& /*aContactStore*/ )

    {

	TRAPD(error,DoGetGroupL());

	if(error != KErrNone)

	    {

      	iContactService->RequestComplete(iTransId);

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

		delete this;

	    }

    }

//Eneters when OpenL() fails.

void COrganiseGroupsObserver::StoreUnavailable( MVPbkContactStore& /*aContactStore*/, TInt aReason )

    {

  	iContactService->RequestComplete(iTransId);

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

	delete this;

    }

void COrganiseGroupsObserver::HandleStoreEventL( MVPbkContactStore& /*aContactStore*/, TVPbkContactStoreEvent /*aStoreEvent*/ )

    {

    	//do nothing here     	

    }

//Associtates/Disassociates list of contacts to/from the group.

void COrganiseGroupsObserver::DoOrganiseGroupsL(MVPbkStoreContact* aContact)

    {

	MVPbkContactGroup* groupPtr = aContact->Group();

	if( !groupPtr )

	{

		User::Leave(KErrNotFound);

	}	

	TInt linkCount = iContactLinkArray->Count();

	if(iAssociateFlag)

	{

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

		{

			groupPtr->AddContactL(iContactLinkArray->At(index));

		}

	}

	else

	{

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

		{

			groupPtr->RemoveContactL(iContactLinkArray->At(index));

		}

	}

    delete groupPtr;

    }

//Single contact operation observer methods

void COrganiseGroupsObserver::VPbkSingleContactOperationComplete( MVPbkContactOperationBase& aOperation,

                						 MVPbkStoreContact* aContact)

    {

	delete &aOperation;

	iOp = NULL;

	iContactService->RequestComplete(iTransId);

	TRAPD(error, DoOrganiseGroupsL(aContact));

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

	delete this;

    }

void COrganiseGroupsObserver::VPbkSingleContactOperationFailed( MVPbkContactOperationBase& aOperation, 

                					   TInt aError)

    {	

	delete &aOperation;

	iOp = NULL;

	iContactService->RequestComplete(iTransId);

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

	delete this;

    }