// Copyright (c) 2003-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 "midiclientutilitybody.h"

const TInt KMimeLength         = 256;

const TInt KMinChannel         = 0;

const TInt KMaxChannel         = 15;

const TInt KMinNote            = 0;

const TInt KMaxNote            = 127;

const TInt KMinNoteOnVelocity  = 0;

const TInt KMaxNoteOnVelocity  = 127;

const TInt KMinNoteOffVelocity = 0;

const TInt KMaxNoteOffVelocity = 127;

const TInt KMinInstrumentId    = 0;

const TInt KMaxInstrumentId    = 127;

CMidiClientUtility::CBody* CMidiClientUtility::CBody::NewL(CMidiClientUtility* aParent,

														   MMidiClientUtilityObserver& aObserver, 

														   TInt aPriority, 

														   TInt aPref,

														   TBool aUseSharedHeap)

	{

	CBody* self = new(ELeave) CBody(aParent, aObserver, aPriority, aPref);

	CleanupStack::PushL(self);

	self->ConstructL(aUseSharedHeap);

	CleanupStack::Pop(self);

	return self;

	}

CMidiClientUtility::CBody::CBody(CMidiClientUtility* aParent, 

								 MMidiClientUtilityObserver& aObserver, 

								 TInt aPriority, 

								 TInt aPref) :

	iObserver(aObserver),

	iMidiControllerCommands(iController),

	iDRMCustomCommands(iController)

	{

	iParent = aParent;

	iState = EMidiStateClosedDisengaged;

	iPrioritySettings.iPriority = aPriority;

	iPrioritySettings.iPref = aPref;

	iIntervalSec = ETrue;

	iStopPosition = TTimeIntervalMicroSeconds(0);

	}

CMidiClientUtility::CBody::~CBody()

	{

	delete iAddDataSourceSinkAsync;

	if (iMidiControllerEventMonitor)

		iMidiControllerEventMonitor->Cancel();

	iController.Close();

	delete iMidiControllerEventMonitor;

	delete iMimeType;

	delete iRepeatTrailingSilenceTimer;

	delete iSource;

	}

void CMidiClientUtility::CBody::ConstructL(TBool aUseSharedHeap)

	{

	iMidiControllerEventMonitor = CMidiControllerEventMonitor::NewL(*this, iMidiControllerCommands, *iParent);

	iMimeType = HBufC8::NewL(KMimeLength);

	RMMFControllerImplInfoArray controllers;

	CleanupResetAndDestroyPushL(controllers);

	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

	// Select the media IDs to allow

	RArray<TUid> mediaIds;

	CleanupClosePushL(mediaIds);

	User::LeaveIfError(mediaIds.Append(KUidMediaTypeMidi));

	cSelect->SetMediaIdsL(mediaIds,CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

	CleanupStack::PopAndDestroy();//mediaIds

	cSelect->ListImplementationsL(controllers);

	// Open and configure a controller

	User::LeaveIfError(DoOpen(controllers, KUidMmfAudioOutput, KNullDesC8, aUseSharedHeap));

	CleanupStack::PopAndDestroy(2);//controllers, cSelect

	iRepeatTrailingSilenceTimer = CRepeatTrailingSilenceTimer::NewL(*this);

	iAddDataSourceSinkAsync = CMMFAddDataSourceSinkAsync::NewL(*this);

	}

void CMidiClientUtility::CBody::MadssaoAddDataSourceSinkAsyncComplete(TInt aError, const TMMFMessageDestination& aHandle)

	{

	if (aError == KErrNone)

		{

		iSourceHandle = aHandle;

		}

	else

		{

 		iMidiControllerEventMonitor->SelfComplete(aError);

		}

	}

void CMidiClientUtility::CBody::OpenFile(const TDesC& aFileName)

	{

	TMMFFileConfig sourceCfg;

	sourceCfg().iPath = aFileName;

	// Add the data source to the controller. MmcuoStateChanged will be call on completition.

	iAddDataSourceSinkAsync->AddDataSource(iController, KUidMmfFileSource, sourceCfg);

	}

void CMidiClientUtility::CBody::OpenFile(RFile& aFile)

	{

		// Add the data source to the controller. MmcuoStateChanged will be call on completition.

	iAddDataSourceSinkAsync->AddFileHandleDataSource(iController, aFile);

	}

void CMidiClientUtility::CBody::OpenFile(const TMMSource& aSource)

	{

	TRAPD(err, DoOpenFileL(aSource));

	if (err != KErrNone)

		{

 		iMidiControllerEventMonitor->SelfComplete(err);

		}

	}

void CMidiClientUtility::CBody::DoOpenFileL(const TMMSource& aSource)

	{

	delete iSource;

	iSource = NULL;

	iSource = CMMFileSourceSink::NewL(KUidMmfFileSource, aSource);

	static_cast<CMMFileSourceSink*>(iSource)->EvaluateIntentL( aSource.Intent() );

	iAddDataSourceSinkAsync->AddDataSource(iController, 

								iSource->SourceSinkUid(),

								iSource->SourceSinkData());

	}

void CMidiClientUtility::CBody::OpenDes(const TDesC8& aDescriptor)

	{

	TMMFDescriptorConfig sourceCfg;

	sourceCfg().iDes = (TAny*)&aDescriptor;

	sourceCfg().iDesThreadId = RThread().Id();

	// Add the data source to the controller. MmcuoStateChanged will be call on completition.

	iAddDataSourceSinkAsync->AddDataSource(iController, KUidMmfDescriptorSource, sourceCfg);

	}

void CMidiClientUtility::CBody::OpenUrl(const TDesC& aUrl,TInt aIapId,const TDesC8& /*aMimeType*/)

	{

	TRAPD(err, DoOpenUrlL(aUrl, aIapId));

	if (err != KErrNone)

		{

 		iMidiControllerEventMonitor->SelfComplete(err);

		}

	}

void CMidiClientUtility::CBody::DoOpenUrlL(const TDesC& aUrl,TInt aIapId)

	{

	CMMFUrlParams* sourceCfg = CMMFUrlParams::NewLC(aUrl, aIapId);

	CBufFlat* sourceCfgBuffer = sourceCfg->ExternalizeToCBufFlatLC();

	// Add the data source to the controller. MmcuoStateChanged will be call on completition.

	iAddDataSourceSinkAsync->AddDataSource(iController, KUidMmfUrlSource, sourceCfgBuffer->Ptr(0));

	CleanupStack::PopAndDestroy(2, sourceCfg);//sourceCfgBuffer, sourceCfg

	}

void CMidiClientUtility::CBody::Close()

	{

	iMidiControllerCommands.Close();

	}

void CMidiClientUtility::CBody::Play()

	{

	TInt err = iController.Prime();

	if (err==KErrNone)

		{

		err=iController.Play();

		}

	if (err!=KErrNone)

		{

		iMidiControllerEventMonitor->SelfComplete(err);

		}

	}

void CMidiClientUtility::CBody::Stop(const TTimeIntervalMicroSeconds& aFadeOutDuration)

	{

	iMidiControllerCommands.Stop(aFadeOutDuration);

	}

/**

 *

 * Returns the current state of the MIDI client utility

 * with regard to MIDI resources.

 *

 * @return "TMidiState" The current state of the utility

 *

 * @since	7.0s

 */

TMidiState CMidiClientUtility::CBody::State() const

	{

	return iState;

	}

void CMidiClientUtility::CBody::PlayNoteL(TInt aChannel,TInt aNote,const TTimeIntervalMicroSeconds& aDuration,TInt aNoteOnVelocity,TInt aNoteOffVelocity)

	{

	if((aChannel >= KMinChannel && aChannel <= KMaxChannel) 

	&& (aNote >= KMinNote && aNote <= KMaxNote) 

	&& (aNoteOnVelocity >= KMinNoteOnVelocity && aNoteOnVelocity <= KMaxNoteOnVelocity) 

	&& (aNoteOffVelocity >= KMinNoteOffVelocity && aNoteOffVelocity <= KMaxNoteOffVelocity))

		{	

		User::LeaveIfError(iMidiControllerCommands.PlayNote(aChannel, aNote, aDuration, aNoteOnVelocity, aNoteOffVelocity));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

void CMidiClientUtility::CBody::PlayNoteL(TInt aChannel,TInt aNote, const TTimeIntervalMicroSeconds& aStartTime, const TTimeIntervalMicroSeconds& aDuration, TInt aNoteOnVelocity, TInt aNoteOffVelocity)

	{

	if((aChannel >= KMinChannel && aChannel <= KMaxChannel) 

	&& (aNote >= KMinNote && aNote <= KMaxNote) 

	&& (aNoteOnVelocity >= KMinNoteOnVelocity && aNoteOnVelocity <= KMaxNoteOnVelocity) 

	&& (aNoteOffVelocity >= KMinNoteOffVelocity && aNoteOffVelocity <= KMaxNoteOffVelocity))

		{

		User::LeaveIfError(iMidiControllerCommands.PlayNote(aChannel, aNote, aStartTime, aDuration, aNoteOnVelocity, aNoteOffVelocity));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

void CMidiClientUtility::CBody::StopNotes(TInt aChannel)

	{

	if(aChannel >= KMinChannel && aChannel <= KMaxChannel) 

		{

		iMidiControllerCommands.StopNotes(aChannel);

		}

	}

void CMidiClientUtility::CBody::NoteOnL(TInt aChannel,TInt aNote,TInt aVelocity)

	{

	if((aChannel >= KMinChannel && aChannel <= KMaxChannel) 

	&& (aNote >= KMinNote && aNote <= KMaxNote) 

	&& (aVelocity >= KMinNoteOnVelocity && aVelocity <= KMaxNoteOnVelocity))

		{

		User::LeaveIfError(iMidiControllerCommands.NoteOn(aChannel, aNote, aVelocity));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

void CMidiClientUtility::CBody::NoteOffL(TInt aChannel,TInt aNote,TInt aVelocity)

	{

	if((aChannel >= KMinChannel && aChannel <= KMaxChannel) 

	&& (aNote >= KMinNote && aNote <= KMaxNote) 

	&& (aVelocity >= KMinNoteOffVelocity && aVelocity <= KMaxNoteOffVelocity))

		{

		User::LeaveIfError(iMidiControllerCommands.NoteOff(aChannel, aNote, aVelocity));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

TInt CMidiClientUtility::CBody::PlaybackRateL() const

	{

	TInt rate;

	User::LeaveIfError(iMidiControllerCommands.PlaybackRate(rate));

	return rate;

	}

void CMidiClientUtility::CBody::SetPlaybackRateL(TInt aRate)

	{

	User::LeaveIfError(iMidiControllerCommands.SetPlaybackRate(aRate));

	}

TInt CMidiClientUtility::CBody::MaxPlaybackRateL() const

	{

	TInt maxRate;

	User::LeaveIfError(iMidiControllerCommands.MaxPlaybackRate(maxRate));

	return maxRate;

	}

TInt CMidiClientUtility::CBody::MinPlaybackRateL() const

	{

	TInt minRate;

	User::LeaveIfError(iMidiControllerCommands.MinPlaybackRate(minRate));

	return minRate;

	}

TInt CMidiClientUtility::CBody::TempoMicroBeatsPerMinuteL() const

	{

	TInt microBeatsPerMinute;

	User::LeaveIfError(iMidiControllerCommands.TempoMicroBeatsPerMinute(microBeatsPerMinute));

	return microBeatsPerMinute;

	}

void CMidiClientUtility::CBody::SetTempoL(TInt aMicroBeatsPerMinute)

	{

	if(aMicroBeatsPerMinute > 0)

		{

		User::LeaveIfError(iMidiControllerCommands.SetTempo(aMicroBeatsPerMinute));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

TInt CMidiClientUtility::CBody::PitchTranspositionCentsL() const

	{

	TInt cents;

	User::LeaveIfError(iMidiControllerCommands.PitchTranspositionCents(cents));

	return cents;

	}

TInt CMidiClientUtility::CBody::SetPitchTranspositionL(TInt aCents)

	{

	TInt pitchApplied = 0;

	//we do not check aCents value - it is expected the controller will report KErrArgument

	//if the pitch level is not supported.

	User::LeaveIfError(iMidiControllerCommands.SetPitchTransposition(aCents, pitchApplied));

	return pitchApplied;

	}

TTimeIntervalMicroSeconds CMidiClientUtility::CBody::DurationMicroSecondsL() const

	{

	TTimeIntervalMicroSeconds duration;

	User::LeaveIfError(iController.GetDuration(duration));

	return duration;

	}

TInt64 CMidiClientUtility::CBody::DurationMicroBeatsL() const

	{

	TInt64 duration;

	User::LeaveIfError(iMidiControllerCommands.DurationMicroBeats(duration));

	return duration;

	}

TInt CMidiClientUtility::CBody::NumTracksL() const

	{

	TInt tracks;

	User::LeaveIfError(iMidiControllerCommands.NumTracks(tracks));

	return tracks;

	}

void CMidiClientUtility::CBody::SetTrackMuteL(TInt aTrack, TBool aMuted) const

	{

	TInt numTracks = NumTracksL();

	if((aTrack >= 0) && (aTrack < numTracks))

		{

		User::LeaveIfError(iMidiControllerCommands.SetTrackMute(aTrack, aMuted));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

const TDesC8& CMidiClientUtility::CBody::MimeTypeL()

	{

	TPtr8 des = iMimeType->Des();

	User::LeaveIfError(iMidiControllerCommands.MimeType(des));

	return *iMimeType;

	}

TTimeIntervalMicroSeconds CMidiClientUtility::CBody::PositionMicroSecondsL() const

	{

	TTimeIntervalMicroSeconds position;

	User::LeaveIfError(iController.GetPosition(position));

	return position;

	}

void CMidiClientUtility::CBody::SetPositionMicroSecondsL(const TTimeIntervalMicroSeconds& aPosition)

	{

	TTimeIntervalMicroSeconds maxPosition = DurationMicroSecondsL();

	TTimeIntervalMicroSeconds minPosition(0);

	TTimeIntervalMicroSeconds position = aPosition;

	if (aPosition > maxPosition)

		{

		position = maxPosition;

		}

	if (aPosition < minPosition)

		{

		position = minPosition;

		}

	User::LeaveIfError(iController.SetPosition(position));

	}

TInt64 CMidiClientUtility::CBody::PositionMicroBeatsL() const

	{

	TInt64 position;

	User::LeaveIfError(iMidiControllerCommands.PositionMicroBeats(position));

	return position;

	}

void CMidiClientUtility::CBody::SetPositionMicroBeatsL(TInt64 aMicroBeats)

	{

	TInt64 maxPosition = DurationMicroBeatsL();

	TInt64 minPosition(0);

	TInt64 position = aMicroBeats;

	if (aMicroBeats > maxPosition)

		{

		position = maxPosition;

		}

	if (aMicroBeats < minPosition)

		{

		position = minPosition;

		}

	User::LeaveIfError(iMidiControllerCommands.SetPositionMicroBeats(position));

	}

void CMidiClientUtility::CBody::SetSyncUpdateCallbackIntervalL(const TTimeIntervalMicroSeconds& aMicroSeconds, TInt64 aMicroBeats)

	{

	if((aMicroSeconds > TTimeIntervalMicroSeconds(0)) || (aMicroSeconds == TTimeIntervalMicroSeconds(0) && aMicroBeats == 0))

		{

		iIntervalSec = ETrue;

		}

	else 

		{

		if (aMicroBeats > 0)

			{

			iIntervalSec = EFalse;

			}

		else

			{

			User::Leave(KErrArgument);

			}

		}

	User::LeaveIfError(iMidiControllerCommands.SetSyncUpdateCallbackInterval(aMicroSeconds, aMicroBeats));

	}

TInt CMidiClientUtility::CBody::SendMessageL(const TDesC8& aMidiMessage)

	{

	TInt numByteProc;

	User::LeaveIfError(iMidiControllerCommands.SendMessage(aMidiMessage, numByteProc));

	return numByteProc;

	}

TInt CMidiClientUtility::CBody::SendMessageL(const TDesC8& aMidiMessage,const TTimeIntervalMicroSeconds& aTime)

	{

	TInt numByteProc;

	User::LeaveIfError(iMidiControllerCommands.SendMessage(aMidiMessage, aTime, numByteProc));

	return numByteProc;

	}

void CMidiClientUtility::CBody::SendMipMessageL(const RArray<TMipMessageEntry>& aEntry)

	{

	User::LeaveIfError(iMidiControllerCommands.SendMipMessage(aEntry));

	}

TInt CMidiClientUtility::CBody::NumberOfBanksL(TBool aCustom) const

	{

	TInt numBanks;

	User::LeaveIfError(iMidiControllerCommands.NumberOfBanks(aCustom, numBanks));

	return numBanks;

	}

TInt CMidiClientUtility::CBody::GetBankIdL(TBool aCustom,TInt aBankIndex) const

	{

	TInt numBanks = NumberOfBanksL(aCustom);

	TInt bankId = 0;

	if(aBankIndex >= 0 && aBankIndex < numBanks)

		{

		User::LeaveIfError(iMidiControllerCommands.GetBankId(aCustom, aBankIndex, bankId));

		}

	else

		{

		User::Leave(KErrArgument);

		}

	return bankId;

	}

void CMidiClientUtility::CBody::LoadCustomBankL(const TDesC& aFileName,TInt& aBankCollectionIndex)

	{

	User::LeaveIfError(iMidiControllerCommands.LoadCustomBank(aFileName, aBankCollectionIndex));

	}

void CMidiClientUtility::CBody::UnloadCustomBankL(TInt aBankCollectionIndex)

	{

	User::LeaveIfError(iMidiControllerCommands.UnloadCustomBank(aBankCollectionIndex));

	}

TBool CMidiClientUtility::CBody::CustomBankLoadedL(TInt aBankCollectionIndex) const

	{

	TBool bankLoaded;

	User::LeaveIfError(iMidiControllerCommands.CustomBankLoaded(aBankCollectionIndex, bankLoaded));

	return bankLoaded;

	}

void CMidiClientUtility::CBody::UnloadAllCustomBanksL()

	{

	User::LeaveIfError(iMidiControllerCommands.UnloadAllCustomBanks());

	}

TInt CMidiClientUtility::CBody::NumberOfInstrumentsL(TInt aBankId,TBool aCustom) const

	{

	TInt numInstruments;

	User::LeaveIfError(iMidiControllerCommands.NumberOfInstruments(aBankId, aCustom, numInstruments));

	return numInstruments;

	}

TInt CMidiClientUtility::CBody::GetInstrumentIdL(TInt aBankId,TBool aCustom,TInt aInstrumentIndex) const

	{

	TInt numInstruments = NumberOfInstrumentsL(aBankId, aCustom);

	TInt instrumentId = 0;

	if(aInstrumentIndex >=0 && aInstrumentIndex < numInstruments)

		{

		User::LeaveIfError(iMidiControllerCommands.GetInstrumentId(aBankId, aCustom, aInstrumentIndex, instrumentId));

		}

	else