/*
* Copyright (c) 2008-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:
*
*/


/**
@file
@internalComponent
*/

#include <e32debug.h>
#include "asbreakeventhandler.h"

const TDesC* StateDes(OMX_STATETYPE);

RASBreakEventHandler::RASBreakEventHandler(MASBreakCallback& aHandler):
iHandler(aHandler),
iCounter(0),
iMode(EIdle)
	{
	iOmxCallbackType.EventHandler = EventHandler;
	
	// do nothing function is set for these callbacks, rather than using NULL
	iOmxCallbackType.EmptyBufferDone = EmptyBufferDone;
	iOmxCallbackType.FillBufferDone = FillBufferDone;
	}

TInt RASBreakEventHandler::Create()
	{
	return iMutex.CreateLocal();
	}

void RASBreakEventHandler::Close()
	{
	for(TInt aIndex = 0, aCount = iComponents.Count(); aIndex < aCount; aIndex++)
		{
		delete iComponents[aIndex].iName;
		}
	iComponents.Close();
	iCounter = 0;
	iMode = EIdle;
	iMutex.Close();
	}

void RASBreakEventHandler::AddComponentL(OMX_COMPONENTTYPE* aComponent, const TDesC& aName)
	{
	ASSERT(iMode == EIdle);
	TComponentInfo componentInfo;
	componentInfo.iHandle = aComponent;
	componentInfo.iName = HBufC::NewLC(aName.Length());
	*(componentInfo.iName) = aName;
	componentInfo.iComplete = EFalse;
	User::LeaveIfError(iComponents.Append(componentInfo));
	CleanupStack::Pop(componentInfo.iName);
	}

OMX_ERRORTYPE RASBreakEventHandler::FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                                   OMX_IN OMX_PTR pAppData,
                                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
	{
	return reinterpret_cast<RASBreakEventHandler*>(pAppData)->DoBufferDone(reinterpret_cast<OMX_COMPONENTTYPE*>(hComponent), pBuffer, ETrue);
	}

OMX_ERRORTYPE RASBreakEventHandler::EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                                    OMX_IN OMX_PTR pAppData,
                                                    OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
	{
	return reinterpret_cast<RASBreakEventHandler*>(pAppData)->DoBufferDone(reinterpret_cast<OMX_COMPONENTTYPE*>(hComponent), pBuffer, EFalse);
	}

OMX_ERRORTYPE RASBreakEventHandler::DoBufferDone(OMX_COMPONENTTYPE* aComponent, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource)
	{
	iHandler.BufferDone(aComponent, aBufHdr, aSource);
	return OMX_ErrorNone;
	}

OMX_ERRORTYPE RASBreakEventHandler::EventHandler(OMX_HANDLETYPE hComponent,
		OMX_PTR pAppData,
		OMX_EVENTTYPE eEvent,
		OMX_U32 nData1,
		OMX_U32 nData2,
		OMX_PTR pEventData)
	{
	return reinterpret_cast<RASBreakEventHandler*>(pAppData)->DoEventHandler(reinterpret_cast<OMX_COMPONENTTYPE*>(hComponent), eEvent, nData1, nData2, pEventData);
	}

OMX_ERRORTYPE RASBreakEventHandler::DoEventHandler(OMX_COMPONENTTYPE* aComponent, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2, TAny* aEventData)
	{
	iMutex.Wait();
	if((iMode == EAwaitingTransition || iMode == EAwaitingSingleTransition) && aEvent == OMX_EventCmdComplete && aData1 == OMX_CommandStateSet)
		{
		StateSet(aComponent, (OMX_STATETYPE) aData2);
		}
	else if(iMode == EAwaitingEOS && aEvent == OMX_EventBufferFlag && aData2 & OMX_BUFFERFLAG_EOS)
		{
		EndOfStream(aComponent);
		}
	else
		{
		iHandler.EventReceived(aComponent, aEvent, aData1, aData2, aEventData);
		}
	iMutex.Signal();
	return OMX_ErrorNone;
	}

void RASBreakEventHandler::StateSet(OMX_COMPONENTTYPE* aComponent, OMX_STATETYPE aState)
	{
	RDebug::Print(_L("State transition: component %S is in state %S\n"), ComponentName(aComponent), StateDes(aState));
	if(iMode == EAwaitingTransition)
		{
		__ASSERT_ALWAYS(aState == iNewState, User::Panic(_L("RASBreakEventHandler"), 2));
		if(--iCounter == 0)
			{
			iMode = EIdle;
			iHandler.AllComponentsTransitioned(iNewState, iOldState);
			}
		}
	else if (iMode == EAwaitingSingleTransition)
		{
		__ASSERT_ALWAYS(aState == iNewState, User::Panic(_L("RASBreakEventHandler"), 2));
		iMode = EIdle;
		iHandler.ComponentTransitioned(iNewState, iOldState);		
		}
	}

void RASBreakEventHandler::EndOfStream(OMX_COMPONENTTYPE* aComponent)
	{
	RDebug::Print(_L("End of stream from component %S\n"), ComponentName(aComponent));
	if(iMode == EAwaitingEOS)
		{
		TInt index = iComponents.Find(aComponent, TComponentInfo::CompareHandle);
		// panic if component was not found
		__ASSERT_ALWAYS(index >= 0, User::Invariant());
	
		// only respond to EOS changing state, to allow potential duplicates
		if(!iComponents[index].iComplete)
			{
			iComponents[index].iComplete = ETrue;
			iCounter--;
			// if iEOSComponent is NULL, wait for all components, otherwise wait for individual component
			if(iEOSComponent == NULL && iCounter == 0 || iEOSComponent == aComponent)
				{
				iMode = EIdle;
				iHandler.AllComponentsEOS();
				}
			}
		}
	}

void RASBreakEventHandler::AwaitTransition(OMX_STATETYPE aNewState, OMX_STATETYPE aOldState)
	{
	RDebug::Print(_L("Awaiting all components to transition from %S to %S\n"), StateDes(aOldState), StateDes(aNewState));
	ASSERT(iMode == EIdle);
	iMode = EAwaitingTransition;
	iNewState = aNewState;
	iOldState = aOldState;
	iCounter = iComponents.Count();
	}

void RASBreakEventHandler::AwaitSingleTransition(OMX_COMPONENTTYPE* aComponent, OMX_STATETYPE aNewState, OMX_STATETYPE aOldState)
	{
	RDebug::Print(_L("Awaiting %S components to transition from %S to %S\n"), ComponentName(aComponent), StateDes(aOldState), StateDes(aNewState));	
	ASSERT(iMode == EIdle);
	iMode = EAwaitingSingleTransition;
	iNewState = aNewState;
	iOldState = aOldState;
	}

void RASBreakEventHandler::AwaitEOS()
	{
	RDebug::Print(_L("Awaiting End Of Stream flag from all components\n"));
	ASSERT(iMode == EIdle);
	iMode = EAwaitingEOS;
	iEOSComponent = NULL;	// wait for all components, not an individual component
	for(iCounter = 0; iCounter < iComponents.Count(); iCounter++)
		{
		iComponents[iCounter].iComplete = EFalse;
		}
	}

void RASBreakEventHandler::AwaitEOS(OMX_COMPONENTTYPE* aComponent)
	{
	RDebug::Print(_L("Awaiting End Of Stream flag from component %S\n"), ComponentName(aComponent));
	ASSERT(iMode == EIdle);
	iMode = EAwaitingEOS;
	iEOSComponent = aComponent;
	for(iCounter = 0; iCounter < iComponents.Count(); iCounter++)
		{
		iComponents[iCounter].iComplete = EFalse;
		}
	}

const TDesC* RASBreakEventHandler::ComponentName(OMX_COMPONENTTYPE* aComponent)
	{
	TInt index = iComponents.Find(aComponent, TComponentInfo::CompareHandle);
	if(index == KErrNotFound)
		{
		return NULL;
		}
	return iComponents[index].iName;
	}

OMX_CALLBACKTYPE& RASBreakEventHandler::CallbackStruct()
	{
	return iOmxCallbackType;
	}