// 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 "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 "rightsdatabase.h"

#include "TestDRM.h"

#include <caf/caf.h>

const TInt KDefaultRightsID = 1;

const TInt KDefaultRightsCount = 2;

const TInt KMaxMimeLength = 256;

/**

 * Constructor

 */

CTestMmfAclntDRMPlayerNoRights::CTestMmfAclntDRMPlayerNoRights()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9000-LP");

	}

CTestMmfAclntDRMPlayerNoRights* CTestMmfAclntDRMPlayerNoRights::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMPlayerNoRights* CTestMmfAclntDRMPlayerNoRights::NewLC()

	{

	CTestMmfAclntDRMPlayerNoRights* self = CTestMmfAclntDRMPlayerNoRights::NewL();

	CleanupStack::PushL(self);

	return self;

	}

void CTestMmfAclntDRMPlayerNoRights::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)

	{

	iError = aError;

	iDuration = aDuration;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete"));

	CActiveScheduler::Stop();

	}

void CTestMmfAclntDRMPlayerNoRights::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete"));

	CActiveScheduler::Stop();

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMPlayerNoRights::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestPlayerUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	delete rights; // the database will now be reset and have no entries in it

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioPlayerUtility* player = NULL;

	player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));

	CActiveScheduler::Start();

	if (iError == KErrCANoRights)

		ret = EPass;			

	else

		ret = EFail;

	delete player;

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

//--------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMPlayerRightsCount::CTestMmfAclntDRMPlayerRightsCount()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9001-LP");

	}

CTestMmfAclntDRMPlayerRightsCount* CTestMmfAclntDRMPlayerRightsCount::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMPlayerRightsCount* CTestMmfAclntDRMPlayerRightsCount::NewLC()

	{

	CTestMmfAclntDRMPlayerRightsCount* self = CTestMmfAclntDRMPlayerRightsCount::NewL();

	CleanupStack::PushL(self);

	return self;

	}

void CTestMmfAclntDRMPlayerRightsCount::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)

	{

	iError = aError;

	iDuration = aDuration;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete"));

	CActiveScheduler::Stop();

	}

void CTestMmfAclntDRMPlayerRightsCount::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete"));

	CActiveScheduler::Stop();

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMPlayerRightsCount::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestPlayerUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	CleanupStack::PushL(rights);

	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount); // add rights count 

	CleanupStack::PopAndDestroy(rights); // cleanup rights object

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioPlayerUtility* player = NULL;

	player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));

	CActiveScheduler::Start();

	// Check for errors.

	if (iError == KErrNone && player != NULL)

		{

		iError = KErrTimedOut;

		for (TInt i=0;i<KDefaultRightsCount;i++)

			{

			player->Play();

			// Wait for play callback

			INFO_PRINTF2( _L("Play CMdaAudioPlayerUtility: DRM play number %d"),i);

			CActiveScheduler::Start();

			if (iError != KErrNone)

				{

				INFO_PRINTF2(_L("Unexpected error %d"),iError);

				break;

				}

			}

		if (iError == KErrNone)

			{

			player->Play();

			// Wait for play callback

			INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility with expired rights"));

			CActiveScheduler::Start();

			if (iError != KErrCANoPermission)

				{

				INFO_PRINTF3(_L("Unexpected error %d, expected %d"),iError,KErrCANoPermission);

				}

			else

				{

				INFO_PRINTF1(_L("Expected failure: rights denied"));

				ret = EPass;

				}

			}

		}

	delete player;

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

//----------------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMRecorderNoRights::CTestMmfAclntDRMRecorderNoRights()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9002-LP");

	}

CTestMmfAclntDRMRecorderNoRights* CTestMmfAclntDRMRecorderNoRights::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMRecorderNoRights* CTestMmfAclntDRMRecorderNoRights::NewLC()

	{

	CTestMmfAclntDRMRecorderNoRights* self = CTestMmfAclntDRMRecorderNoRights::NewL();

	CleanupStack::PushL(self);

	return self;

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMRecorderNoRights::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestRecorderUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	delete rights; // the database will now be reset and have no entries in it

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioRecorderUtility* recorder = CMdaAudioRecorderUtility::NewL(*this);

	CleanupStack::PushL(recorder);

	recorder->OpenFileL(filename);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

	CActiveScheduler::Start();

	if (iError == KErrCANoRights)

		ret = EPass;			

	else

		ret = EFail;

	CleanupStack::PopAndDestroy(recorder);

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

void CTestMmfAclntDRMRecorderNoRights::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iError = aErrorCode;

	//iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

	CActiveScheduler::Stop();

	}

//--------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMRecorderRightsCount::CTestMmfAclntDRMRecorderRightsCount()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9003-LP");

	}

CTestMmfAclntDRMRecorderRightsCount* CTestMmfAclntDRMRecorderRightsCount::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMRecorderRightsCount* CTestMmfAclntDRMRecorderRightsCount::NewLC()

	{

	CTestMmfAclntDRMRecorderRightsCount* self = CTestMmfAclntDRMRecorderRightsCount::NewL();

	CleanupStack::PushL(self);

	return self;

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMRecorderRightsCount::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestRecorderUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	CleanupStack::PushL(rights);

	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount); // add rights count 

	CleanupStack::PopAndDestroy(rights); // cleanup rights object

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioRecorderUtility* recorder = CMdaAudioRecorderUtility::NewL(*this);

	CleanupStack::PushL(recorder);

	recorder->OpenFileL(filename);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

	CActiveScheduler::Start();

	// Check for errors.

	if (iError == KErrNone && recorder != NULL)

		{

		iError = KErrTimedOut;

		for (TInt i=0;i<KDefaultRightsCount;i++)

			{

			recorder->PlayL();

			// Wait for play callback

			INFO_PRINTF2( _L("Play CMdaAudioRecorderUtility: DRM play number %d"),i);

			CActiveScheduler::Start();

			if (iError != KErrNone)

				{

				INFO_PRINTF2(_L("Unexpected error %d"),iError);

				break;

				}

			}

		if (iError == KErrNone)

			{

			recorder->PlayL();

			// Wait for play callback

			INFO_PRINTF1( _L("Play CMdaAudioRecorderUtility with expired rights"));

			CActiveScheduler::Start();

			if (iError != KErrCANoPermission)

				{

				INFO_PRINTF3(_L("Unexpected error %d, expected %d"),iError,KErrCANoPermission);

				}

			else

				{

				INFO_PRINTF1(_L("Expected failure: rights denied"));

				ret = EPass;

				}

			}

		}

	CleanupStack::PopAndDestroy(recorder);

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

void CTestMmfAclntDRMRecorderRightsCount::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iError = aErrorCode;

	//iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	TBool busy = (iCurrentState == CMdaAudioClipUtility::ERecording || iCurrentState == CMdaAudioClipUtility::EPlaying);

	if (!busy || iError!=KErrNone)

		CActiveScheduler::Stop();

	INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

	}

//--------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMPlayerOpen::CTestMmfAclntDRMPlayerOpen()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9004-LP");

	}

CTestMmfAclntDRMPlayerOpen* CTestMmfAclntDRMPlayerOpen::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMPlayerOpen* CTestMmfAclntDRMPlayerOpen::NewLC()

	{

	CTestMmfAclntDRMPlayerOpen* self = CTestMmfAclntDRMPlayerOpen::NewL();

	CleanupStack::PushL(self);

	return self;

	}

void CTestMmfAclntDRMPlayerOpen::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)

	{

	iError = aError;

	iDuration = aDuration;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete"));

	CActiveScheduler::Stop();

	}

void CTestMmfAclntDRMPlayerOpen::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete"));

	CActiveScheduler::Stop();

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMPlayerOpen::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestPlayerUtils : File"));

	TVerdict ret = EFail;

	TInt err=KErrNone;

	iError = KErrTimedOut;

	//fectch MIME type from config file

	TBuf8<KMaxMimeLength> mimeType;

	TPtrC				  mimeTypePtr; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavMime"),mimeTypePtr))

		return EInconclusive;

	mimeType.Copy(mimeTypePtr);

	//setup file to open

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	//setup DRM rights

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	CleanupStack::PushL(rights);

	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount,mimeType); // add rights count 

	CleanupStack::PopAndDestroy(rights); // cleanup rights object

	//create instance of Audio Player, which should try open the file as well

	CMdaAudioPlayerUtility* player = NULL;

	TRAP(err, player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this));

	if (iError == KErrNone)//call back OK

	{

		// Wait for initialisation callback

		INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));

		CActiveScheduler::Start();

	}

	else

	{

		INFO_PRINTF2(_L("Unexpected error %d"),iError);

	}

	if (err != KErrNone)

		{

			INFO_PRINTF3(_L("Unexpected error %d, expected %d"),iError,KErrCANoPermission);

		}

	else

		{

			INFO_PRINTF1(_L("Expected: PASS"));

			ret = EPass;

		}

	delete player;

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

//--------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMRecorderPlay::CTestMmfAclntDRMRecorderPlay()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9005-LP");

	}

CTestMmfAclntDRMRecorderPlay* CTestMmfAclntDRMRecorderPlay::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMRecorderPlay* CTestMmfAclntDRMRecorderPlay::NewLC()

	{

	CTestMmfAclntDRMRecorderPlay* self = CTestMmfAclntDRMRecorderPlay::NewL();

	CleanupStack::PushL(self);

	return self;

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMRecorderPlay::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestRecorderUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	//fectch MIME type from config file

	TBuf8<KMaxMimeLength> mimeType;

	TPtrC				  mimeTypePtr; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavMime"),mimeTypePtr))

		return EInconclusive;

	mimeType.Copy(mimeTypePtr);

	//setup DRM rights

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	CleanupStack::PushL(rights);

	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount,mimeType); // add rights count 

	CleanupStack::PopAndDestroy(rights); // cleanup rights object

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioRecorderUtility* recorder = CMdaAudioRecorderUtility::NewL(*this);

	CleanupStack::PushL(recorder);

	recorder->OpenFileL(filename);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

	CActiveScheduler::Start();

	// Check for errors.

	if (iError == KErrNone && recorder != NULL)

		{

		iError = KErrTimedOut;

		recorder->PlayL();

		// Wait for play callback

		INFO_PRINTF1( _L("Play DRM protected file with CMdaAudioRecorderUtility(with sufficient permission)"));

		CActiveScheduler::Start();

		if (iError != KErrNone)

			{

			INFO_PRINTF2(_L("Unexpected error trying to play protected file %d"),iError);

			}

		else

			{

			INFO_PRINTF1(_L("DRM Protected file played successfully"));

			ret = EPass;

			}

		}

	CleanupStack::PopAndDestroy(recorder);

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

void CTestMmfAclntDRMRecorderPlay::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iError = aErrorCode;

	//iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	TBool busy = (iCurrentState == CMdaAudioClipUtility::ERecording || iCurrentState == CMdaAudioClipUtility::EPlaying);

	if (!busy || iError!=KErrNone)

		CActiveScheduler::Stop();

	INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

	}

//--------------------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDRMConverterFail::CTestMmfAclntDRMConverterFail()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-9006-LP");

	}

CTestMmfAclntDRMConverterFail* CTestMmfAclntDRMConverterFail::NewL()

	{

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

	return self;

	}

CTestMmfAclntDRMConverterFail* CTestMmfAclntDRMConverterFail::NewLC()

	{

	CTestMmfAclntDRMConverterFail* self = CTestMmfAclntDRMConverterFail::NewL();

	CleanupStack::PushL(self);

	return self;

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntDRMConverterFail::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestconverterUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	//fectch MIME type from config file

	TBuf8<KMaxMimeLength> mimeType;

	TPtrC				  mimeTypePtr; 

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavMime"),mimeTypePtr))

		return EInconclusive;

	mimeType.Copy(mimeTypePtr);

	//setup DRM rights

	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

	CleanupStack::PushL(rights);

	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount,mimeType); // add rights count 

	CleanupStack::PopAndDestroy(rights); // cleanup rights object

	TBuf<KSizeBuf>	filename;

	TBuf<KSizeBuf>	destFilename;

	TPtrC			filename1; 

	TPtrC			filename2;

	if(!GetStringFromConfig(_L("SectionDRM"),_L("DRMWavFile"),filename1))

		return EInconclusive;

	if(!GetStringFromConfig(_L("SectionDRM"),_L("TestConvertFile"),filename2))

		return EInconclusive;

	GetDriveName(filename);

	filename.Append(filename1);

	GetDriveName(destFilename);

	destFilename.Append(filename2);

	RFs		theFs;

	theFs.Connect();

	theFs.Delete(destFilename);

	theFs.Close();

	iError = KErrTimedOut;

	TMdaFileClipLocation location(destFilename);

	TMdaWavClipFormat	format;

	TMdaPcmWavCodec		codec;

	CMdaAudioConvertUtility* converter = CMdaAudioConvertUtility::NewL(*this);

	CleanupStack::PushL(converter);

	converter->OpenL(filename, &location, &format, &codec);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	// Check for errors.

	if (iError == KErrNone && converter != NULL)

		{

		iError = KErrTimedOut;

		converter->ConvertL();

		// Wait for convert callback

		INFO_PRINTF1( _L("Convert CMdaAudioconverterUtility: DRM play number"));

		CActiveScheduler::Start();

		if (iError == KErrNotSupported)

			{

			INFO_PRINTF1(_L("Correctly received KErrNotSupported, for converting protected file"));

			ret = EPass;

			}

		else

			{

			INFO_PRINTF3(_L("Unexpected error %d, expecting %d"),iError, KErrNotSupported);

			}

		}

	CleanupStack::PopAndDestroy(converter);

	User::After(KOneSecond); // wait for deletion to shut down devsound

	return	ret;

	}

void CTestMmfAclntDRMConverterFail::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iError = aErrorCode;

	//iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	TBool busy = (iCurrentState == CMdaAudioClipUtility::ERecording || iCurrentState == CMdaAudioClipUtility::EPlaying);

	if (!busy || iError!=KErrNone)

		CActiveScheduler::Stop();

	INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioconverterUtility complete"));

	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

	}