/*

* 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;

	}