1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "MmfBtDevSoundCallbackHandler.h"

    17 

    18 //

    19 //BufferToBeFilled//

    20 //

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

    22 	{

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

    24 	CleanupStack::PushL(self);

    25 	self->ConstructL();

    26 	CleanupStack::Pop();

    27 	return self;

    28 	}

    29 

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

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

    32 	{

    33 	CActiveScheduler::Add(this);

    34 	}

    35 

    36 void CMMFBufferToBeFilledHandler::ConstructL()

    37 	{

    38 	}

    39 

    40 CMMFBufferToBeFilledHandler::~CMMFBufferToBeFilledHandler()

    41 	{

    42 	Cancel();

    43 	}

    44 

    45 void CMMFBufferToBeFilledHandler::ReceiveEvents()

    46 	{

    47 	_LIT(KBTBFPanic, "CMMFBufferToBeFilledHandler");

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

    49 

    50 	iDevSoundProxy->ReceiveBufferToBeFilledEvent(iSetPckg, iStatus);

    51 	SetActive();

    52 	}

    53 

    54 void CMMFBufferToBeFilledHandler::CancelReceiveEvents()

    55 	{

    56 	Cancel();

    57 	}

    58 

    59 void CMMFBufferToBeFilledHandler::RunL()

    60 	{

    61 	TMMFDevSoundProxyHwBuf aSet;

    62 	aSet.iBufferType = iSetPckg().iBufferType;

    63 	aSet.iRequestSize = iSetPckg().iRequestSize;

    64 	aSet.iBufferSize = iSetPckg().iBufferSize;

    65 	aSet.iLastBuffer = iSetPckg().iLastBuffer;

    66 

    67 

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

    69 	CleanupStack::PushL(buffer);

    70 	buffer->SetRequestSizeL(aSet.iRequestSize);

    71 	CleanupStack::Pop(buffer);

    72 	buffer->SetLastBuffer(aSet.iLastBuffer);

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

    74 

    75 	ReceiveEvents();

    76 	iDevSoundObserver.BufferToBeFilled(buffer);

    77 	}

    78 

    79 void CMMFBufferToBeFilledHandler::DoCancel()

    80 	{

    81 	iDevSoundProxy->CancelReceiveBufferToBeFilledEvent();

    82 	}

    83 

    84 TInt CMMFBufferToBeFilledHandler::RunError(TInt aError)

    85 	{

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

    87 	iDevSoundObserver.PlayError(aError);

    88 	ReceiveEvents();

    89 	

    90 	return KErrNone;

    91 	}

    92 

    93 

    94 //

    95 //BufferToBeEmptied//

    96 //

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

    98 	{

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

   100 	CleanupStack::PushL(self);

   101 	self->ConstructL();

   102 	CleanupStack::Pop();

   103 	return self;

   104 	}

   105 

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

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

   108 	{

   109 	CActiveScheduler::Add(this);

   110 	}

   111 

   112 void CMMFBufferToBeEmptiedHandler::ConstructL()

   113 	{

   114 	}

   115 

   116 CMMFBufferToBeEmptiedHandler::~CMMFBufferToBeEmptiedHandler()

   117 	{

   118 	Cancel();

   119 	delete iBuffer;

   120 	}

   121 

   122 void CMMFBufferToBeEmptiedHandler::ReceiveEvents()

   123 	{

   124 	_LIT(KBTBEPanic, "CMMFBufferToBeEmptiedHandler");

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

   126 

   127 	iDevSoundProxy->ReceiveBufferToBeEmptiedEvent(iSetPckg, iStatus);

   128 	SetActive();

   129 	}

   130 

   131 void CMMFBufferToBeEmptiedHandler::CancelReceiveEvents()

   132 	{

   133 	Cancel();

   134 	}

   135 

   136 void CMMFBufferToBeEmptiedHandler::RunL()

   137 	{

   138 	TMMFDevSoundProxyHwBuf aSet;

   139 	aSet.iBufferType = iSetPckg().iBufferType;

   140 	aSet.iRequestSize = iSetPckg().iRequestSize;

   141 	aSet.iBufferSize = iSetPckg().iBufferSize;

   142 	aSet.iLastBuffer = iSetPckg().iLastBuffer;

   143 

   144 	if(iBuffer)

   145 		{

   146 		delete iBuffer;

   147 		iBuffer = NULL;

   148 		}

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

   150 	iBuffer->SetRequestSizeL(aSet.iRequestSize);

   151 	iBuffer->SetLastBuffer(aSet.iLastBuffer);

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

   153 

   154 	iDevSoundObserver.BufferToBeEmptied(iBuffer);

   155 	ReceiveEvents();

   156 	}

   157 

   158 void CMMFBufferToBeEmptiedHandler::DoCancel()

   159 	{

   160 	iDevSoundProxy->CancelReceiveBufferToBeEmptiedEvent();

   161 	}

   162 

   163 TInt CMMFBufferToBeEmptiedHandler::RunError(TInt aError)

   164 	{

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

   166 	iDevSoundObserver.RecordError(aError);

   167 	ReceiveEvents();

   168 

   169 	return KErrNone;

   170 	}

   171 

   172 //

   173 //PlayError//

   174 //

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

   176 	{

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

   178 	CleanupStack::PushL(self);

   179 	self->ConstructL();

   180 	CleanupStack::Pop();

   181 	return self;

   182 	}

   183 

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

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

   186 	{

   187 	CActiveScheduler::Add(this);

   188 	}

   189 

   190 void CMMFPlayErrorHandler::ConstructL()

   191 	{

   192 	}

   193 

   194 CMMFPlayErrorHandler::~CMMFPlayErrorHandler()

   195 	{

   196 	Cancel();

   197 	}

   198 

   199 void CMMFPlayErrorHandler::ReceiveEvents()

   200 	{

   201 	_LIT(KPEPanic, "CMMFPlayErrorHandler");

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

   203 

   204 	iDevSoundProxy->ReceivePlayErrorEvent(iSetPckg, iStatus);

   205 	SetActive();

   206 	}

   207 

   208 void CMMFPlayErrorHandler::CancelReceiveEvents()

   209 	{

   210 	Cancel();

   211 	}

   212 

   213 void CMMFPlayErrorHandler::RunL()

   214 	{

   215 	iDevSoundObserver.PlayError(iStatus.Int());

   216 	iStatus = KErrNone;

   217 	ReceiveEvents();

   218 	}

   219 

   220 void CMMFPlayErrorHandler::DoCancel()

   221 	{

   222 	iDevSoundProxy->CancelReceivePlayErrorEvent();

   223 	}

   224 

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

   226 	{

   227 	return KErrNone;

   228 	}

   229 

   230 //

   231 //RecordError//

   232 //

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

   234 	{

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

   236 	CleanupStack::PushL(self);

   237 	self->ConstructL();

   238 	CleanupStack::Pop();

   239 	return self;

   240 	}

   241 

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

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

   244 	{

   245 	CActiveScheduler::Add(this);

   246 	}

   247 

   248 void CMMFRecordErrorHandler::ConstructL()

   249 	{

   250 	}

   251 

   252 CMMFRecordErrorHandler::~CMMFRecordErrorHandler()

   253 	{

   254 	Cancel();

   255 	}

   256 

   257 void CMMFRecordErrorHandler::ReceiveEvents()

   258 	{

   259 	_LIT(KREPanic, "CMMFRecordErrorHandler");

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

   261 

   262 	iDevSoundProxy->ReceiveRecordErrorEvent(iSetPckg, iStatus);

   263 	SetActive();

   264 	}

   265 

   266 void CMMFRecordErrorHandler::CancelReceiveEvents()

   267 	{

   268 	Cancel();

   269 	}

   270 

   271 void CMMFRecordErrorHandler::RunL()

   272 	{

   273 	iDevSoundObserver.RecordError(iStatus.Int());

   274 	iStatus = KErrNone;

   275 	ReceiveEvents();

   276 	}

   277 

   278 void CMMFRecordErrorHandler::DoCancel()

   279 	{

   280 	iDevSoundProxy->CancelReceiveRecordErrorEvent();

   281 	}

   282 

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

   284 	{

   285 	return KErrNone;

   286 	}

   287 

   288 //

   289 //ToneFinished//

   290 //

   291 

   292 

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

   294 	{

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

   296 	CleanupStack::PushL(self);

   297 	self->ConstructL();

   298 	CleanupStack::Pop();

   299 	return self;

   300 	}

   301 

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

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

   304 	{

   305 	CActiveScheduler::Add(this);

   306 	}

   307 

   308 void CMMFToneFinishedHandler::ConstructL()

   309 	{

   310 	}

   311 

   312 CMMFToneFinishedHandler::~CMMFToneFinishedHandler()

   313 	{

   314 	Cancel();

   315 	}

   316 

   317 void CMMFToneFinishedHandler::ReceiveEvents()

   318 	{

   319 	_LIT(KTFPanic, "CMMFToneFinishedHandler");

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

   321 

   322 	iDevSoundProxy->ReceiveToneFinishedEvent(iSetPckg, iStatus);

   323 	SetActive();

   324 	}

   325 

   326 void CMMFToneFinishedHandler::CancelReceiveEvents()

   327 	{

   328 	Cancel();

   329 	}

   330 

   331 void CMMFToneFinishedHandler::RunL()

   332 	{

   333 	iDevSoundObserver.ToneFinished(iStatus.Int());

   334 	ReceiveEvents();

   335 	}

   336 

   337 void CMMFToneFinishedHandler::DoCancel()

   338 	{

   339 	iDevSoundProxy->CancelReceiveToneFinishedEvent();

   340 	}

   341 

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

   343 	{

   344 	return KErrNone;

   345 	}

   346 

   347 //

   348 //InitializeComplete//

   349 //

   350 

   351 

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

   353 	{

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

   355 	CleanupStack::PushL(self);

   356 	self->ConstructL();

   357 	CleanupStack::Pop();

   358 	return self;

   359 	}

   360 

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

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

   363 	{

   364 	CActiveScheduler::Add(this);

   365 	}

   366 

   367 void CMMFInitializeCompleteHandler::ConstructL()

   368 	{

   369 	}

   370 

   371 CMMFInitializeCompleteHandler::~CMMFInitializeCompleteHandler()

   372 	{

   373 	Cancel();

   374 	}

   375 

   376 void CMMFInitializeCompleteHandler::ReceiveEvents()

   377 	{

   378 	_LIT(KICPanic, "CMMFInitializeCompleteHandler");

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

   380 

   381 	iDevSoundProxy->ReceiveInitializeCompleteEvent(iSetPckg, iStatus);

   382 	SetActive();

   383 	}

   384 

   385 void CMMFInitializeCompleteHandler::CancelReceiveEvents()

   386 	{

   387 	Cancel();

   388 	}

   389 

   390 void CMMFInitializeCompleteHandler::RunL()

   391 	{

   392 	iDevSoundObserver.InitializeComplete(iStatus.Int());

   393 	iStatus = KErrNone;

   394 	ReceiveEvents();

   395 	}

   396 

   397 void CMMFInitializeCompleteHandler::DoCancel()

   398 	{

   399 	iDevSoundProxy->CancelReceiveInitializeCompleteEvent();

   400 	}

   401 

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

   403 	{

   404 	return KErrNone;

   405 	}

   406 

   407 //

   408 //SendEventToClient//

   409 //

   410 

   411 

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

   413 	{

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

   415 	CleanupStack::PushL(self);

   416 	self->ConstructL();

   417 	CleanupStack::Pop();

   418 	return self;

   419 	}

   420 

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

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

   423 	{

   424 	CActiveScheduler::Add(this);

   425 	}

   426 

   427 void CMMFSendEventToClientHandler::ConstructL()

   428 	{

   429 	}

   430 

   431 CMMFSendEventToClientHandler::~CMMFSendEventToClientHandler()

   432 	{

   433 	Cancel();

   434 	}

   435 

   436 void CMMFSendEventToClientHandler::ReceiveEvents()

   437 	{

   438 	_LIT(KSETCPanic, "CMMFSendEventToClientHandler");

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

   440 

   441 	iDevSoundProxy->ReceiveSendEventToClientEvent(iEventPckg, iStatus);

   442 	SetActive();

   443 	}

   444 

   445 void CMMFSendEventToClientHandler::CancelReceiveEvents()

   446 	{

   447 	Cancel();

   448 	}

   449 

   450 void CMMFSendEventToClientHandler::RunL()

   451 	{

   452 	iDevSoundObserver.SendEventToClient(iEventPckg());

   453 	iStatus = KErrNone;

   454 	ReceiveEvents();

   455 	}

   456 

   457 void CMMFSendEventToClientHandler::DoCancel()

   458 	{

   459 	iDevSoundProxy->CancelReceiveSendEventToClientEvent();

   460 	}

   461 

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

   463 	{

   464 	return KErrNone;

   465 	}

   466