// Copyright (c) 2007-2009 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:
//

/**
 @file
 @internalComponent
 @released
*/

  
#include "clplproxyfactory.h"
#include "rcntmodel.h"
#include <ecom/ecom.h>
#include <cntsync.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include "cntsyncecom.h"
#endif

#include "cntviewprivate.h"


// The name of the test phone book sync plugin.  This plugin will be used in the
// first instance (i.e. if it exists then use it rather than any other plugin).
_LIT(KTestPluginName,"Test phone book synchronizer Implementation");


/**
CContactSynchroniser object factory method.

This class is copied from the Persistence Layer.  It should be refactored into
a shared library if possible.

@return CContactSynchroniser object.
*/
CContactSynchroniser* CContactSynchroniser::NewL()
	{
	RImplInfoPtrArray implInfoArray;
	CleanupResetAndDestroyPushL(implInfoArray);
	REComSession::ListImplementationsL(KUidEcomCntPhBkSyncInterface, implInfoArray);
	
	const TInt count = implInfoArray.Count(); 
	__ASSERT_ALWAYS(count > 0, User::Leave(KErrNotSupported));

	TInt pluginToBeUsed = 0;
	CImplementationInformation *info;

	// Scan the list of plugins for the test plugin.
	for (TInt plugIn = 0 ; plugIn < count ; ++plugIn)
	{
		info = implInfoArray[plugIn];
		if(info->DisplayName() == KTestPluginName)
		{
			// We have found the test plugin so use it rather than any other
			// plugin.
			pluginToBeUsed = plugIn;
			break;
		}
	}

	// Create the implementation found for KUidEcomCntPhBkSyncInterface.
	const TUid theImplementationID = implInfoArray[pluginToBeUsed]->ImplementationUid();
	
	TAny* ptr(NULL);
	ptr = REComSession::CreateImplementationL(theImplementationID, _FOFF(CContactSynchroniser,iDtor_ID_Key));

#ifdef __VERBOSE_DEBUG__
	RDebug::Print(_L("[CNTMODEL] CContactSynchroniser::NewL(): Create sync plugin: %S\n"), &info->DisplayName());
#endif

	CleanupStack::PopAndDestroy(&implInfoArray);

	return reinterpret_cast<CContactSynchroniser*>(ptr);
	}


/**
CProxyFactory object factory method.

@param aDb Contacts database used by the proxies this factory provides.

@return CProxyFactory object.
*/
CProxyFactory* CProxyFactory::NewL(const CContactDatabase& aDb)
	{
	CProxyFactory*	self = new (ELeave) CProxyFactory(aDb);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

	
/**
CProxyFactory second phase constructor.
*/
void CProxyFactory::ConstructL()
	{
	}


/**
CProxyFactory first phase constructor.

@param aDb Contacts database used to access Contacts Model session handle.
*/
CProxyFactory::CProxyFactory(const CContactDatabase& aDb)
	:
	iDb(aDb)
	{
	}


/**
CProxyFactory destructor.
*/
CProxyFactory::~CProxyFactory()
	{
	if (iSynchroniser)
		{
		iSynchroniser->Release();  //calls delete this
		iSynchroniser = NULL;
		}	
	delete iManager;
	delete iCollection;
	}


/**
Get the MLplViewItemManager proxy interface.  If the
CViewIteratorProxyManager object does not yet exist then 
create it.

@return MLplViewIteratorManager proxy interface instance.
*/
MLplViewIteratorManager& CProxyFactory::GetViewIteratorManagerL()
	{
	if(iManager == NULL)
		{
		iManager = CViewIteratorProxyManager::NewL(iDb);
		}
	return *iManager;
	}


/**
Get the MContactSynchroniser interface.  If the CContactSynchroniser object does
not yet exist then create it (lazy initialisation).

@return MContactSynchroniser interface instance.
*/
MContactSynchroniser& CProxyFactory::GetContactSynchroniserL(TUint)
	{
	if(iSynchroniser == NULL)
		{
		iSynchroniser = CContactSynchroniser::NewL();
		}
	return *iSynchroniser;
	}


/**
Get the MLplCollection proxy interface.  If the CCollectionProxy proxy object
does not yet exist then create it (lazy initialisation).

@return MLplCollection proxy interface instance.
*/
MLplCollection& CProxyFactory::GetCollectorL()
	{
	if(iCollection == NULL)
		{
		iCollection = new (ELeave) CCollectionProxy(iDb);
		}
	return *iCollection;
	}


/**
CViewIteratorProxyManager object factory method.

@param aDb Contacts database used to access Contacts Model session handle.

@return CViewIteratorProxyManager object.
*/
CViewIteratorProxyManager* CViewIteratorProxyManager::NewL(const CContactDatabase& aDb)
	{
	CViewIteratorProxyManager* self = new (ELeave) CViewIteratorProxyManager(aDb);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}


/**
CViewIteratorProxyManager second phase constructor.
*/
void CViewIteratorProxyManager::ConstructL()
	{
	}


/**
CViewIteratorProxyManager first phase constructor.

@param aDb Contacts database used to access Contacts Model session handle.
*/
CViewIteratorProxyManager::CViewIteratorProxyManager(const CContactDatabase& aDb)
	:
	iDb(aDb)
	{
	}


/**
CViewIteratorProxyManager destructor.
*/
CViewIteratorProxyManager::~CViewIteratorProxyManager()
	{
	}


/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
CViewContact* CViewIteratorProxyManager::ItemAtL(TContactItemId aContactId, TInt aViewId)
	{
	return iDb.iCntSvr->ItemAtL(aContactId, aViewId);
	}

	
/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
TInt CViewIteratorProxyManager::OpenViewL(const CContactTextDef& aTextDef, TContactViewPreferences aViewPrefs)
	{
	return iDb.iCntSvr->OpenViewL(aTextDef, aViewPrefs);
	}
	

/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
void CViewIteratorProxyManager::CloseView(TInt aViewId)
	{
	iDb.iCntSvr->CloseView(aViewId);
	}

	
/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
void CViewIteratorProxyManager::ChangeSortOrderL(TInt aViewId, const CContactTextDef& aTextDef)
	{
	iDb.iCntSvr->ChangeSortOrderL(aViewId, aTextDef);
	}

	
/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
void CViewIteratorProxyManager::BeginIterateL(TInt aViewId)
	{
	iDb.iCntSvr->BeginIterateL(aViewId);
	}
	
	
/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
void CViewIteratorProxyManager::EndIterateL(TInt aViewId)
	{
	iDb.iCntSvr->EndIterateL(aViewId);
	}

	
/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
CViewContact* CViewIteratorProxyManager::NextItemL(TInt aViewId, TContactViewPreferences aViewPrefs)
	{
	return iDb.iCntSvr->NextItemL(aViewId, aViewPrefs);
	}


/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
TUid CViewIteratorProxyManager::ReadContactTextDefL(TContactItemId aContactId, TDes &aResult,const CContactTextDef& aTextDef)
    {
    iDb.iCntSvr->ReadContactTextDefL(aContactId, aResult, aTextDef);
    return TUid(KNullUid); //type uid is not used at client side.   
    }


/**
Proxy implementation of pure virtual methods in MLplViewItemManager.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
void CViewIteratorProxyManager::TextFieldL(TInt aCntItemId,TFieldType aFieldType, TDes& aText)
    {
    iDb.iCntSvr->TextFieldL(aCntItemId, aFieldType, aText);
    }


/**
CCollectionProxy first phase constructor.

@param aDb Contacts database used to access Contacts Model session handle.
*/
CCollectionProxy::CCollectionProxy(const CContactDatabase& aDb)
	:
	iDb(aDb)
	{
	}


/**
Proxy implementation of pure virtual method in MLplCollection.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
CContactIdArray* CCollectionProxy::CollectionL(TLplViewType aViewType,TTime aTime,const TDesC& aGuid)
	{
	return iDb.iCntSvr->CollectionL(aViewType,aTime,aGuid);
	}

/**
Proxy implementation of pure virtual method in MLplCollection.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
TBool CCollectionProxy::SeekContactL(TContactItemId aReqId,TContactItemId& aId,TUid& aContactType, TBool& aDeleted)
	{
	return iDb.iCntSvr->SeekContactL(aReqId, aId, aContactType, aDeleted);		
	}
	
/**
Proxy implementation of pure virtual method in MLplCollection.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.
*/
TInt CCollectionProxy::ContactCountL()
	{
	return iDb.iCntSvr->ContactCountL();
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
TBool CCollectionProxy::ContactMatchesHintFieldL (TInt /*aBitWiseFilter*/, TContactItemId /*aContactId*/)
	{
	return EFalse;		
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
CContactIdArray* CCollectionProxy::MatchPhoneNumberL(const TDesC& /*aNumber*/, const TInt /*aMatchLengthFromRight*/)
	{
	return NULL;	
	}


/**
Proxy implementation of pure virtual method in MLplCollection.

The proxy does not access the Persistence Layer directly.  Instead it uses the
Contacts Model session handle to access the Persistence Layer via the server.

This method could be a dummy implementation since only CContactDatabase calls
the client session FindL() method.
*/
CContactIdArray* CCollectionProxy::FindL(const TDesC& aText, const CContactItemFieldDef* aFieldDef, TUint /*aSessionId*/)
	{
	return iDb.iCntSvr->FindL(aText,aFieldDef);
	}

	
/**
Dummy method - implemented in the Persistence Layer.
*/
CContactIdArray* CCollectionProxy::FilterDatabaseL(CCntFilter& /*aFilter*/)
	{
	return NULL;
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
void CCollectionProxy::Reset()
	{
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
void CCollectionProxy::FindAsyncInitL(const TDesC& /*aText*/,CContactItemFieldDef* /*aFieldDef*/)
	{
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
void CCollectionProxy::FindAsyncTextDefInitL(const CDesCArray& /*aWords*/,CContactTextDef* /*aTextDef*/)
	{
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
CContactIdArray* CCollectionProxy::FindAsyncL(TBool& /*aMoreToGo*/, TUint /*aSessionId*/)
	{
	return NULL;
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
TBool CCollectionProxy::UsesIdentityFieldsOnly(TInt /*aFindFlags*/)
	{
	return EFalse;		
	}


/**
Dummy method - implemented in the Persistence Layer.
*/
void CCollectionProxy::ConstructBitwiseFlagsFromTextDef(TInt& /*aFindFlags*/, TInt& /*aIdentityColumnsCount*/, const CContactTextDef* /*aTextDef*/)	
	{
	}