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