/*

* 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/caftypes.h>

#include <caf/embeddedobject.h>

#include "drmfilecontainer.h"

#include "drmfilecontent.h"

using namespace ReferenceTestAgent;

using namespace ContentAccess;

CDrmFileContainer* CDrmFileContainer::NewL(CDrmFileContainer* aParent)

	{

	CDrmFileContainer* self = new (ELeave) CDrmFileContainer(aParent);

	return self;

	}

CDrmFileContainer::CDrmFileContainer(CDrmFileContainer* aParent) : iParentContainer(aParent)

	{

	}

CDrmFileContainer::~CDrmFileContainer()

	{

	delete iName;

	delete iUniqueId;

	iContainers.ResetAndDestroy();

	iContainers.Close();

	iContents.ResetAndDestroy();

	iContents.Close();

	}

EXPORT_C void CDrmFileContainer::GetEmbeddedObjectsL(RStreamablePtrArray<CEmbeddedObject>& aArray)

	{

	GetEmbeddedObjectsL(aArray, EContainerObject);

	GetEmbeddedObjectsL(aArray, EContentObject);

	}

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

	{

	if(aType == EContentObject)

		{

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

			{

			CDrmFileContent* content = iContents[i];

			CEmbeddedObject* object = CEmbeddedObject::NewL(content->UniqueId(), content->Name(), content->MimeType(), EContentObject);

			CleanupStack::PushL(object);

			aArray.AppendL(object);

			CleanupStack::Pop(object);

			}

		}

	else if(aType == EContainerObject)

		{

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

			{

			CDrmFileContainer* container = iContainers[i];

			CEmbeddedObject* object = CEmbeddedObject::NewL(container->UniqueId(), container->Name(), KNullDesC8(), EContainerObject);

			CleanupStack::PushL(object);

			aArray.AppendL(object);

			CleanupStack::Pop(object);

			}

		}

	}

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

	{

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

	return err;

	}

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

	{

	TInt i = 0;

	TInt searchResult = KErrNotFound;

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

		{

		CDrmFileContent* content = iContents[i];

		// Only add contents if the mime type matches the type we are searching for

		if(content->MimeType().CompareF(aMimeType) == 0)

			{

			CEmbeddedObject* object = CEmbeddedObject::NewL(content->UniqueId(), content->Name(), content->MimeType(), EContentObject);

			CleanupStack::PushL(object);

			aArray.AppendL(object);

			CleanupStack::Pop(object);

			// At least one content object has been found

			searchResult = KErrNone;

			}

		}

	if(aRecursive)

		{

		// Search within embedded containers

		TInt err;

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

			{

			err = iContainers[i]->Search(aArray, aMimeType, aRecursive);

			if(err != KErrNotFound)

				{

				if(err == KErrNone)

					{

					// at least one object has been found

					searchResult = KErrNone;

					}

				else

					{

					// some other unexpected error occurred

					User::Leave(err);

					}

				}

			}

		}

	User::LeaveIfError(searchResult);

	}

CDrmFileContainer* CDrmFileContainer::ParentContainer()

	{

	return iParentContainer;

	}

RPointerArray <CDrmFileContainer>& CDrmFileContainer::Containers()

	{

	return iContainers;

	}

RPointerArray <CDrmFileContent>& CDrmFileContainer::Contents()

	{

	return iContents;

	}

void CDrmFileContainer::ListAllContentL(RPointerArray <CDrmFileContent>& aContentArray)

	{

	TInt i;

	// add content from this container

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

		{

		User::LeaveIfError(aContentArray.Append(iContents[i]));		

		}

	// traverse embedded containers

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

		{

		iContainers[i]->ListAllContentL(aContentArray);

		}

	}

const TDesC& CDrmFileContainer::UniqueId()

	{

	return *iUniqueId;

	}

const TDesC& CDrmFileContainer::Name()

	{

	return *iName;

	}

CDrmFileContainer& CDrmFileContainer::AddContainerL()

	{

	CDrmFileContainer *newContainer = CDrmFileContainer::NewL(this);

	CleanupStack::PushL(newContainer);

	User::LeaveIfError(iContainers.Append(newContainer));

	CleanupStack::Pop(newContainer);

	return *(iContainers[iContainers.Count() - 1]);

	}

void CDrmFileContainer::SetNameL(const TDesC& aName)

	{

	if(iName)

		{

		User::Leave(KErrCorrupt);

		}

	iName = aName.AllocL();

	}

void CDrmFileContainer::SetUniqueIdL(const TDesC& aUniqueId )

	{

	if(iUniqueId)

		{

		User::Leave(KErrCorrupt);

		}

	iUniqueId= aUniqueId.AllocL();

	}

void CDrmFileContainer::AddContentL(const TDesC8& aCid, const TDesC& aName, const TDesC& aUniqueId, const TDesC& aFileName, RAttributeSet& aAttributeSet, RStringAttributeSet& aStringAttributeSet)

	{

	CDrmFileContent *newContent = CDrmFileContent::NewL(aCid, aName, aUniqueId, aFileName, aAttributeSet, aStringAttributeSet);

	CleanupStack::PushL(newContent);

	User::LeaveIfError(iContents.Append(newContent));

	CleanupStack::Pop(newContent);

	}