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

 // Implements the post-acquisition content protection test.

 // 

 //

 #include "tpostacquisition.h"

 #include "testprotstrdesc.h"

 #include "testagentkeystreamdecoder.h"

 #include <caf/data.h>

 #include <caf/content.h>

 #include <caf/supplier.h>

 #include <caf/metadataarray.h>

 #include <caf/supplieroutputfile.h>

 #include <caf/streaming/keystreamdecoder.h>

 using namespace StreamAccess;

 using namespace ContentAccess;

 CScafPostAcquisition::CScafPostAcquisition(CScafServer& aParent)

 /**

  	Constructor for the postacquisition test object.

  */

 	:	CScafStep(aParent)

 	{

 	SetTestStepName(KScafPostAcquisitionStep);

 	}

 CScafPostAcquisition::~CScafPostAcquisition()

 /**

  	Destructor for the postacquisition test object.

  */

 	{

 	//empty

 	}

 void DeleteFileL(RFs& aFs, const TDesC& aPath)

 	{

 	TInt err = 0;

 	err = aFs.Delete(aPath);

 	if(err != KErrNone && err != KErrNotFound && err != KErrPathNotFound)

 		{

 		User::Leave(err);

 		}

 	}

 TVerdict CScafPostAcquisition::doTestL()

 	{

 	TBool createOutputFile = EFalse;

 	if(!GetBoolFromConfig(ConfigSection(), KCreateOutputFiles, createOutputFile))

 		{

 		ERR_PRINTF2(_L("Failed to read '%S' key of configuration"), &KCreateOutputFiles);

 		SetTestStepResult(EFail);

 		return TestStepResult();

 		}

 	//Ensure pre-conditions

 	CleanAgentsPrivateFolderL(KRtaPrivateFolder());

 	CleanAgentsPrivateFolderL(KStaPrivateFolder());

 	CleanAgentsPrivateFolderL(KTestServerPrivateFolder());

 	CleanAgentsPrivateFolderL(KRtaTestFolder());

 	DeleteFileL(iParent.Fs(), _L("c:\\PostAcquisitionTest.dr"));

 	DeleteFileL(iParent.Fs(), _L("c:\\PostAcquisitionTest.TXT"));

 	//First copy the RO, which allows to record the protected content, into the test agent's private directory

 	CopyFile2AgentsPrivateFolderL(iParent.Fs(), KRecordableRoFileName(), KStaPrivateFolder());

 	//Secondly copy the program protected RO into the test agent's private directory

 	CopyFile2AgentsPrivateFolderL(iParent.Fs(), KPostAcquisitionRoFileName(), KStaPrivateFolder());

 	//Create an SDP document object and set the created key stream field object

 	CSdpDocument* sdpDoc = CreateSdpDocumentLC();

 	//Create a SDP object for RO-Recordable

 	CSdpMediaField* sdp = CreateSdpLC(0);

 	AddMediaFieldL(*sdpDoc, sdp);

 	CleanupStack::Pop(sdp);

 	// Generate a protected key stream description. 

 	HBufC* filePath = GetFullPathLC(KStaPrivateFolder, KNullDesC);

 	CTestProtectedStreamDesc* protectStreamDesc = CTestProtectedStreamDesc::NewL(*filePath);

 	CleanupStack::PopAndDestroy(filePath);

 	CleanupStack::PushL(protectStreamDesc);

 	//Create a key stream decoder

 	CKeyStreamDecoder* decoder = CKeyStreamDecoder::NewL(*protectStreamDesc, *sdp, *sdpDoc); 

 	CleanupStack::PushL(decoder);

 	//Check whether the content is recordable

 	TBool value = EFalse;

 	decoder->GetAttributeL(ECanExport, value);

 	if(!value)

 		{

 		ERR_PRINTF1(_L("The content can not be exported. Unexpected result!"));

 		SetTestStepResult(EFail);

 		User::Leave(KErrCANotSupported);

 		}

 	CImportFile* import(0);

 	_LIT(KPostAcqContentFileName, "postacquisition.content");

 	if(!createOutputFile)

 		{

 		HBufC* outputDir = GetFullPathLC(KRtaPrivateFolder(), KNullDesC());

 		import = decoder->CreateImportSessionLC(_L8("text/plain"), KPostAcqContentFileName(), *outputDir);

 		CleanupStack::Pop(import);

 		CleanupStack::PopAndDestroy(outputDir);

 		CleanupStack::PushL(import);

 		}

 	else

 		{

 		import = decoder->CreateImportSessionLC(_L8("text/plain")); 

 		//To get a better coverage, delete this import object and create another one with zero-length-output-directory.

 		CleanupStack::PopAndDestroy(import);

 		DeleteFileL(iParent.Fs(), _L("c:\\PostAcquisitionTest.dr"));

 		DeleteFileL(iParent.Fs(), _L("c:\\PostAcquisitionTest.TXT"));

 		import = decoder->CreateImportSessionLC(_L8("text/plain"), _L("NULL"), KNullDesC()); 

 		}

 	_LIT8(KStreamingData1,"SampleStreamingDataBegan");

 	_LIT8(KStreamingData2,"TheEndOfStreamingData");

 	_LIT8(KStreamingDataFull,"SampleStreamingDataBeganTheEndOfStreamingData");

 	User::LeaveIfError(import->WriteData(KStreamingData1()));

 	User::LeaveIfError(import->WriteData(KStreamingData2()));

 	//Import has been completed

 	TFileName fileName;

 	TInt err = 0;

 	err = import->WriteDataComplete();

 	while (err == KErrCANewFileHandleRequired)              

         {

         err = ProvideNewOutputFileL(*import, fileName);

         if(err == KErrNone)

         	{

         	err = import->WriteDataComplete();

         	}

         }

 	User::LeaveIfError(err);

 	CleanupStack::PopAndDestroy(3, protectStreamDesc);

 	CleanupStack::PopAndDestroy(); //sdpDoc

 	//Try to read what we have imported

 	CContent* content(0);

 	if(!createOutputFile)

 		{

 		HBufC* filePath = GetFullPathLC(KRtaPrivateFolder(), KPostAcqContentFileName());

 		content = CContent::NewL(*filePath);

 		CleanupStack::PopAndDestroy(filePath);

 		CleanupStack::PushL(content);

 		}

 	else

 		{

 		content = CContent::NewLC(fileName);

 		}

 	CData* mydata = content->OpenContentL(EView);

 	CleanupStack::PushL(mydata);

 	RBuf8 rdata;

 	rdata.CreateL(KStreamingDataFull().Length());

 	rdata.CleanupClosePushL();

 	User::LeaveIfError(mydata->Read(rdata));

 	if(rdata.Compare(KStreamingDataFull()))

 		{

 		SetTestStepResult(EFail);		

 		}

 	CleanupStack::PopAndDestroy(3, content);

 	return TestStepResult();

 	}

 TInt CScafPostAcquisition::ProvideNewOutputFileL(CImportFile& aImport, TDes& aName)

 	{

 	TInt err = 0;

 	// supply new file in order to continue writing

 	aImport.GetSuggestedOutputFileName(aName);

     HBufC* newFullName = GetFullPathLC(KRtaTestFolder(), aName);

     RFile newFile;

     User::LeaveIfError(newFile.Replace(iParent.Fs(), *newFullName, EFileWrite));

     err = aImport.ContinueWithNewOutputFile(newFile, *newFullName);

     newFile.Close();

     aName.Copy(*newFullName);

     CleanupStack::PopAndDestroy(newFullName);

     return err;

 	}