/*

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

 #include <caf/data.h>

 #include <caf/agentinterface.h>

 #include "agentinfo.h"

 #include <caf/agentfactory.h>

 #include <caf/attributeset.h>

 #include <caf/virtualpath.h>

 #include "resolver.h"

 #include "agentinfo.h"

 #include <e32def.h>

 using namespace ContentAccess;

 EXPORT_C CData* CData::NewL(const TVirtualPathPtr& aVirtualPath, TIntent aIntent, TContentShareMode aShareMode)

 	{

 	CData *self = CData::NewLC(aVirtualPath, aIntent, aShareMode);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(const TVirtualPathPtr& aVirtualPath, TIntent aIntent, TContentShareMode aShareMode)

 	{

 	CData *self = new (ELeave) CData;

 	CleanupStack::PushL(self);

 	self->ConstructL(aVirtualPath, aIntent, aShareMode);

 	return self;

 	}

 EXPORT_C CData* CData::NewL(RFile& aFile, const TDesC& aUniqueId, TIntent aIntent)

 	{

 	CData *self = CData::NewLC(aFile, aUniqueId, aIntent);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(RFile& aFile, const TDesC& aUniqueId, TIntent aIntent)

 	{

 	CData *self = new (ELeave) CData;

 	CleanupStack::PushL(self);

 	self->ConstructL(aFile, aUniqueId, aIntent);

 	return self;

 	}

 EXPORT_C CData* CData::NewL(const TVirtualPathPtr& aVirtualPath, TContentShareMode aShareMode)

 	{

 	CData *self = CData::NewLC(aVirtualPath, aShareMode);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(const TVirtualPathPtr& aVirtualPath, TContentShareMode aShareMode)

 	{

 	CData *self = new (ELeave) CData;

 	CleanupStack::PushL(self);

 	self->ConstructL(aVirtualPath, aShareMode);

 	return self;

 	}

 EXPORT_C CData* CData::NewL(RFile& aFile, const TDesC& aUniqueId)

 	{

 	CData *self = CData::NewLC(aFile, aUniqueId);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(RFile& aFile, const TDesC& aUniqueId)

 	{

 	CData *self = new (ELeave) CData;

 	CleanupStack::PushL(self);

 	self->ConstructL(aFile, aUniqueId);

 	return self;

 	}

 CData* CData::NewLC(TUid aUid,

 					const TVirtualPathPtr& aVirtualPath,

 					TIntent aIntent,

 					TContentShareMode aShareMode)

 	{

 	CData* self = new(ELeave) CData();

 	CleanupStack::PushL(self);

 	self->ConstructL(aUid, aVirtualPath, aIntent, aShareMode);

 	return self;

 	}

 CData* CData::NewLC(TUid aUid, RFile& aFile, const TDesC& aUniqueId, TIntent aIntent)

 	{

 	CData* self = new (ELeave) CData();

 	CleanupStack::PushL(self);

 	self->ConstructL(aUid, aFile, aUniqueId, aIntent);

 	return self;

 	}

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 EXPORT_C CData* CData::NewL(const TDesC8& aHeaderData)

 	{

 	CData* self = CData::NewLC(aHeaderData);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewL(const TDesC8& aHeaderData, TIntent aIntent)

 	{

 	CData* self = CData::NewLC(aHeaderData, aIntent);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(const TDesC8& aHeaderData)

 	{

 	CData* self = new (ELeave) CData();

 	CleanupStack::PushL(self);

 	self->ConstructL(aHeaderData);

 	return self;

 	}

 EXPORT_C CData* CData::NewLC(const TDesC8& aHeaderData, TIntent aIntent)

 	{

 	CData* self = new (ELeave) CData();

 	CleanupStack::PushL(self);

 	self->ConstructL(aHeaderData, aIntent);

 	return self;

 	}

 CData* CData::NewLC(TUid aAgentUid, const TDesC8& aHeaderData, TIntent aIntent)

 	{

 	CData* self = new (ELeave) CData();

 	CleanupStack::PushL(self);

 	self->ConstructL(aAgentUid, aHeaderData, aIntent);

 	return self;

 	}

 #endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 CData::CData()

 	{ 

 	}

 CData::~CData() 

 	{ 

 	// Destroy the agent implementation

 	delete iAgentData;

 	// close ECOM session, may result in the unloading of the DLL

 	delete iAgentFactory;

 	REComSession::FinalClose();

 	}

 void CData::ConstructL(const TVirtualPathPtr& aVirtualPath, TIntent aIntent, TContentShareMode aShareMode)

 	{

 	// Create the agent resolver which will contains a reference to

 	// the agent responsible for this piece of content

 	CAgentResolver* resolver = CAgentResolver::NewLC(EFalse);

 	// Create a temporary buffer used to store the translated version of the URI

 	HBufC* actualUri = HBufC::NewLC(aVirtualPath.URI().Length() + KMaxSIDLength);

 	TPtr uri = actualUri->Des();

 	// Find the agent who handles the file and translate the URI if it is pointing to a private directory 

 	CAgentInfo& agentInfo = resolver->ResolveFileL(aVirtualPath.URI(), uri, aShareMode);

 	// Figure out the Uid of the agent

 	TUid agentUid = agentInfo.Agent().ImplementationUid();

 	// call internal CData::NewL()

 	CData::ConstructL(agentUid, TVirtualPathPtr(*actualUri, aVirtualPath.UniqueId()), aIntent, aShareMode);

 	CleanupStack::PopAndDestroy(2, resolver); // actualUri, resolver

 	}

 void CData::ConstructL(const TVirtualPathPtr& aVirtualPath, TContentShareMode aShareMode)

 	{

 	// Create the agent resolver which will contains a reference to

 	// the agent responsible for this piece of content

 	CAgentResolver* resolver = CAgentResolver::NewLC(EFalse);

 	// Create a temporary buffer used to store the translated version of the URI

 	HBufC* actualUri = HBufC::NewLC(aVirtualPath.URI().Length() + KMaxSIDLength);

 	TPtr uri = actualUri->Des();

 	// Find the agent who handles the file and translate the URI if it is pointing to a private directory 

 	CAgentInfo& agentInfo = resolver->ResolveFileL(aVirtualPath.URI(), uri, aShareMode);

 	// Figure out the Uid of the agent

 	TUid agentUid = agentInfo.Agent().ImplementationUid();

 	// call internal CData::NewL()

 	CData::ConstructL(agentUid, TVirtualPathPtr(*actualUri, aVirtualPath.UniqueId()), aShareMode);

 	CleanupStack::PopAndDestroy(2, resolver); // actualUri, resolver

 	}

 void CData::ConstructL(RFile& aFile, const TDesC& aUniqueId, TIntent aIntent)

 	{

 	// Find the agent who handles the file

 	CAgentResolver* resolver = CAgentResolver::NewLC(EFalse);

 	CAgentInfo& agentInfo = resolver->ResolveFileL(aFile);

 	// Figure out the Uid of the agent

 	TUid agentUid = agentInfo.Agent().ImplementationUid();

 	// call other constructL now that we have the Uid

 	CData::ConstructL(agentUid, aFile, aUniqueId, aIntent);

 	// Cleanup resolver after creating CData to unnecessary 

 	// unloading and loading of agent plug-ins

 	CleanupStack::PopAndDestroy(resolver); 

 	}

 void CData::ConstructL(RFile& aFile, const TDesC& aUniqueId)

 	{

 	// Find the agent who handles the file

 	CAgentResolver* resolver = CAgentResolver::NewLC(EFalse);

 	CAgentInfo& agentInfo = resolver->ResolveFileL(aFile);

 	// Figure out the Uid of the agent

 	TUid agentUid = agentInfo.Agent().ImplementationUid();

 	// call other constructL now that we have the Uid

 	CData::ConstructL(agentUid, aFile, aUniqueId);

 	// Cleanup resolver after creating CData to unnecessary 

 	// unloading and loading of agent plug-ins

 	CleanupStack::PopAndDestroy(resolver); 

 	}

 void CData::ConstructL(TUid aUid,

 					   const TVirtualPathPtr& aVirtualPath,

 					   TIntent aIntent,

 					   TContentShareMode aShareMode)

 	{

 	CData::ConstructL(aUid, aVirtualPath, aShareMode);

 	// Ensure that client's intent is possible

 	User::LeaveIfError(iAgentData->EvaluateIntent(aIntent));

 	}

 void CData::ConstructL(TUid aUid,

 					   const TVirtualPathPtr& aVirtualPath,

 					   TContentShareMode aShareMode)

 	{

 	iAgentUid = aUid;

 	// create our own agent factory (de-facto session handle for ECOM)

 	iAgentFactory = CAgentFactory::NewL(iAgentUid);

 	// Create an instance of the Agent's CAgentData

 	iAgentData = iAgentFactory->CreateDataConsumerL(aVirtualPath, aShareMode);

 	}

 void CData::ConstructL(TUid aUid, RFile& aFile, const TDesC& aUniqueId, TIntent aIntent)

 	{

 	CData::ConstructL(aUid, aFile, aUniqueId);

 	// Ensure that client's intent is possible

 	User::LeaveIfError(iAgentData->EvaluateIntent(aIntent));

 	}

 void CData::ConstructL(TUid aUid, RFile& aFile, const TDesC& aUniqueId)

 	{

 	iAgentUid = aUid;

 	// create our own agent factory (de-facto session handle for ECOM)

 	iAgentFactory = CAgentFactory::NewL(iAgentUid);

 	// Create an instance of the agent's CAgentData

 	// The agent must make a duplicate of the file handle

 	iAgentData = iAgentFactory->CreateDataConsumerL(aFile, aUniqueId);

   	}

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 void CData::ConstructL(const TDesC8& aHeaderData)

 	{

 	// Find the agent who handles the file

 	CAgentResolver* resolver = CAgentResolver::NewLC(EFalse);

 	CAgentInfo& agentInfo = resolver->ResolveFileL(aHeaderData);

 	// Figure out the Uid of the agent

 	TUid agentUid = agentInfo.Agent().ImplementationUid();

 	CData::ConstructL(agentUid, aHeaderData);

 	// Cleanup resolver after creating CData to unnecessary 

 	// unloading and loading of agent plug-ins

 	CleanupStack::PopAndDestroy(resolver); 

 	}

 void CData::ConstructL(const TDesC8& aHeaderData, TIntent aIntent)

 	{

 	CData::ConstructL(aHeaderData);

 	// Ensure that client's intent is possible

 	User::LeaveIfError(iAgentData->EvaluateIntent(aIntent));

 	}

 void CData::ConstructL(TUid aAgentUid, const TDesC8& aHeaderData)

 	{

 	iAgentUid = aAgentUid;

 	iAgentFactory = CAgentFactory::NewL(iAgentUid);

 	// create an instance of agent's CAgentStreamData.

 	iAgentData = iAgentFactory->CreateDataConsumerL(aHeaderData);

 	}

 void CData::ConstructL(TUid aUid, const TDesC8& aHeaderData, TIntent aIntent)

 	{

 	CData::ConstructL(aUid, aHeaderData);

 	// Ensure that client's intent is possible

 	User::LeaveIfError(iAgentData->EvaluateIntent(aIntent));

 	}

 #endif //#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 EXPORT_C void CData::DataSizeL(TInt& aSize)

 	{

 	// ask the agent for the data size of the current content object

 	iAgentData->DataSizeL(aSize);

 	}

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C void CData::DataSize64L(TInt64& aSize)

 	{

 	// ask the agent for the data size of the current content object

 	TRAPD(err, iAgentData->DataSize64L(aSize));

 	if(err == KErrCANotSupported)

 		{

 		//fallback to 32bit API

 		TInt size32;

 		iAgentData->DataSizeL(size32);

 		aSize = size32;

 		}

 	else

 		User::LeaveIfError(err);

 	}

 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C TInt CData::EvaluateIntent(TIntent aIntent)

 	{

 	// ask the agent to re-evaluate the intent on the current content object

 	return iAgentData->EvaluateIntent(aIntent);

 	}

 EXPORT_C TInt CData::ExecuteIntent(TIntent aIntent)

 	{

 	// ask the agent to re-evaluate the intent on the current content object

 	return iAgentData->ExecuteIntent(aIntent);

 	}

 EXPORT_C TInt CData::Read(TDes8& aDes) const

 	{

 	// ask the agent to read plaintext from the content object 

 	return iAgentData->Read(aDes);

 	}

 EXPORT_C TInt CData::Read(TDes8& aDes, TInt aLength) const

 	{

 	// ask the agent to read plaintext from the content object 

 	return iAgentData->Read(aDes, aLength);

 	}

 EXPORT_C void CData::Read(TDes8& aDes, 

 						  TRequestStatus& aStatus) const

 	{

 	// ask the agent to read plaintext from the content object 

 	iAgentData->Read(aDes, aStatus);

 	}

 EXPORT_C void CData::Read(TDes8& aDes, 

 						  TInt aLength, 

 						  TRequestStatus& aStatus) const

 	{

 	// ask the agent to read plaintext from the content object 

 	iAgentData->Read(aDes, aLength, aStatus);

 	}

 EXPORT_C void CData::ReadCancel(TRequestStatus &aStatus) const

 	{

 	iAgentData->ReadCancel(aStatus);

 	}

 #ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 EXPORT_C TInt CData::Read(const TDesC8& aEncryptedInputDataPacket, TDes8& aDecryptedOutputPacket) const

 	{

 	return iAgentData->Read(aEncryptedInputDataPacket, aDecryptedOutputPacket);

 	}

 EXPORT_C void CData::Read(const TDesC8& aEncryptedInputDataPacket, TDes8& aDecryptedOutputPacket, TRequestStatus& aStatus) const

 	{

 	iAgentData->Read(aEncryptedInputDataPacket, aDecryptedOutputPacket, aStatus);

 	}

 #endif //#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	EXPORT_C TInt CData::Read_Unused(TInt aPos, TDes8& aDes, 

 								TInt aLength, TRequestStatus& aStatus) const

 #else

 	EXPORT_C TInt CData::Read(TInt aPos, TDes8& aDes, 

 								TInt aLength, TRequestStatus& aStatus) const

 #endif

 	{

 	// ask the agent to read plaintext from the content object 

 	if(aPos<0)

 		return KErrArgument;

 	return iAgentData->Read(aPos, aDes, aLength, aStatus);

 	}

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C TInt CData::Read(TInt64 aPos, TDes8& aDes,

 						  TInt aLength, TRequestStatus& aStatus) const

 	{

 	// If agent does not support 64bit Read, a fallback to 32bit Read is provided automatically

 	// The above API method signature allows error codes to be returned

 	// via two different routes (return code & aStatus). Should the async request 

 	// dispatch fail then an error code is returned immediately via the 

 	// aStatus parameter rather than via the return code of the function.	

 	// NOTE: it is not generally not recommended for functions to be able to return

 	// error codes in two different ways as this places a bigger error-checking

 	// burden on clients.

 	if(aPos<0)

 		return KErrArgument;

 	TInt rval = iAgentData->Read64(aPos, aDes, aLength, aStatus);

 	return (rval == KErrCANotSupported? iAgentData->Read((TInt)aPos, aDes, aLength, aStatus) : rval );

 	}

 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C TInt CData::Seek(TSeek aMode,TInt& aPos) const

 	{

 	// ask the agent to seek witin the plaintext 

 	return iAgentData->Seek(aMode, aPos);

 	}

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C TInt CData::Seek64(TSeek aMode,TInt64& aPos) const

 	{

 	// ask the agent to seek witin the plaintext 

 	TInt rval64 = iAgentData->Seek64(aMode, aPos);

 	if(rval64 == KErrCANotSupported)

 		{

 		//fallback to 32bit API

 		TInt pos32 = I64INT(aPos);

 		TInt rval32 = iAgentData->Seek(aMode, pos32);

 		aPos = pos32;

 		return rval32;

 		}

 	return rval64;

 	}

 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 EXPORT_C TInt CData::SetProperty(TAgentProperty aProperty, TInt aValue)

 	{

 	// Set a property within the agent

 	return iAgentData->SetProperty(aProperty, aValue);

 	}

 EXPORT_C TInt CData::GetAttribute(TInt aAttribute, TInt& aValue) const

 	{

 	// Get an attribute related to this content object

 	return iAgentData->GetAttribute(aAttribute, aValue);

 	}

 EXPORT_C TInt CData::GetAttributeSet(RAttributeSet& aAttributeSet) const

 	{

 	// Get a set of attributes related to this content object

 	return iAgentData->GetAttributeSet(aAttributeSet);

 	}

 EXPORT_C TInt CData::GetStringAttribute(TInt aAttribute, TDes& aValue) const

 	{

 	// Get a string attribute related to this content object

 	return iAgentData->GetStringAttribute(aAttribute, aValue);

 	}

 EXPORT_C TInt CData::GetStringAttributeSet(RStringAttributeSet& aStringAttributeSet) const

 	{

 	// Get a set of string attributes related to this content object

 	return iAgentData->GetStringAttributeSet(aStringAttributeSet);

 	}

 #ifndef REMOVE_CAF1

 EXPORT_C void CData::SetQosL(TQosAttribute aQosAttr, TInt aValue)

 	{

 	if(aQosAttr == EQosBufferSize)

 		{

 		User::LeaveIfError(iAgentData->SetProperty(EAgentPropertyBufferSize, aValue));

 		}

 	}

 EXPORT_C TBool CData::GetMimeTypeL(TDes8& aMimeType) const

 	{

 	TBuf16 <KMaxDataTypeLength> mimeType;

 	TInt err = KErrNone;

 	if(iAgentUid != KF32AgentImplUid)

 		{

 		err = iAgentData->GetStringAttribute(EMimeType, mimeType);

 		if(err == KErrNone && mimeType.Length() != 0)

 			{

 			aMimeType.Copy(mimeType);

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 #endif // REMOVE_CAF1