// play.cpp
// 
// Copyright (c) 2005 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//


#include <e32base.h>
#include <bacline.h>
#include <mmf/server/sounddevice.h>
#include "play.h"

_LIT(KNewLine, "\n");


//______________________________________________________________________________
//						~CCmdPlay
CCommandBase* CCmdPlay::NewLC()
	{
	CCmdPlay* self = new(ELeave)CCmdPlay();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
void CCmdPlay::ConstructL()
	{
	BaseConstructL();
	iPlayer = CMmfPlayer::NewL(Stdout());
	}
	
CCmdPlay::~CCmdPlay()
	{
	delete iPlayer;
	}
	
const TDesC& CCmdPlay::Name() const
	{
	_LIT(KName, "play");
	return KName;
	}
	
void CCmdPlay::DoRunL()
	{
	if (iMaxVolume)
		{
		// we use DevSound to get the max volume, as CMdaAudioRecorderUtility
		// always returns 0 until we have opened a file.
		CMMFDevSound* devSound = CMMFDevSound::NewL();
		TInt maxVol = devSound->MaxVolume();
		TBool cons = Stdout().AttachedToConsole();
		if (cons) Printf(_L("Maximum volume: "));
		Printf(_L("%d"), maxVol);
		if (cons) Printf(_L("\r\n"));
		delete devSound;
		}
	else
		{
		if (!iArguments.IsPresent(0)) 
			{
			PrintError(KErrArgument, _L("No filename specified"));
			DisplayHelp();
			Complete(KErrArgument);
			return;
			}
		iPlayer->GetReady(iFile, iVerbose);
		if (iOptions.IsPresent(&iPriority) || iOptions.IsPresent(&iPreference))
			{
			iPlayer->SetPriority(iPriority, iPreference);
			}
		if (iOptions.IsPresent(&iVolume))
			{
			iPlayer->SetVolume(iVolume);
			}
		CActiveScheduler::Start();
		User::LeaveIfError(iPlayer->Error());
		}
	}

void CCmdPlay::OptionsL(RCommandOptionList& aOptions)
	{
	_LIT(KOptPriority, "priority");
	aOptions.AppendIntL(iPriority, KOptPriority);

	_LIT(KOptPreference, "preference");
	aOptions.AppendIntL(iPreference, KOptPreference);

	_LIT(KOptVolume, "volume");
	aOptions.AppendIntL(iVolume, KOptVolume);

	_LIT(KOptVerbose, "verbose");
	aOptions.AppendBoolL(iVerbose, KOptVerbose);

	_LIT(KOptMaxVolume, "max-volume");
	aOptions.AppendBoolL(iMaxVolume, KOptMaxVolume);
	}
	
void CCmdPlay::ArgumentsL(RCommandArgumentList& aArguments)
	{
	_LIT(KArgFiles, "file_name");
	aArguments.AppendFileNameL(iFile, KArgFiles);
	}
			
CCmdPlay::CCmdPlay()
	{
	}

//______________________________________________________________________________
//						CMmfPlayer
CMmfPlayer* CMmfPlayer::NewL(RIoConsoleWriteHandle& aStdOut)
	{
	CMmfPlayer* self = new(ELeave)CMmfPlayer(aStdOut);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	
void CMmfPlayer::ConstructL()
	{
	CActiveScheduler::Add(this);
	iUtil = CMdaAudioRecorderUtility::NewL(*this);
	}
	
CMmfPlayer::CMmfPlayer(RIoConsoleWriteHandle& aStdOut)
	: CActive(CActive::EPriorityStandard), iStdOut(aStdOut), iVolume(-1)
	{
	}

CMmfPlayer::~CMmfPlayer()
	{
	delete iUtil;
	}
	
TInt CMmfPlayer::GetMaxVolume()
	{
	return iUtil->MaxVolume();
	}
	
TInt CMmfPlayer::Error()
	{
	return iError;
	}

void CMmfPlayer::GetReady(const TDesC& aFileName, TBool aVerbose)
	{
	iFileName = &aFileName;
	iVerbose = aVerbose;
	iState = EInitial;
	TRequestStatus* stat = &iStatus;
	User::RequestComplete(stat, KErrNone);
	SetActive();
	}
	
void CMmfPlayer::SetPriority(TInt aPriority, TInt aPreference)
	{
	iUtil->SetPriority(aPriority, (TMdaPriorityPreference)aPreference);
	}

void CMmfPlayer::SetVolume(TInt aVolume)
	{
	iVolume = aVolume;
	}

void CMmfPlayer::RunL()
	{
	ProcessL();
	}
	
TInt CMmfPlayer::RunError(TInt aError)
	{
	Error(aError);
	return KErrNone;
	}

void CMmfPlayer::DoCancel()
	{
	}

void CMmfPlayer::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode)
	{
	if (aErrorCode!=KErrNone)
		{
		Error(aErrorCode);
		}
	else
		{
		if (aCurrentState!=EPlaying)
			{
			TRAPD(err, ProcessL());
			if (err!=KErrNone) Error(err);
			}				
		}
	}
	
void CMmfPlayer::ProcessL()
	{
	switch (iState)
		{
	case EInitial:
		iState = EOpening;
		iUtil->OpenFileL(*iFileName);
		Message(_L("Opening clip %S"), &iFileName);
		break;
	case EOpening:
		iState = EPlaying;
		if (iVolume != -1)
			{
			iUtil->SetVolume(iVolume);
			}
		iUtil->PlayL();
		Message(_L("Playing"));
		break;
	case EPlaying:
		Message(_L("Playing complete"));
		Stop();
		break;
		}
	}
	
void CMmfPlayer::Error(TInt aError)
	{
	switch (iState)
		{
	case EInitial:
		Message(_L("Error %d"), aError);
		break;
	case EOpening:
		Message(_L("Error %d when opening clip"), aError);
		break;
	case EPlaying:
		Message(_L("Error %d when playing clip"), aError);
		break;
	default:
		Message(_L("Error %d (in unknown state)"), aError);
		break;
		}
	Stop();
	iError = aError;
	}
	
void CMmfPlayer::Message(TRefByValue<const TDesC> aFmt, ...)
	{
	if (iVerbose)
		{
		TDesC fmt(aFmt);
		RBuf16 newText;
		iMsgBuf.Zero();

		TTruncateOverflow overflow;
		VA_LIST list;
		VA_START(list, aFmt);
		iMsgBuf.AppendFormatList(aFmt, list, &overflow);
		
		iStdOut.Write(iMsgBuf);
		iStdOut.Write(KNewLine);
		}
	}
	
void CMmfPlayer::Stop()
	{
	CActiveScheduler::Stop();
	}

EXE_BOILER_PLATE(CCmdPlay);