// Copyright (c) 2007-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/streaming/keystreamdecoder.h>

#include <caf/streaming/streamagentfactory.h>

#include "streamagentresolver.h"

#include <caf/streaming/protectedstreamdesc.h>

#include "scaflog.h"

#include <caf/supplier.h>

#include <caf/metadataarray.h>

using namespace StreamAccess;

EXPORT_C CKeyStreamDecoder* CKeyStreamDecoder::NewL(const CProtectedStreamDesc& aProtectedStreamDesc, const CSdpMediaField& aSdpKeyStream, const CSdpDocument& aSdpDoc)

	{

	CKeyStreamDecoder* self = CKeyStreamDecoder::NewLC(aProtectedStreamDesc,aSdpKeyStream,aSdpDoc);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CKeyStreamDecoder* CKeyStreamDecoder::NewLC(const CProtectedStreamDesc& aProtectedStreamDesc, const CSdpMediaField& aSdpKeyStream, const CSdpDocument& aSdpDoc)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aProtectedStreamDesc,aSdpKeyStream,aSdpDoc);

	return self;

	}

CKeyStreamDecoder::CKeyStreamDecoder()

	{

	}

CKeyStreamDecoder::~CKeyStreamDecoder()

	{

	delete iAgentKeyStreamDecoder;

	delete iStreamAgentFactory;

	REComSession::DestroyedImplementation(iEcomKey);

	REComSession::FinalClose();	

	}

void CKeyStreamDecoder::ConstructL(const CProtectedStreamDesc& aProtectedStreamDesc, const CSdpMediaField& aSdpKeyStream, const CSdpDocument& aSdpDoc)

	{

	DEBUG_PRINTF(_L("Creating a key stream decoder object."));

	// Create an instance of the Stream Agent Resolver

	CStreamAgentResolver* resolver = CStreamAgentResolver::NewLC();

	/* Retrieve a reference to the CStreamAgentInfo object, associated to the resolved stream agent plugin 

	 * capable of supporting the supplied SDP media description 

	 */

	CStreamAgentInfo& agentInfo = resolver->ResolveSdpKeyStreamL(aSdpKeyStream);

	/* Create a handle to the factory object (CStreamAgentFactory) associated to the

	 * resolved stream agent, so that it can be successfully destroyed and freed having been used 

	 */

	iStreamAgentFactory = static_cast<CStreamAgentFactory *>(REComSession::CreateImplementationL(agentInfo.ImplementationUid(), iEcomKey));

	// Instantiate the necessary implementation of key stream sink

	CKeyStreamSink* keyStreamSink = aProtectedStreamDesc.CreateKeyStreamSinkLC();

	// Retrieve a reference to the stream agents factory

	CStreamAgentFactory& agentFactory = agentInfo.StreamAgentFactory();

	/* The factory is then used to generate an instance of the CAgentKeyStreamDecoder, using the instantiated key

	 * stream sink and the SDP media description

	 */

	iAgentKeyStreamDecoder = agentFactory.GetKeyStreamDecoderL(*keyStreamSink,aSdpKeyStream,aSdpDoc);

	CleanupStack::PopAndDestroy(2,resolver); //< keyStreamSink, resolver

	DEBUG_PRINTF(_L("The key stream decoder object has been created successfully."));

	}

EXPORT_C void CKeyStreamDecoder::GetAttributeL(const TAttribute& aAttribute, TBool& aValue) const

	{

	iAgentKeyStreamDecoder->GetAttributeL(aAttribute, aValue);

	}

EXPORT_C HBufC* CKeyStreamDecoder::GetStringAttributeLC(const TStringAttribute& aAttribute) const

	{

	return iAgentKeyStreamDecoder->GetStringAttributeLC(aAttribute);

	}

EXPORT_C ContentAccess::CImportFile* CKeyStreamDecoder::CreateImportSessionLC(const TDesC8& aContentMimeType, const TDesC& aSuggestedName, const TDesC& aOutputDirectory) const

	{

	return DoCreateImportSessionLC(aContentMimeType, aSuggestedName, aOutputDirectory);

	}

EXPORT_C ContentAccess::CImportFile* CKeyStreamDecoder::CreateImportSessionLC(const TDesC8& aContentMimeType) const

	{

	return DoCreateImportSessionLC(aContentMimeType, KNullDesC(), KNullDesC());

	}

ContentAccess::CImportFile* CKeyStreamDecoder::DoCreateImportSessionLC(const TDesC8& aContentMimeType, const TDesC& aSuggestedName, const TDesC& aOutputDirectory) const

	{

	DEBUG_PRINTF(_L("Creating an import session for post-acquisition content."));

	// Handle to the post-acquisition rights object file owned by the agent

	RFile   fPostAcq;

	// The content Id of the pos-acquisition rights object.

	RBuf8 contentId;

	contentId.CreateL(KMimeTypesMaxLength);

	contentId.CleanupClosePushL();

	// The mime type which will be used to import the rights object

	RBuf8 mimeTypeRights; 

	mimeTypeRights.CreateL(KMimeTypesMaxLength);

	mimeTypeRights.CleanupClosePushL();

	// The mime type which will be used to import the content file.

	RBuf8 mimeTypeContent;

	mimeTypeContent.CreateL(KMimeTypesMaxLength);

	mimeTypeContent.CleanupClosePushL();

	iAgentKeyStreamDecoder->GetPostDeliveryRightsL(fPostAcq, contentId, mimeTypeRights, mimeTypeContent);

	CleanupClosePushL(fPostAcq);

	DEBUG_PRINTF2(_L8("Post-acquisition RO's Mime Type: (%S)"), &mimeTypeRights);

	DEBUG_PRINTF2(_L8("Post-acquisition Content's Mime Type: (%S)"), &mimeTypeContent);

	// Create a supplier

	ContentAccess::CSupplier* supplier = ContentAccess::CSupplier::NewLC();

	// Check if there is any CAF agent supporting postacquisition rights object import

	if(!supplier->IsImportSupported(mimeTypeRights))

		{

		DEBUG_PRINTF2(_L8("A CAF agent capable of importing (%S) mime type can not be found!"), &mimeTypeRights);

		User::Leave(KErrNotSupported);

		}

	// if everything went successfully, create a file import object and import the rights object

	// Create meta-data array

	ContentAccess::CMetaDataArray* metaDataArray = ContentAccess::CMetaDataArray::NewLC();

	// The content Id is provided as suggested name to allow the agent to generate the output file

	HBufC* roName = HBufC::NewLC(contentId.Length());

	TPtr roPtr (roName->Des());

	roPtr.Copy(contentId);

	// Create the import object for the rights object file

	ContentAccess::CImportFile* importRo =  supplier->ImportFileL(mimeTypeRights, *metaDataArray, *roName);

	CleanupStack::PopAndDestroy(roName);

	CleanupStack::PushL(importRo);

	TBuf8<128> buf;

	TInt dataLen = 0;

	// Start importing the content of the post-acquisition RO file

	do

		{

		User::LeaveIfError(fPostAcq.Read(buf));

		dataLen = buf.Length();

		User::LeaveIfError(importRo->WriteData(buf));

		} while(dataLen > 0);

	// Post-acquisition rigths object import is being completed

	User::LeaveIfError(importRo->WriteDataComplete());

	CleanupStack::PopAndDestroy(importRo);

	//The meta data field of the content Id. A content Id is passed to an agent through this meta-data field.

	_LIT8(KMetaDataFieldCid, "cid");

	// Add the (postacq) RO's content id used to match the content with the RO

	metaDataArray->AddL(KMetaDataFieldCid(), contentId);

	//The meta data field of the mime type. A mime type is passed to an agent through this meta-data field.

	_LIT8(KMetaDataFieldMimeType, "mimetype");

	// Add the mime type of the protected streamed data (e.g. video/3gpp)

	metaDataArray->AddL(KMetaDataFieldMimeType(), aContentMimeType);

	// Create the import object for the protected streamed content

	ContentAccess::CImportFile* importContent(0);

	if((aSuggestedName.Length() > 0) && (aOutputDirectory.Length() > 0))

		{

		// A file name is suggested. The client wants the agent to generate the output files.

		DEBUG_PRINTF2(_L("Output filename (%S) is suggested."), &aSuggestedName);

		supplier->SetOutputDirectoryL(aOutputDirectory);

		importContent =  supplier->ImportFileL(mimeTypeContent, *metaDataArray, aSuggestedName);

		}

	else

		{

		// No suggested file name is passed to the agent, the client will provide output files for the agent to use

		DEBUG_PRINTF(_L("Output filename is not suggested."));

		importContent =  supplier->ImportFileL(mimeTypeContent, *metaDataArray);

		}

	CleanupStack::PopAndDestroy(6, &contentId);

	CleanupStack::PushL(importContent);

	DEBUG_PRINTF(_L("Import session has been created successfully."));

	return importContent;

	}