// Copyright (c) 2005-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 <testframework.h>

#include "TSU_MMFMIDICLNT.h"
#include "TS_MMFMIDICLNTsuite.h"

#include "TestMidiClientUtility.h"

_LIT(KDrmSectName, "SectionDRM");
_LIT(KDrmFileKey, "MidiDrmContent");

const TInt K1Second		=1000000;
const TInt K5Seconds	= 5 * K1Second;
const TInt K30Seconds	=30 * K1Second;

class CCallbackTimer : public CTimer
   	{
public:
   	static CCallbackTimer* NewL();
   	~CCallbackTimer();
   	void SetCb(TCallBack aCallback)
   		{
   		iCallback = aCallback;
   		}
	void After(TTimeIntervalMicroSeconds32 aCancelDelay)
		{
		CTimer::After(aCancelDelay);
		}
	void After(TTimeIntervalMicroSeconds32 aCancelDelay, TCallBack aCallback);

private:
   CCallbackTimer();
   // from CActive
    void RunL();

private:
    TCallBack iCallback; 
    };
    
CCallbackTimer* CCallbackTimer::NewL()
    {
	CCallbackTimer* self=new (ELeave) CCallbackTimer();
   	CleanupStack::PushL(self);
   	self->ConstructL();
   	CleanupStack::Pop();
    return self;
    }
    
CCallbackTimer::CCallbackTimer():CTimer(EPriorityHigh)
	{
	CActiveScheduler::Add(this);
	}

CCallbackTimer::~CCallbackTimer()
    {
    Cancel();
    }


void CCallbackTimer::After(TTimeIntervalMicroSeconds32 aCancelDelay, TCallBack aCallback)
    {
   	iCallback = aCallback;   
   	CTimer::After(aCancelDelay);
    }

/**
*
* RunL
*
**/
void CCallbackTimer::RunL()
    {
    iCallback.CallBack();
    }



CTestStepDrm::CTestStepDrm(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams):
								CTestMmfMidiClntStep(aTestName, aTestType),
								iDrmParams(aDrmParams)
	{
	}

TVerdict CTestStepDrm::DoTestStepPreambleL()
	{
	if (EPass==CTestMmfMidiClntStep::DoTestStepPreambleL())
		{
		iTimer = CCallbackTimer::NewL();
		iTimer->SetCb(TCallBack(TimerGate, this));
		User::LeaveIfError( iFs.Connect() );
		return EPass;
		}
	return EFail;
	}

TVerdict CTestStepDrm::DoTestStepPostambleL()
	{
	delete iTimer;
	iTimer = NULL;
	
	iFile.Close();
	iFs.Close();
	return CTestMmfMidiClntStep::DoTestStepPostambleL();
	}

TVerdict CTestStepDrm::DoTestStepL()
	{
	if (iDrmParams.iTestMode != TDrmTestParams::EAlloc)
		{
		return CTestMmfMidiClntStep::DoTestStepL();
		}
	TVerdict result=EPass;
	TInt failCount = 1;
	TBool completed = EFalse;
	CMidiClientUtility* midiClnt = NULL;
	TInt err;
	while(!completed)	
		{
		iError = KErrNone;
		__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);
		__MM_HEAP_MARK;

		TRAP( err, 
				midiClnt = CMidiClientUtility::NewL(*this);
				result=DoTestL(midiClnt);
			);
		iTimer->Cancel();
		
 		completed = EFalse;
		if (err == KErrNone)
			{
			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test
			if (testAlloc==NULL)
				{
				completed = ETrue;
				}
			else
				{
				completed = ETrue;
				User::Free(testAlloc);
				}
			}
		else if (err != KErrNoMemory) // bad error code
			{
			completed 	= ETrue;
			result		= EFail;
			}
		else
			{
			++failCount;
			}
			
		delete midiClnt;
		midiClnt = NULL;
					
		__UHEAP_RESET;
		__MM_HEAP_MARKEND;
		}
	return result;
	}

/*static*/
TInt CTestStepDrm::TimerGate(TAny* aPtr)
	{
	reinterpret_cast<CTestStepDrm*>(aPtr)->OnTimer();
	return KErrNone;
	}
	
void CTestStepDrm::OnTimer()
	{
	iTimer->Cancel();
	CActiveScheduler::Stop();
	iError = KErrTimedOut;	
	}

TVerdict CTestStepDrm::OpenFileL(CMidiClientUtility* aMidi)
	{
	TPtrC fileName;
	if (iDrmParams.iFileNameKey==NULL)
		{
		if(!GetStringFromConfig(KDrmSectName,KDrmFileKey,fileName))
			{
			return EInconclusive;
			}		
		}
	else
		{
		if(!GetStringFromConfig(KDrmSectName,TPtrC(iDrmParams.iFileNameKey), fileName))
			{
			return EInconclusive;
			}				
		}
	if (iDrmParams.iSourceType==TDrmTestParams::EFileName)
		{
		TPtrC uniqueId(ContentAccess::KDefaultContentObject);
		if (iDrmParams.iUniqueId)
			{
			uniqueId.Set(TPtrC(iDrmParams.iUniqueId));
			}
		if (iDrmParams.iUniqueId==NULL && iDrmParams.iIntent==TDrmTestParams::KNoIntent)
			{
			aMidi->OpenFile(TMMFileSource(fileName));
			}
		else if (iDrmParams.iIntent==TDrmTestParams::KNoIntent)
			{
			aMidi->OpenFile(TMMFileSource(fileName, uniqueId));
			}
		else
			{
			aMidi->OpenFile(TMMFileSource(fileName, uniqueId, iDrmParams.iIntent));
			}		
		}
	else
		{
		iFile.Close();
		User::LeaveIfError( iFs.ShareProtected() );
		User::LeaveIfError( iFile.Open(iFs, fileName, EFileRead | EFileShareExclusive) );
		
		TPtrC uniqueId(ContentAccess::KDefaultContentObject);
		if (iDrmParams.iUniqueId)
			{
			uniqueId.Set(TPtrC(iDrmParams.iUniqueId));
			}
		if (iDrmParams.iUniqueId==NULL && iDrmParams.iIntent==TDrmTestParams::KNoIntent)
			{
			aMidi->OpenFile(TMMFileHandleSource(iFile));
			}
		else if (iDrmParams.iIntent==TDrmTestParams::KNoIntent)
			{
			aMidi->OpenFile(TMMFileHandleSource(iFile, uniqueId));
			}
		else
			{
			aMidi->OpenFile(TMMFileHandleSource(iFile, uniqueId, iDrmParams.iIntent));
			}				
		}

	return EPass;	
	}


/*static*/
CTestDrmNegative* CTestDrmNegative::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams)
	{
	return new (ELeave) CTestDrmNegative(aTestName, aTestType, aDrmParams);
	}

CTestDrmNegative::CTestDrmNegative(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams):
						CTestStepDrm(aTestName, aTestType, aDrmParams)
	{
	}

void CTestDrmNegative::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState /*aNewState*/, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError)
	{
	iError = aError;
	CActiveScheduler::Stop();
	}

TVerdict CTestDrmNegative::DoTestL(CMidiClientUtility* aMidi)
	{
	iTimer->After( TTimeIntervalMicroSeconds32(K5Seconds) );
	TVerdict result=OpenFileL(aMidi);
	if (result!=EPass)
		{
		iTimer->Cancel();
		return result; 
		}
	CActiveScheduler::Start();

	if (iError!=iDrmParams.iExpectedError)
		{
		result=EFail;
		ERR_PRINTF3(_L("Open() gave error %d (expected %d)"),iError, iDrmParams.iExpectedError);
		}
	iTimer->Cancel();
	return result;
	}


/*static*/
CTestDrmPlay* CTestDrmPlay::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams)
	{
	return new (ELeave) CTestDrmPlay(aTestName, aTestType, aDrmParams);
	}

CTestDrmPlay::CTestDrmPlay(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams):
						CTestStepDrm(aTestName, aTestType, aDrmParams)
	{
	}

void CTestDrmPlay::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState aNewState, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError)
	{
	iError 		= aError;
	iLatestState= aNewState;
	CActiveScheduler::Stop();
	}

TVerdict CTestDrmPlay::PlayL(CMidiClientUtility* aMidi, TTimeIntervalMicroSeconds32 aStopAfter)
	{
	iTimer->Cancel();
	iTimer->After(aStopAfter);
	
	TVerdict result=OpenFileL(aMidi);
	if (result!=EPass)
		{
		iTimer->Cancel();
		return result; 
		}
	CActiveScheduler::Start();
	User::LeaveIfError(iError);
	
	aMidi->Play();
	CActiveScheduler::Start();
	User::LeaveIfError(iError);
	if (iLatestState != EMidiStateOpenPlaying)
		{
		iTimer->Cancel();
		ERR_PRINTF3(_L("Play() got state %d (expected %d)"),iLatestState, EMidiStateOpenPlaying);	
		return EFail;
		}
	
	CActiveScheduler::Start();
	
	iTimer->Cancel();
	if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc)
		{
		User::Leave(iError);
		}
		
	return result;
	}

TVerdict CTestDrmPlay::DoTestL(CMidiClientUtility* aMidi)
	{
	TVerdict res=EPass;
	TInt i=iDrmParams.iNumPlayLoops > 0 ? iDrmParams.iNumPlayLoops : 1;
	for (; i && res==EPass && iError==KErrNone; --i)
		{
		TRAP( iError,
				res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K30Seconds));
			);
		}
	if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc)
		{
		User::Leave(iError);
		}		
	if (res==EPass)
		{
		res=(i==0 && iDrmParams.iExpectedError==iError)? EPass : EFail;
		}
		
	if (iError!=iDrmParams.iExpectedError)
		{
		ERR_PRINTF4(_L("Play() gave error %d (expected %d) loops left=%d"),iError, iDrmParams.iExpectedError, i);
		}		
	return res;		
	}

/*
***** Play() -> Stop()
*/
CTestDrmPlayStop* CTestDrmPlayStop::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams)
	{
	return new (ELeave) CTestDrmPlayStop(aTestName, aTestType, aDrmParams);
	}


CTestDrmPlayStop::CTestDrmPlayStop(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams):
					CTestDrmPlay(aTestName, aTestType, aDrmParams)
	{
	}
	
void CTestDrmPlayStop::OnTimer()
	{
	if (iLatestState != EMidiStateOpenPlaying || iStopping)
		{
		iError = KErrGeneral;
		CActiveScheduler::Stop();
		ERR_PRINTF3(_L("CTestDrmPlayStop::OnTimer() got err %d stopping %d"),iError, iStopping);	
		}
	else
		{
		iMidi->Stop(TTimeIntervalMicroSeconds(100000));
		iStopping=ETrue;
		iTimer->After(K5Seconds);
		}
	}
	
TVerdict CTestDrmPlayStop::DoTestL(CMidiClientUtility* aMidi)
	{
	iMidi = aMidi;
	TVerdict res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K5Seconds));
	iTimer->Cancel();
	if (res!=EPass)
		{
		return res;
		}
	return iError==iDrmParams.iExpectedError ? EPass : EFail;
	}

/*
***** Play() -> Stop()
*/

/*static*/
CTestDrmPlayWithUI* CTestDrmPlayWithUI::NewL(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams)
	{
	return new (ELeave) CTestDrmPlayWithUI(aTestName, aTestType, aDrmParams);
	}

CTestDrmPlayWithUI::CTestDrmPlayWithUI(const TDesC& aTestName, const TTestStepType aTestType, const TDrmTestParams& aDrmParams):
						CTestStepDrm(aTestName, aTestType, aDrmParams)
	{
	}

void CTestDrmPlayWithUI::MmcuoStateChanged(TMidiState /*aOldState*/,TMidiState aNewState, const TTimeIntervalMicroSeconds& /*aTime*/,TInt aError)
	{
	iError 		= aError;
	iLatestState= aNewState;
	CActiveScheduler::Stop();
	}

TVerdict CTestDrmPlayWithUI::PlayL(CMidiClientUtility* aMidi, TTimeIntervalMicroSeconds32 aStopAfter)
	{
	iTimer->Cancel();
	iTimer->After(aStopAfter);
	
	TVerdict result=OpenFileL(aMidi);
	if (result!=EPass)
		{
		iTimer->Cancel();
		return result; 
		}
	CActiveScheduler::Start();
	User::LeaveIfError(iError);
	
	MMMFDRMCustomCommand* cmd=aMidi->GetDRMCustomCommand();
	if (cmd==NULL)
		{
		ERR_PRINTF1(_L("GetDRMCustomCommand() returned NULL"));
		return EFail;		
		}
	iError=cmd->SetAgentProperty(ContentAccess::EAgentPropertyAgentUI, ETrue);
	// The test agent should return KErrCANotSupported...
	if (iError != KErrCANotSupported)
		{
		ERR_PRINTF2(_L("SetAgentProperty() Error=%d"),iError);
		return EFail;		
		}
	else
		{
		// ..it has, so flag that there's no error!
		iError = KErrNone;
		}
	User::LeaveIfError(iError);
	
	aMidi->Play();
	CActiveScheduler::Start();
	User::LeaveIfError(iError);
	
	if (iLatestState != EMidiStateOpenPlaying)
		{
		iTimer->Cancel();
		ERR_PRINTF3(_L("Play() got state %d (expected %d)"),iLatestState, EMidiStateOpenPlaying);	
		return EFail;
		}	
	
	CActiveScheduler::Start();
	
	iTimer->Cancel();
	if (iError==KErrNoMemory && iDrmParams.iTestMode==TDrmTestParams::EAlloc)
		{
		User::Leave(iError);
		}
		
	return EPass;
	}

TVerdict CTestDrmPlayWithUI::DoTestL(CMidiClientUtility* aMidi)
	{
	TVerdict res=EPass;
	TInt i=iDrmParams.iNumPlayLoops > 0 ? iDrmParams.iNumPlayLoops : 1;
	for (; i && res==EPass; --i)
		{
		res=PlayL(aMidi, TTimeIntervalMicroSeconds32(K30Seconds));
		}
	if (res==EFail)
		{
		return res;
		}
	if (iError!=iDrmParams.iExpectedError)
		{
		res=EFail;
		ERR_PRINTF3(_L("Play() gave error %d (expected %d)"),iError, iDrmParams.iExpectedError);
		}				
	return res;
	}