// Copyright (c) 2008-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
*/

#include "CachedCustomResolver.h"
#include <ecom/implementationproxy.h>
#include <ecom/ecomerrorcodes.h>

/**
This function is used for cleanup support of ListAllL call.
*/
LOCAL_C void CleanupEComPtrArray(TAny* aArray)
	{
	RImplInfoArray* self = static_cast<RImplInfoArray*>(aArray);
	self->Reset();
	delete self;
	}

// static factory method to instantiate the resolver.
CExampleResolver* CExampleResolver::NewL(MPublicRegistry& aRegistry)
	{
	CExampleResolver* self = new(ELeave) CExampleResolver(aRegistry);
	(void)self->GetSignature();
	return self;
	}

CExampleResolver::~CExampleResolver()
	{
	// nothing
	}

CExampleResolver::CExampleResolver(MPublicRegistry& aRegistry)
: CResolver(aRegistry)
	{
	// nothing to do
	}

// stub for the IdentifyImplementationL pure virtual
TUid CExampleResolver::IdentifyImplementationL(TUid aInterfaceUid, 
											   const TEComResolverParams&) const
	{
	RImplInfoArray& implementationsInfo = iRegistry.ListImplementationsL(aInterfaceUid);
	if (implementationsInfo.Count())
		{
		return implementationsInfo[0]->ImplementationUid();
		}
	return KNullUid;
	}

// stub for the ListAllL pure virtual
RImplInfoArray* CExampleResolver::ListAllL(TUid aInterfaceUid, 
										   const TEComResolverParams&) const
	{
	TBool checkMyVersion = (aInterfaceUid == KCustomResolverInterfaceUid);
	TBool foundMyself = EFalse;

	// Ownership of the returned pointer is passed back to the caller.
	// Hence need to new it.
	RImplInfoArray* retList = new(ELeave) RImplInfoArray;
	CleanupStack::PushL(TCleanupItem(CleanupEComPtrArray, retList));

	RImplInfoArray& fullList = iRegistry.ListImplementationsL(aInterfaceUid);
	const TInt numImps = fullList.Count();
	for(TInt index = 0; index < numImps; ++index)
		{
		if (checkMyVersion)
			{
			VerifyVersionL(fullList[index], foundMyself);
			}

		User::LeaveIfError(retList->Append(fullList[index]));
		}

	if (checkMyVersion && !foundMyself)
		{
		RDebug::Print(_L("ECOM: error cachedcustomresolver not in list\n"));
		User::Leave(KEComErrMismatchedTags);
		}

	// Reset the member variable because we are passing ownership back
	CleanupStack::Pop(retList);
	return retList;
	}

//
// Used by test code in list request where the i/f UID is KCustomResolverInterfaceUid.
// This gives the custom resolver object a chance to check that the version listed
// in ECOM registry matches the current running object.
//
// param aImplInfo - the implementation object to check
// param aMe - output parameter to tell the call if 'this' is found
void CExampleResolver::VerifyVersionL(const CImplementationInformation* aImplInfo, TBool& aMe) const
	{
	const TUid KMyImplUid = {0x10009E12};
	if (aImplInfo->ImplementationUid() == KMyImplUid)
		{
		if (GetSignature() != aImplInfo->Version())
			{
			RDebug::Print(_L("ECOM: error registry has ver %d, binary has %d\n"), aImplInfo->Version(), GetSignature());
			// leave with un-used cwcode. But even if ECOM will use this in
			// the future, the code will not occur in a list request.
			User::Leave(KEComErrMismatchedTags);
			}
		aMe = ETrue; // found myself
		}
	}

// __________________________________________________________________________
// Exported proxy for instantiation method resolution
// Define the interface UIDs
const TImplementationProxy ImplementationTable[] = 
	{
	IMPLEMENTATION_PROXY_ENTRY(0x10009E12, CExampleResolver::NewL)
	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
	return ImplementationTable;
	}