/*

* Copyright (c) 2004-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 <caf/caf.h>

#include "testagentcontent.h"

#include "testagentattributes.h"

using namespace ContentAccess;

_LIT(KDummyContainer,"DummyContainer");

CTestAgentContent* CTestAgentContent::NewL(const TDesC& aURI, TContentShareMode aShareMode)

	{

	CTestAgentContent* self = NewLC(aURI, aShareMode);

	CleanupStack::Pop(self);

	return self;

	}

CTestAgentContent* CTestAgentContent::NewLC(const TDesC& aURI, TContentShareMode aShareMode)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aURI, aShareMode);

	return self;

	}

CTestAgentContent* CTestAgentContent::NewL(RFile& aFile)

	{

	CTestAgentContent* self = NewLC(aFile);

	CleanupStack::Pop(self);

	return self;

	}

CTestAgentContent* CTestAgentContent::NewLC(RFile& aFile)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aFile);

	return self;

	}

CTestAgentContent::CTestAgentContent() 

	{

	iDummyContainerOpen=EFalse;

	}

CTestAgentContent::~CTestAgentContent()

	{

	delete iTestFile;

	delete iTestDrmContent;

	delete iURI;

	iFile.Close();

	iFs.Close();

	}

void CTestAgentContent::ConstructL(const TDesC& aURI, TContentShareMode aShareMode)

	{

	TFileName dummyFileName;

	TTestAgentAttributes::GetDummyFileName(aURI, dummyFileName);

	iURI = dummyFileName.AllocL();

	TUint mode = EFileStream | EFileRead;

	if(aShareMode == EContentShareReadWrite)

		{

		mode |= EFileShareReadersOrWriters;

		}

	else if (aShareMode == EContentShareExclusive)

		{

		mode |= EFileShareExclusive;

		}

	else

		{

		mode |= EFileShareReadersOnly;

		}

	// open underlying file handle

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFile.Open(iFs, *iURI, mode));

	// Create DRM file objects

	iTestFile = CTestAgentFile::NewL(iFile);

	iTestDrmContent = CTestAgentDrmContent::NewL(iFile);

	// reset file pointer back to the beginning of the file

	TInt pos = 0;

	iFile.Seek(ESeekStart,pos);

	iShareMode = aShareMode;

	}

void CTestAgentContent::ConstructL(RFile& aFile)

	{

	User::LeaveIfError(iFile.Duplicate(aFile));

	// Create file objects

	iTestFile = CTestAgentFile::NewL(iFile);

	iTestDrmContent = CTestAgentDrmContent::NewL(iFile);

	// reset file pointer back to the beginning of the file

	TInt pos = 0;

	iFile.Seek(ESeekStart, pos);

	}

TInt CTestAgentContent::OpenContainer(const TDesC& aUniqueId)

	{

	if(!iDummyContainerOpen && aUniqueId == KDummyContainer())

		{

		iDummyContainerOpen = ETrue;

		return KErrNone;

		}

	return KErrNotFound;

	}

TInt CTestAgentContent::CloseContainer()

	{

	if(iDummyContainerOpen)

		{

		iDummyContainerOpen = EFalse;

		return KErrNone;

		}

	return KErrNotFound;

	}

void CTestAgentContent::GetEmbeddedObjectsL(RStreamablePtrArray<CEmbeddedObject>& aArray)

	{

	if(!iDummyContainerOpen)

		{

		// The content object

		CEmbeddedObject *embeddedObject = CEmbeddedObject::NewL(KDefaultContentObject(), *iURI, iTestDrmContent->ContentMimeType(), EContentObject);

		CleanupStack::PushL(embeddedObject);

		aArray.AppendL(embeddedObject);

		// Now owned by the array so do not destroy

		CleanupStack::Pop(embeddedObject);

		embeddedObject = NULL;

		// the file itself

		embeddedObject = CEmbeddedObject::NewL(KNullDesC(), *iURI, iTestFile->ContentMimeType(), EContentObject);

		CleanupStack::PushL(embeddedObject);

		aArray.AppendL(embeddedObject);

		// Now owned by the array so do not destroy

		CleanupStack::Pop(embeddedObject);

		embeddedObject = NULL;

		// The dummy container

		embeddedObject = CEmbeddedObject::NewL(KDummyContainer(), KDummyContainer(), KNullDesC8(), EContainerObject);

		CleanupStack::PushL(embeddedObject);

		aArray.AppendL(embeddedObject);

		// Now owned by the array so do not destroy

		CleanupStack::Pop(embeddedObject);

		embeddedObject = NULL;

		}

	}

void CTestAgentContent::GetEmbeddedObjectsL(RStreamablePtrArray<CEmbeddedObject>& aArray, TEmbeddedType aType)

	{

	CEmbeddedObject *embeddedObject = NULL;

	if(!iDummyContainerOpen)

		{

		// the only embedded object is the file itself

		if(aType == EContentObject)

			{

			// The content object

			embeddedObject = CEmbeddedObject::NewL(KDefaultContentObject(), *iURI, iTestDrmContent->ContentMimeType(), EContentObject);

			CleanupStack::PushL(embeddedObject);

			aArray.AppendL(embeddedObject);

			// Now owned by the array so do not destroy

			CleanupStack::Pop(embeddedObject);

			embeddedObject = NULL;

			// the file itself

			embeddedObject = CEmbeddedObject::NewL(KNullDesC(), *iURI, iTestFile->ContentMimeType(), EContentObject);

			CleanupStack::PushL(embeddedObject);

			aArray.AppendL(embeddedObject);

			// Now owned by the array so do not destroy

			CleanupStack::Pop(embeddedObject);

			embeddedObject = NULL;

			}

		else

			{

			// The dummy container

			embeddedObject = CEmbeddedObject::NewL(KDummyContainer(), KDummyContainer(), KNullDesC8(), EContainerObject);

			CleanupStack::PushL(embeddedObject);

			aArray.AppendL(embeddedObject);

			// Now owned by the array so do not destroy

			CleanupStack::Pop(embeddedObject);

			embeddedObject = NULL;

			}

		}

	}

TInt CTestAgentContent::Search(RStreamablePtrArray<CEmbeddedObject>& aArray, const TDesC8& aMimeType, TBool aRecursive)

	{

	TRAPD(err, SearchL(aArray, aMimeType, aRecursive));

	return err;

	}

void CTestAgentContent::SearchL(RStreamablePtrArray<CEmbeddedObject>& aArray, const TDesC8& aMimeType, TBool )

	{

	CEmbeddedObject *embeddedObject = NULL;

	if(iTestDrmContent->ContentMimeType() == aMimeType)

		{

		// content object matches required mime type

		embeddedObject = CEmbeddedObject::NewL(KDefaultContentObject(), *iURI, iTestDrmContent->ContentMimeType(), EContentObject);

		}

	else if(aMimeType == iTestFile->ContentMimeType())

		{

		// matches the file itself

		embeddedObject = CEmbeddedObject::NewL(KNullDesC(), *iURI, iTestFile->ContentMimeType(), EContentObject);

		}

	else

		{

		User::Leave(KErrNotFound);

		}

	CleanupStack::PushL(embeddedObject);

	aArray.AppendL(embeddedObject);

	// Now owned by the array so do not destroy

	CleanupStack::Pop(embeddedObject);

	}

TInt CTestAgentContent::GetAttribute(TInt aAttribute, TInt& aValue, const TDesC& aUniqueId)

	{

	// check that the unique Id exists

	if(TTestAgentAttributes::CheckUniqueId(aUniqueId) != KErrNone)

		{

		return KErrNotFound;	

		}

	if(aUniqueId.Length() == 0)

		{

		// If it's the entire file

		return iTestFile->GetAttribute(aAttribute, aValue);

		}

	else if(aUniqueId == KDefaultContentObject())

		{

		// If it's the embedded content

		return iTestDrmContent->GetAttribute(aAttribute, aValue);

		}

	return KErrNotFound;

	}

TInt CTestAgentContent::GetAttributeSet(RAttributeSet& aAttributeSet, const TDesC& aUniqueId)

	{

	// check that the unique Id exists

	if(TTestAgentAttributes::CheckUniqueId(aUniqueId) != KErrNone)

		{

		return KErrNotFound;	

		}

	if(aUniqueId.Length() == 0)	

		{

		// The entire file

		return TTestAgentAttributes::GetAttributeSet(*iTestFile, aAttributeSet);

		}

	else if(aUniqueId == KDefaultContentObject())

		{

		// the embedded content

		return TTestAgentAttributes::GetAttributeSet(*iTestDrmContent, aAttributeSet);	

		}

	return KErrNotFound;

	}

TInt CTestAgentContent::GetStringAttribute(TInt aAttribute, TDes& aValue, const TDesC& aUniqueId)

	{

	// check that the unique Id exists

	if(TTestAgentAttributes::CheckUniqueId(aUniqueId) != KErrNone)

		{

		return KErrNotFound;	

		}

	if(aUniqueId.Length() == 0)

		{

		// If it's the entire file

		return iTestFile->GetStringAttribute(aAttribute, aValue);

		}

	else 

		{

		// If it's the embedded content

		return iTestDrmContent->GetStringAttribute(aAttribute, aValue);

		}

	}

TInt CTestAgentContent::GetStringAttributeSet(RStringAttributeSet& aStringAttributeSet, const TDesC& aUniqueId)

	{

	// check that the unique Id exists

	if(TTestAgentAttributes::CheckUniqueId(aUniqueId) != KErrNone)

		{

		return KErrNotFound;	

		}

	if(aUniqueId.Length() == 0)	

		{

		// The entire file

		return TTestAgentAttributes::GetStringAttributeSet(*iTestFile, aStringAttributeSet);

		}

	else

		{

		// the embedded content

		return TTestAgentAttributes::GetStringAttributeSet(*iTestDrmContent, aStringAttributeSet);	

		}

	}

_LIT(KAgentSpecificCommandResponse, "output");

TInt CTestAgentContent::AgentSpecificCommand(TInt aCommand, const TDesC8&, TDes8& aOutputBuffer)

	{

	if(aCommand == 1)

		{

		aOutputBuffer.Copy(KAgentSpecificCommandResponse());

		return KErrNone;

		}

	return KErrCANotSupported;

	}

void CTestAgentContent::AgentSpecificCommand(TInt aCommand, const TDesC8& aInputBuffer, TDes8& aOutputBuffer, TRequestStatus& aStatus)

	{

	TRequestStatus *ptr = &aStatus;

	User::RequestComplete(ptr, AgentSpecificCommand(aCommand, aInputBuffer, aOutputBuffer));

	}

void CTestAgentContent::NotifyStatusChange(TEventMask , TRequestStatus& aStatus, const TDesC& )

	{

	TRequestStatus *ptr = &aStatus;

	User::RequestComplete(ptr, KErrCANotSupported);

	}

TInt CTestAgentContent::CancelNotifyStatusChange(TRequestStatus& , const TDesC& )

	{

	return KErrCANotSupported;

	}

void CTestAgentContent::RequestRights(TRequestStatus& aStatus , const TDesC& )

	{

	TRequestStatus *ptr = &aStatus;

	User::RequestComplete(ptr, KErrCANotSupported);

	}

TInt CTestAgentContent::CancelRequestRights(TRequestStatus& , const TDesC& )

	{

	return KErrCANotSupported;

	}

void CTestAgentContent::DisplayInfoL(TDisplayInfo , const TDesC& )

	{

	User::Leave(KErrCANotSupported);

	}

TInt CTestAgentContent::SetProperty(TAgentProperty /*aProperty*/, TInt /*aValue*/)

	{

	return KErrNone;

	}