diff -r 000000000000 -r 40261b775718 devsound/sounddevbt/PlatSec/src/SoundDevice/MmfBtDevSoundCallbackHandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/devsound/sounddevbt/PlatSec/src/SoundDevice/MmfBtDevSoundCallbackHandler.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,466 @@
+// 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;
+	}
+