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

//

//BufferToBeFilled//

//

CMMFBufferToBeFilledHandler* CMMFBufferToBeFilledHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFBufferToBeFilledHandler* self = new(ELeave) CMMFBufferToBeFilledHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFBufferToBeFilledHandler::CMMFBufferToBeFilledHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFBufferToBeFilledHandler::ConstructL()

	{

	}

CMMFBufferToBeFilledHandler::~CMMFBufferToBeFilledHandler()

	{

	Cancel();

	}

void CMMFBufferToBeFilledHandler::ReceiveEvents()

	{

	_LIT(KBTBFPanic, "CMMFBufferToBeFilledHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KBTBFPanic, 1));

	iDevSoundProxy->ReceiveBufferToBeFilledEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFBufferToBeFilledHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFBufferToBeFilledHandler::RunL()

	{

	TMMFDevSoundProxyHwBuf aSet;

	aSet.iBufferType = iSetPckg().iBufferType;

	aSet.iRequestSize = iSetPckg().iRequestSize;

	aSet.iBufferSize = iSetPckg().iBufferSize;

	aSet.iLastBuffer = iSetPckg().iLastBuffer;

	CMMFDataBuffer* buffer = CMMFDescriptorBuffer::NewL(aSet.iBufferSize);

	CleanupStack::PushL(buffer);

	buffer->SetRequestSizeL(aSet.iRequestSize);

	CleanupStack::Pop(buffer);

	buffer->SetLastBuffer(aSet.iLastBuffer);

	iDevSoundProxy->SetBuffer(buffer);//DevSoundProxy takes the owenership of "buffer"

	ReceiveEvents();

	iDevSoundObserver.BufferToBeFilled(buffer);

	}

void CMMFBufferToBeFilledHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveBufferToBeFilledEvent();

	}

TInt CMMFBufferToBeFilledHandler::RunError(TInt aError)

	{

	// report error to client - client should make decesion what to do with the error.

	iDevSoundObserver.PlayError(aError);

	ReceiveEvents();

	return KErrNone;

	}

//

//BufferToBeEmptied//

//

CMMFBufferToBeEmptiedHandler* CMMFBufferToBeEmptiedHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFBufferToBeEmptiedHandler* self = new(ELeave) CMMFBufferToBeEmptiedHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFBufferToBeEmptiedHandler::CMMFBufferToBeEmptiedHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFBufferToBeEmptiedHandler::ConstructL()

	{

	}

CMMFBufferToBeEmptiedHandler::~CMMFBufferToBeEmptiedHandler()

	{

	Cancel();

	delete iBuffer;

	}

void CMMFBufferToBeEmptiedHandler::ReceiveEvents()

	{

	_LIT(KBTBEPanic, "CMMFBufferToBeEmptiedHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KBTBEPanic, 1));

	iDevSoundProxy->ReceiveBufferToBeEmptiedEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFBufferToBeEmptiedHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFBufferToBeEmptiedHandler::RunL()

	{

	TMMFDevSoundProxyHwBuf aSet;

	aSet.iBufferType = iSetPckg().iBufferType;

	aSet.iRequestSize = iSetPckg().iRequestSize;

	aSet.iBufferSize = iSetPckg().iBufferSize;

	aSet.iLastBuffer = iSetPckg().iLastBuffer;

	if(iBuffer)

		{

		delete iBuffer;

		iBuffer = NULL;

		}

	iBuffer = CMMFDescriptorBuffer::NewL(aSet.iBufferSize);

	iBuffer->SetRequestSizeL(aSet.iRequestSize);

	iBuffer->SetLastBuffer(aSet.iLastBuffer);

	User::LeaveIfError(iDevSoundProxy->GetRecordedBufferL(*iBuffer));  

	iDevSoundObserver.BufferToBeEmptied(iBuffer);

	ReceiveEvents();

	}

void CMMFBufferToBeEmptiedHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveBufferToBeEmptiedEvent();

	}

TInt CMMFBufferToBeEmptiedHandler::RunError(TInt aError)

	{

	// report error to client - client should make decesion what to do with the error.

	iDevSoundObserver.RecordError(aError);

	ReceiveEvents();

	return KErrNone;

	}

//

//PlayError//

//

CMMFPlayErrorHandler* CMMFPlayErrorHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFPlayErrorHandler* self = new(ELeave) CMMFPlayErrorHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFPlayErrorHandler::CMMFPlayErrorHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityStandard+1), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFPlayErrorHandler::ConstructL()

	{

	}

CMMFPlayErrorHandler::~CMMFPlayErrorHandler()

	{

	Cancel();

	}

void CMMFPlayErrorHandler::ReceiveEvents()

	{

	_LIT(KPEPanic, "CMMFPlayErrorHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KPEPanic, 1));

	iDevSoundProxy->ReceivePlayErrorEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFPlayErrorHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFPlayErrorHandler::RunL()

	{

	iDevSoundObserver.PlayError(iStatus.Int());

	iStatus = KErrNone;

	ReceiveEvents();

	}

void CMMFPlayErrorHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceivePlayErrorEvent();

	}

TInt CMMFPlayErrorHandler::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

//

//RecordError//

//

CMMFRecordErrorHandler* CMMFRecordErrorHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFRecordErrorHandler* self = new(ELeave) CMMFRecordErrorHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFRecordErrorHandler::CMMFRecordErrorHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFRecordErrorHandler::ConstructL()

	{

	}

CMMFRecordErrorHandler::~CMMFRecordErrorHandler()

	{

	Cancel();

	}

void CMMFRecordErrorHandler::ReceiveEvents()

	{

	_LIT(KREPanic, "CMMFRecordErrorHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KREPanic, 1));

	iDevSoundProxy->ReceiveRecordErrorEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFRecordErrorHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFRecordErrorHandler::RunL()

	{

	iDevSoundObserver.RecordError(iStatus.Int());

	iStatus = KErrNone;

	ReceiveEvents();

	}

void CMMFRecordErrorHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveRecordErrorEvent();

	}

TInt CMMFRecordErrorHandler::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

//

//ToneFinished//

//

CMMFToneFinishedHandler* CMMFToneFinishedHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFToneFinishedHandler* self = new(ELeave) CMMFToneFinishedHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFToneFinishedHandler::CMMFToneFinishedHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFToneFinishedHandler::ConstructL()

	{

	}

CMMFToneFinishedHandler::~CMMFToneFinishedHandler()

	{

	Cancel();

	}

void CMMFToneFinishedHandler::ReceiveEvents()

	{

	_LIT(KTFPanic, "CMMFToneFinishedHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KTFPanic, 1));

	iDevSoundProxy->ReceiveToneFinishedEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFToneFinishedHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFToneFinishedHandler::RunL()

	{

	iDevSoundObserver.ToneFinished(iStatus.Int());

	ReceiveEvents();

	}

void CMMFToneFinishedHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveToneFinishedEvent();

	}

TInt CMMFToneFinishedHandler::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

//

//InitializeComplete//

//

CMMFInitializeCompleteHandler* CMMFInitializeCompleteHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFInitializeCompleteHandler* self = new(ELeave) CMMFInitializeCompleteHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFInitializeCompleteHandler::CMMFInitializeCompleteHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFInitializeCompleteHandler::ConstructL()

	{

	}

CMMFInitializeCompleteHandler::~CMMFInitializeCompleteHandler()

	{

	Cancel();

	}

void CMMFInitializeCompleteHandler::ReceiveEvents()

	{

	_LIT(KICPanic, "CMMFInitializeCompleteHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KICPanic, 1));

	iDevSoundProxy->ReceiveInitializeCompleteEvent(iSetPckg, iStatus);

	SetActive();

	}

void CMMFInitializeCompleteHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFInitializeCompleteHandler::RunL()

	{

	iDevSoundObserver.InitializeComplete(iStatus.Int());

	iStatus = KErrNone;

	ReceiveEvents();

	}

void CMMFInitializeCompleteHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveInitializeCompleteEvent();

	}

TInt CMMFInitializeCompleteHandler::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}

//

//SendEventToClient//

//

CMMFSendEventToClientHandler* CMMFSendEventToClientHandler::NewL(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver)

	{

	CMMFSendEventToClientHandler* self = new(ELeave) CMMFSendEventToClientHandler(aDevSoundProxy, aDevSoundObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CMMFSendEventToClientHandler::CMMFSendEventToClientHandler(RMMFDevSoundProxy* aDevSoundProxy, MDevSoundObserver& aDevSoundObserver) :

	CActive(EPriorityLow), iDevSoundProxy(aDevSoundProxy), iDevSoundObserver(aDevSoundObserver)

	{

	CActiveScheduler::Add(this);

	}

void CMMFSendEventToClientHandler::ConstructL()

	{

	}

CMMFSendEventToClientHandler::~CMMFSendEventToClientHandler()

	{

	Cancel();

	}

void CMMFSendEventToClientHandler::ReceiveEvents()

	{

	_LIT(KSETCPanic, "CMMFSendEventToClientHandler");

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KSETCPanic, 1));

	iDevSoundProxy->ReceiveSendEventToClientEvent(iEventPckg, iStatus);

	SetActive();

	}

void CMMFSendEventToClientHandler::CancelReceiveEvents()

	{

	Cancel();

	}

void CMMFSendEventToClientHandler::RunL()

	{

	iDevSoundObserver.SendEventToClient(iEventPckg());

	iStatus = KErrNone;

	ReceiveEvents();

	}

void CMMFSendEventToClientHandler::DoCancel()

	{

	iDevSoundProxy->CancelReceiveSendEventToClientEvent();

	}

TInt CMMFSendEventToClientHandler::RunError(TInt /*aError*/)

	{

	return KErrNone;

	}