--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contentmgmt/cafstreamingsupport/source/keystreamdecoder.cpp	Mon Mar 15 12:46:43 2010 +0200
@@ -0,0 +1,199 @@
+// 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;
+	}