/*

 * Copyright (c) 2003-2009 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: 

 *

 */

 #include <ecom/ecom.h>

 #include "agentinfo.h"

 #include <caf/agent.h>

 #include <caf/agentfactory.h>

 #include <caf/agentinterface.h>

 using namespace ContentAccess;

 // Default buffer size of zero

 const TInt KCafApparcBufferSize = 0;

 CAgentInfo* CAgentInfo::NewLC(const CImplementationInformation& aImplInfo)

 	{

 	CAgentInfo* self = new (ELeave) CAgentInfo;

 	CleanupStack::PushL(self);

 	self->ConstructL(aImplInfo);

 	return self;

 	}

 CAgentInfo::CAgentInfo()

 	{

 	}

 CAgentInfo::~CAgentInfo()

 	{

 	iSupplierMimeTypes.ResetAndDestroy();

 	iSupplierMimeTypes.Close();

 	iConsumerMimeTypes.ResetAndDestroy();

 	iConsumerMimeTypes.Close();

 	// Delete the agent manager and agent factory, this may unload the agent DLL

 	delete iAgentManager;

 	delete iAgentFactory;

 	}

 void CAgentInfo::ConstructL(const CImplementationInformation& aImplInfo)

 	{

 	// Set up the agent member with the name and Uid of the agent

 	iAgent.SetValue(aImplInfo.DisplayName(), aImplInfo.ImplementationUid());

 	// get the name of the agents private directory

 	TInt length = aImplInfo.OpaqueData().Length();

 	if(length > KMaxSIDLength)

 		{

 		User::Leave(KErrCorrupt);

 		}

 	else

 		{

 		iPrivateDirectoryName.Copy(aImplInfo.OpaqueData().Left(KMaxSIDLength));

 		}

 	// Extract from the data field from the info.

 	// The data field should be of the form:

 	// "<bufferlength>|<supplier1>,<supplier2>,....,<suppliern>:<consumer1>,<consumer2>"

 	// bufferlength is the desired length of the buffer passed from apparc to DoRecognize

 	TPtrC8 data(aImplInfo.DataType());

 	TPtrC8 supplier(KNullDesC8());

 	TPtrC8 consumer(KNullDesC8());

 	// Search for the "|" field to delimit buffersize and supplier mime types

 	TInt index = data.LocateF('|');

 	if(index < 0)

 		{

 		// No default buffersize, ie. corrupt

 		User::Leave(KErrCorrupt);

 		}

 	else

 		{

 		TPtrC8 buffersize(data.Left(index));

 		TLex8 bufferLex(buffersize);

 		bufferLex.Val(iPreferredBufferSize);

 		// Make sure a buffer size was actually specified before the | character

 		if(iPreferredBufferSize == 0)

 			{

 			iPreferredBufferSize = KCafApparcBufferSize;

 			}

 		// Make sure '|' is not the last character

 		if (index + 1 < data.Length())

 			{

 			data.Set(aImplInfo.DataType().Mid(index + 1));

 			}

 		else 

 			{

 			User::Leave(KErrCorrupt);

 			}

 		}

 	// Search for the ":" field to delimit supplier and consumer

 	index = data.LocateF(':');

 	// If the colon was present, then set the pointers appropriately

 	if (index >= 0)

 		{

 		// Set supplier pointer

 		supplier.Set(data.Left(index));

 		// Check that ':' is not the last character before setting consumer pointer

 		if (index + 1 < data.Length())

 			{

 			consumer.Set(data.Mid(index + 1));

 			}

 		}

 	else

 		{

 		User::Leave(KErrCorrupt);

 		}

 	// Now parse the supplier mime types

 	ParseMimeTypesL(supplier, iSupplierMimeTypes);

 	// Do the same for the consumer mime types

 	ParseMimeTypesL(consumer, iConsumerMimeTypes);

 	}

 CAgentFactory& CAgentInfo::AgentFactoryL()

 	{

 	// Create the agent factory if it hasn't been done already

 	if (!iAgentFactory)

 		{

 		iAgentFactory = CAgentFactory::NewL(iAgent.ImplementationUid());

 		}

 	return *iAgentFactory;

 	}

 CAgentManager& CAgentInfo::AgentManagerL()

 	{

 	// Create the agent manager

 	if (!iAgentManager)

 		{

 		iAgentManager = AgentFactoryL().CreateManagerL();

 		}

 	return *iAgentManager;

 	}	

 TBool CAgentInfo::IsSupportedSupplier(const TDesC8& aSupplierMime) const

 	{

 	for (TInt i = 0; i < iSupplierMimeTypes.Count(); ++i)

 		{

 		if (aSupplierMime == *iSupplierMimeTypes[i])

 			{

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 TBool CAgentInfo::IsSupportedConsumer(const TDesC8& aConsumerMime) const

 	{

 	for (TInt i = 0; i < iConsumerMimeTypes.Count(); ++i)

 		{

 		if (aConsumerMime == *iConsumerMimeTypes[i])

 			{

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 const RPointerArray<HBufC8>& CAgentInfo::SupplierMimeTypes() const

 	{

 	return iSupplierMimeTypes;

 	}

 const RPointerArray<HBufC8>& CAgentInfo::ConsumerMimeTypes() const

 	{

 	return iConsumerMimeTypes;

 	}

 void CAgentInfo::AddToArrayL(const TDesC8& aElement, 

 							 RPointerArray<HBufC8>& aArray)

 	{

 	// Don't bother adding empty elements

 	if (aElement.Length())

 		{

 		HBufC8* newElem = aElement.AllocLC();

 		TPtr8 lowerCasePtr = newElem->Des();

 		lowerCasePtr.LowerCase();

 		User::LeaveIfError(aArray.Append(newElem));

 		CleanupStack::Pop(newElem);

 		}

 	}

 void CAgentInfo::ParseMimeTypesL(const TDesC8& aBuf, 

 								 RPointerArray<HBufC8>& aMimeTypes)

 	{

 	TPtrC8 ptr(aBuf);

 	TInt pos = 0;

 	while ((pos = ptr.LocateF(',')) >= 0)

 		{

 		// Take into account possibility of ,,

 		if (pos > 0)

 			{

 			AddToArrayL(ptr.Left(pos), aMimeTypes);

 			}

 		// Now, move the pointer to the position after the ','. BUT if the

 		// ',' is the last position, then we are done, so return (a bit

 		// dirty, but makes things easier

 		if (pos + 1 < ptr.Length())

 			{

 			ptr.Set(ptr.Mid(pos + 1));

 			}

 		else

 			{

 			// The ',' is the last character, so quit

 			return;

 			}

 		}

 	// Now extract the last mime type.

 	AddToArrayL(ptr, aMimeTypes);

 	}

 TInt CAgentInfo::PreferredBufferSize() const

 	{

 	return iPreferredBufferSize;

 	}

 const TDesC& CAgentInfo::PrivateDirectoryName() const

 	{

 	return iPrivateDirectoryName;

 	}

 TAgent& CAgentInfo::Agent()

 	{

 	return iAgent;

 	}