/*

 * 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 <e32debug.h>

 #include <ecom/ecom.h>

 #include "resolver.h"

 #include <caf/agentfactory.h>

 #include <caf/agentinterface.h>

 #include "agentinfo.h"

 #include <caf/agent.h>

 #include <caf/cafpanic.h>

 #include <caf/caferr.h>

 #include <caf/patchdata.h>

 using namespace ContentAccess;

 // Constants for the F32 agent

 _LIT(KF32Agent,"F32 CA Agent");

 _LIT(KParentDir, "..\\");

 _LIT(KPrivateDir, "\\private\\");

 const TInt KPrivateDirLength = 9;   // "\\private\\"

 const TInt KPrivateDirAndDriveLength = 11;   // "x:\\private\\"

 const TInt KPrivateDirOffset = 2; // "x:\\"

 EXPORT_C CAgentResolver* CAgentResolver::NewLC(const TBool aDynamicAgentUpdate)

 	{

 	CAgentResolver* self = new (ELeave) CAgentResolver(aDynamicAgentUpdate);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 EXPORT_C CAgentResolver* CAgentResolver::NewL(const TBool aDynamicAgentUpdate)

 	{

 	CAgentResolver* self = CAgentResolver::NewLC(aDynamicAgentUpdate);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CAgentResolver::CAgentResolver(const TBool aDynamicAgentUpdate) : CActive(EPriorityStandard), iDynamicAgentUpdate(aDynamicAgentUpdate)

 	{

 	}

 CAgentResolver::~CAgentResolver()

 	{

 	// remove ourselves from the ActiveScheduler

 	if(IsAdded())

 		{

 		Deque();

 		}

 	// Unload all the agents

 	DestroyListOfAgents();

 	// Close our ECOM session

 	if(iEcomSession)

 		{

 		if(iDynamicAgentUpdate)

 			{

 			iEcomSession->CancelNotifyOnChange(iStatus);

 			}

 		iEcomSession->Close();

 		REComSession::FinalClose();

 		}

 	iSupplierMimeTypes.Close();

 	iConsumerMimeTypes.Close();

 	iAgentInfos.Close();

 	}

 void CAgentResolver::ConstructL()

 	{

 	if(iDynamicAgentUpdate)

 		{

 		// Add ourselves to the current active scheduler so we can get dynamic 

 		// updates when agents are removed or new agents are added

 		CActiveScheduler::Add(this);

 		}

 	iEcomSession = &REComSession::OpenL();

 	// find all the agents

 	BuildListOfAgentsL();

 	if(iDynamicAgentUpdate)

 		{

 		// register for ECOM update notifications in case a new agent appears

 		SetActive();

 		iEcomSession->NotifyOnChange(iStatus);

 		}

 	}

 void CAgentResolver::BuildListOfAgentsL()

 	{

 	TInt err = KErrNone;

 	// Get all plugins which implement the agent interface

 	RImplInfoPtrArray implArray;

 	CleanupStack::PushL(TCleanupItem(CleanImplArray, &implArray));

 	REComSession::ListImplementationsL(KCAAgentInterfaceUid, implArray);

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

 		{

 #ifdef __EPOC32__

 		// On hardware - to load agents from sources other than ROM the patch 

 		// data KCafLoadPostProductionAgents must be set to True (non-zero).

 		// Default SymbianOS behavior is to only load agents from ROM

 		if ((KCafLoadPostProductionAgents == 0) &&

             !implArray[i]->RomBased())

 			{

 			// If the agent is not in ROM, don't load it because it might

 			// be a security risk.

 			continue;

 			}

 #endif

 		// Construct all the agent infos from these implementations

 		TRAP(err, AddAgentL(*implArray[i]));

 		// If we ran out of memory proagate the leave to the caller

 		// otherwise don't let a dodgy agent affect the construction of the other

 		// agents

 		if(err == KErrNoMemory)

 			{

 			User::Leave(KErrNoMemory);

 			}

 		}

 	CleanupStack::PopAndDestroy(&implArray);  

 	if (!iDefaultAgent)

 		{

 		// If we didn't find a default agent, we have a big problem so panic

 		User::Panic(KCafPanicString, ECafPanicNoF32Agent);

 		}

 	}

 void CAgentResolver::AddAgentL(const CImplementationInformation& aImplInfo)

 	{

 	// Create a CAgentInfo instance

 	CAgentInfo* agentInfo = CAgentInfo::NewLC(aImplInfo);

 	if(IsF32Agent(*agentInfo))

 		{

 		// It's the F32 Agent

 		if(iDefaultAgent)

 			{

 			// If we already have a default agent something is seriously wrong

 			User::Panic(KCafPanicString, ECafPanicDuplicateF32Agent);

 			}

 		// Note that the default agent is NOT stored in the agents list, it is a special case

 		iDefaultAgent = agentInfo;

 		CleanupStack::Pop(agentInfo);

 		}

 	else

 		{

 		// All other agents go in the agent list

 		User::LeaveIfError(iAgentInfos.Append(agentInfo));

 		CleanupStack::Pop(agentInfo);

 		TInt mimeIndex=0;

 		// Update our list of all supplier mime types supported by CAF

 		for(mimeIndex=0;mimeIndex < agentInfo->SupplierMimeTypes().Count(); mimeIndex++) 

 			{

 			User::LeaveIfError(iSupplierMimeTypes.Append(*agentInfo->SupplierMimeTypes()[mimeIndex]));

 			}

 		// Update our list of all consumer mime types supported by CAF

 		for(mimeIndex=0;mimeIndex < agentInfo->ConsumerMimeTypes().Count(); mimeIndex++) 

 			{

 			User::LeaveIfError(iConsumerMimeTypes.Append(*agentInfo->ConsumerMimeTypes()[mimeIndex]));

 			}

 		}

 	}

 void CAgentResolver::DestroyListOfAgents()

 	{

 	iSupplierMimeTypes.Reset();

 	iConsumerMimeTypes.Reset();

 	// cant forget to delete the default agent

 	delete iDefaultAgent;

 	iDefaultAgent = NULL;

 	// Free memory assocated with the iAgentInfos array 

 	iAgentInfos.ResetAndDestroy();

 	}

 void CAgentResolver::DoCancel()

 	{

 	// Abort any update notification 

 	iEcomSession->CancelNotifyOnChange(iStatus);

 	}

 void CAgentResolver::RunL()

 	{

 	// Called by the ECOM framework if a new agent appears

 	// remove the existing list of agents and build a new one

 	DestroyListOfAgents();

 	BuildListOfAgentsL();

 	// request notification of any further changes

 	iEcomSession->NotifyOnChange(iStatus);

 	SetActive();

 	}	

 TBool CAgentResolver::IsF32Agent(CAgentInfo& aAgentInfo)

 	{

 	// Check if the agent has no consumer or supplier mime types

 	// and that it has the correct name and Uid

 	if (aAgentInfo.Agent().ImplementationUid() == KF32AgentImplUid

 		&& aAgentInfo.Agent().Name().Compare(KF32Agent()) == 0 

 		&& aAgentInfo.ConsumerMimeTypes().Count() == 0 

 		&& aAgentInfo.SupplierMimeTypes().Count() == 0)

 		{

 		return ETrue;

 		}

 	else

 		{

 		return EFalse;

 		}

 	}

 CAgentInfo& CAgentResolver::ResolveSupplierMimeL(const TDesC8& aMimeType) const

 	{

 	// Go through all the agents and return the one which supports the

 	// required supplier mime type

 	CAgentInfo* retVal=NULL;

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

 		{

 		if (iAgentInfos[i]->IsSupportedSupplier(aMimeType))

 			{

 			retVal = iAgentInfos[i];

 			break;

 			}

 		}

 	if (!retVal)

 		{

 		User::Leave(KErrCANoAgent);

 		}

 	return *retVal;

 	}

 CAgentInfo& CAgentResolver::ResolveConsumerMime(const TDesC8& aMimeType) const

 	{

 	// By default, set the return value to be the default agent. If we find

 	// anything better, then we change it

 	CAgentInfo* retVal = iDefaultAgent;

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

 		{

 		if (iAgentInfos[i]->IsSupportedConsumer(aMimeType))

 			{

 			retVal = iAgentInfos[i];

 			break;

 			}

 		}

 	ASSERT(retVal);

 	return *retVal;

 	}

 CAgentInfo& CAgentResolver::ResolveFileL(const TDesC& aURI, TDes& aActualUri, TContentShareMode aShareMode) const

 	{

 	// Go through all the agents and return the one which supports the file at the given URI	

 	TBool thePrivateDir = EFalse;	

 	TUid agentUid = ResolveDirectory(aURI, aActualUri, thePrivateDir);

 	if(agentUid != iDefaultAgent->Agent().ImplementationUid())

 		{

 		// this file must be living in a private server directory

 		// return the agent who owns the directory

 		return AgentInfoL(agentUid);

 		}

 	else

 		{

 		TInt agentsCount(iAgentInfos.Count());

 		CAgentManager* agentManager = NULL;

 		for (TInt i = 0; i < agentsCount; ++i)

 			{

 			TRAPD(result, agentManager = &iAgentInfos[i]->AgentManagerL());

 			if(result != KErrNone)

 				{

 				if(KErrNoMemory == result)

 					{

 					User::Leave(result);

 					}

 				else

 					{

 					continue;	

 					}

 				}

 			if (agentManager->IsRecognizedL(aURI, aShareMode))

 				{

 				return *iAgentInfos[i];

 				}

 			}

 		}

 	return *iDefaultAgent;

 	}

 CAgentInfo& CAgentResolver::ResolveFileL(RFile& aFile) const

 	{

 	// Go through all the agents and return the one which supports the file

 	TInt agentsCount(iAgentInfos.Count());

 	CAgentManager* agentManager = NULL;

 	for (TInt i = 0; i < agentsCount; ++i)

 		{

 		TRAPD(result, agentManager = &iAgentInfos[i]->AgentManagerL());

 		if(result != KErrNone)

 			{

 			if(KErrNoMemory == result)

 				{

 				User::Leave(result);

 				}

 			else

 				{

 				continue;	

 				}

 			}

 		if (agentManager->IsRecognizedL(aFile))

 			{

 			return *iAgentInfos[i];

 			}

 		}

 	return *iDefaultAgent;

 	}

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 CAgentInfo& CAgentResolver::ResolveFileL(const TDesC8& aHeaderData)

 	{

 	// Go through all the agents and return the one which supports the given WMDRM content.

 	TInt agentsCount(iAgentInfos.Count());

 	CAgentManager* agentManager = NULL;

 	for (TInt i = 0; i < agentsCount; ++i)

 		{

 		TRAPD(result, agentManager = &iAgentInfos[i]->AgentManagerL());

 		if(result != KErrNone)

 			{

 			if(KErrNoMemory == result)

 				{

 				User::Leave(result);

 				}

 			else

 				{

 				continue;	

 				}

 			}

 		if (agentManager->IsRecognizedL(aHeaderData))

 			{

 			return *iAgentInfos[i];

 			}

 		}

     // will never reach here	

 	return *iDefaultAgent;

 	}

 EXPORT_C TBool CAgentResolver::DoRecognizeL(const TDesC8& aHeader, TDes8& aFileMimeType, TDes8& aContentMimeType)

 	{

 	// Go through all the agents and return the one which supports the given WMDRM content.

 	TInt agentsCount(iAgentInfos.Count());

 	CAgentManager* agentManager = NULL;

 	for (TInt i = 0; i < agentsCount; ++i)

 		{

 		TRAPD(result, agentManager = &iAgentInfos[i]->AgentManagerL());

 		if(result != KErrNone)

 			{

 			if(KErrNoMemory == result)

 				{

 				User::Leave(result);

 				}

 			else

 				{

 				continue;	

 				}

 			}

 		if (agentManager->RecognizeContentL(aHeader, aFileMimeType, aContentMimeType))

 			{

 			// force to lower case to ensure that chosen lower case scheme for mime types is maintained

 			aFileMimeType.LowerCase();

 			aContentMimeType.LowerCase();			

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 #endif //#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 TUid CAgentResolver::ResolveDirectory(const TDesC& aPath, TDes& aActualPath, TBool& aThePrivateDir) const

 	{

 	TInt i = 0;

 	TInt pathLength = 0;

 	TBuf <KPrivateDirAndDriveLength> pathLowerCase;

 	// Assume it's a publicly accessable path

 	aThePrivateDir = EFalse;

 	// Find the length of the path and private directory

 	pathLength = aPath.Length();

 	// Check that the path is long enough to be within a private directory

 	// and does not include "..\\".The  "..\\" sequence could be a security risk

 	if(aPath.Find(KParentDir()) == KErrNotFound && pathLength >= KPrivateDirAndDriveLength)

 		{

 		// Create a lower case copy of the left hand side of the path

 		TPtrC lowerCasePtr = aPath.Mid(KPrivateDirOffset, KPrivateDirLength);

 		pathLowerCase.Copy(lowerCasePtr);

 		pathLowerCase.LowerCase();

 		// Compare the first directory in the path to \\private\\ 

 		if(KPrivateDir() == pathLowerCase)

 			{

 			// It is a private directory of some sort

 			if(pathLength > KPrivateDirAndDriveLength)

 				{

 				// It must be a server private directory data cage

 				TPtrC serverDirectoryPath = aPath.Right(pathLength - KPrivateDirAndDriveLength);

 				for(i = 0; i < AgentInfoCount(); i++)

 					{

 					// See if the part after \\private\\ matches the agent name

 					TPtrC privateDirectoryName = AgentInfo(i).PrivateDirectoryName();

 					TPtrC agentName = AgentInfo(i).Agent().Name();

 					if(privateDirectoryName.Length() && agentName.Length() && agentName == serverDirectoryPath.Left(agentName.Length()))

 						{

 						// It must be this agent's private directory

 						// Convert \\private\\agentName\\... to \\private\\SID\\...

 						aActualPath.Copy(aPath.Left(KPrivateDirAndDriveLength));

 						aActualPath.Append(privateDirectoryName);

 						aActualPath.Append(aPath.Right(pathLength - KPrivateDirAndDriveLength - agentName.Length()));

 						return AgentInfo(i).Agent().ImplementationUid();

 						}

 					}

 				}

 			else

 				{

 				// It's just the c:\\private\\ directory

 				// Use the default agent, any calls will just fail

 				aThePrivateDir = ETrue;

 				}

 			}

 		}

 	// Not an agent private directory so just return the default agent

 	aActualPath.Copy(aPath);

 	return iDefaultAgent->Agent().ImplementationUid();

 	}

 HBufC* CAgentResolver::ConvertAgentFileNameL(const TDesC& aFileName) const

 	{

 	TInt i = 0;

 	TInt fileNameLength = 0;

 	TBuf <KPrivateDirAndDriveLength> pathLowerCase;

 	fileNameLength = aFileName.Length();

 	// If the path is shorter than the x:\\private\\ it must be a F32 file

 	if(fileNameLength  > KPrivateDirAndDriveLength)

 		{

 		// Create a lower case copy of the left hand side of the path

 		TPtrC lowerCasePtr = aFileName.Mid(KPrivateDirOffset, KPrivateDirLength);

 		pathLowerCase.Copy(lowerCasePtr);

 		pathLowerCase.LowerCase();

 		// Compare the first directory in the path to \\private\\ 

 		if(KPrivateDir() == pathLowerCase)

 			{

 			// It is a private directory of some sort

 			if(fileNameLength > KPrivateDirAndDriveLength)

 				{

 				// It must be a server private directory data cage

 				TPtrC serverDirectoryPath = aFileName.Right(fileNameLength - KPrivateDirAndDriveLength);

 				for(i = 0; i < AgentInfoCount(); i++)

 					{

 					// See if the part after \\private\\ matches the agent name

 					TPtrC privateDirectoryName = AgentInfo(i).PrivateDirectoryName();

 					TPtrC agentName = AgentInfo(i).Agent().Name();

 					if(privateDirectoryName.Length() && agentName.Length() && privateDirectoryName == serverDirectoryPath.Left(privateDirectoryName.Length()))

 						{

 						// It is this agent's private directory

 						// Convert \\private\\SID\\... \\private\\agentName\\... 

 						HBufC* buffer = HBufC::NewL(fileNameLength - privateDirectoryName.Length() + agentName.Length());

 						TPtr ptr = buffer->Des();

 						ptr.Copy(aFileName.Left(KPrivateDirAndDriveLength));

 						ptr.Append(agentName);

 						ptr.Append(aFileName.Right(fileNameLength - KPrivateDirAndDriveLength - privateDirectoryName.Length()));

 						return buffer;

 						}

 					}

 				}

 			}

 		}

 	return aFileName.AllocL();

 	}

 EXPORT_C TBool CAgentResolver::DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer, TDes8& aFileMimeType, TDes8& aContentMimeType)

 	{

 	// Given the filename and buffer from apparc, ask the agents in turn if they recognize the file

 	// Note this will not call the DefaultAgent (F32) because it won't be able to recognize anything

 	TInt agentsCount(iAgentInfos.Count());

 	CAgentManager* agentManager = NULL;

 	for (TInt i = 0; i < agentsCount; ++i)

 		{

 		TRAPD(result, agentManager = &iAgentInfos[i]->AgentManagerL());

 		if(result != KErrNone)

 			{

 			if(KErrNoMemory == result)

 				{

 				User::Leave(result);

 				}

 			else

 				{

 				continue;	

 				}

 			}

 		if (agentManager->RecognizeFileL(aName, aBuffer, aFileMimeType, aContentMimeType))

 			{

 			// force to lower case to ensure that chosen lower case scheme for mime types is maintained

 			aFileMimeType.LowerCase();

 			aContentMimeType.LowerCase();			

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 void CAgentResolver::CleanImplArray(TAny* aArray)

 	{

 	static_cast<RImplInfoPtrArray*>(aArray)->ResetAndDestroy();

 	}

 EXPORT_C TInt CAgentResolver::PreferredBufferSize()

 	{

 	TInt size=0;

 	if(iDefaultAgent != NULL)

 		{

 		size = iDefaultAgent->PreferredBufferSize();

 		}

 	// Find out the maximum buffer requested by any agent

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

 			{

 			if(iAgentInfos[i]->PreferredBufferSize() > size)

 				{

 				size = iAgentInfos[i]->PreferredBufferSize();

 				}

 			}

 	return size;

 	}

 EXPORT_C const RArray<TPtrC8>& CAgentResolver::ConsumerMimeTypes() const

 	{

 	return iConsumerMimeTypes;

 	}

 EXPORT_C const RArray<TPtrC8>& CAgentResolver::SupplierMimeTypes() const

 	{

 	return iSupplierMimeTypes;

 	}

 CAgentInfo& CAgentResolver::AgentInfoL(const TDesC& aAgentName) const

 	{

 	TBool found = EFalse;

 	TInt i = 0;

 	for(i = 0; i < iAgentInfos.Count(); i++)

 		{

 		if(iAgentInfos[i]->Agent().Name() == aAgentName)

 			{

 			found = ETrue;

 			break;

 			}

 		}

 	if(!found)

 		{

 		// Can't find the agent so leave

 		User::Leave(KErrNotFound);

 		}

 	return *iAgentInfos[i];

 	}

 CAgentInfo& CAgentResolver::AgentInfoL(const TUid& aUid) const

 	{

 	TInt i = 0;

 	TBool found = EFalse;

 	// See if it's the F32 agent

 	if(aUid == DefaultAgentUid())

 		{

 		return *iDefaultAgent;

 		}

 	for(i = 0; i < iAgentInfos.Count(); i++)

 		{

 		if(iAgentInfos[i]->Agent().ImplementationUid() == aUid)

 			{

 			found = ETrue;

 			break;			

 			}

 		}

 	if(!found)

 		{

 		// couldn't find the agent so leave

 		User::Leave(KErrNotFound);

 		}

 	return *iAgentInfos[i];

 	}

 CAgentInfo& CAgentResolver::AgentInfo(TInt aIndex) const

 		{

 		return *iAgentInfos[aIndex];		

 		}

 TInt CAgentResolver::AgentInfoCount() const

 	{

 	return iAgentInfos.Count();	

 	}

 TUid CAgentResolver::DefaultAgentUid() const

 	{

 	return iDefaultAgent->Agent().ImplementationUid();

 	}