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

#include "avrcprouter.h"

#include "avrcputils.h"

#include "controlcommand.h"

#include "passthroughhelper.h"

#include "controlbearer.h"

CPassthroughHelper* CPassthroughHelper::NewL(CRcpRouter& aRouter, CRemConBearerAvrcp& aBearer, CDeltaTimer& aTimer)

	{

	CPassthroughHelper* helper = new(ELeave)CPassthroughHelper(aRouter, aBearer, aTimer);

	CleanupStack::PushL(helper);

	helper->ConstructL();

	CleanupStack::Pop(helper);

	return helper;

	}

CPassthroughHelper::~CPassthroughHelper()

	{

	}

CPassthroughHelper::CPassthroughHelper(CRcpRouter& aRouter, CRemConBearerAvrcp& aBearer, CDeltaTimer& aTimer)

	: iRouter(aRouter)

	, iBearer(aBearer)

	, iTimer(aTimer)

	{

	}

void CPassthroughHelper::ConstructL()

	{

	}

void CPassthroughHelper::Disconnect()

	{

	LOG_FUNC

	// We handle the last command as a special case to ensure the presses and

	// releases are balanced from a clients' point of view.

	if(iPreviousPassthrough)

		{

		iRouter.RemoveFromSendQueue(*iPreviousPassthrough);

		BalanceHandledCommand(*iPreviousPassthrough);

		}

	}

/** Sends a response to the remote device.

Because of the 100ms timeout for responses we send a response to

passthrough commands as soon as we receive them.  This means the real

response from RemCon is currently ignored.  A real response is

only sent if this is a vendor dependent command.

@param aCommand The command to respond to.

@param aErr The result of handling the command.  KErrNone if successful.

			KErrNotSupported if this operation is not supported.

*/		

void CPassthroughHelper::Respond(CControlCommand& aCommand, TInt aErr)

	{

	LOG_FUNC

	aCommand.SetResponseType(aErr);

	iRouter.AddToSendQueue(aCommand);

	}

/** To be called on completion of command handling.

This aggregates the handler's tidying up of a finished

command.

@param aCommand The command to tidy up.

*/	

void CPassthroughHelper::HandledCommand(CControlCommand& aCommand)

	{

	LOG_FUNC

	// If this was the previous passthrough reset it to NULL

	if(iPreviousPassthrough == &aCommand)

		{

		iPreviousPassthrough = NULL;

		}

	aCommand.CancelTimer(iTimer);

	aCommand.DecrementUsers();

	}

/** Handles incoming passthrough command.

How the command is handled is dependent on this and the previous command.

Previous command	This command 	Behaviour

Press_op1			Press_op1		discard

Press_op1			Release_op1		press_op1 hold timer not expired - generate click_op1

									press_op1 release timer not expired - generate release_op1

Press_op1			Press_op2		generate release_op1, start hold timer for press_op2

Press_op1			Release_op2		press_op1 hold timer not expired - generate click_op1, discard release_op2

									press_op1 release timer not expired - generate release_op1, discard release_op2

Release_op1			Press_op1		start hold timer for press_op1

Release_op1			Release_op1		discard

Release_op1			Press_op2		start hold timer for press_op2	

Release_op1			Release_op2		discard

@param aCommand The command to handle.

@leave System wide error code.

*/

void CPassthroughHelper::HandlePassthrough(CControlCommand& aCommand)

	{

	LOG_FUNC

	// We can't map Vendor Unique passthrough command to clicks as we do

	// not know how the button action is conveyed to the API.  All we can

	// do is try and ensure that we try to generate a release if one is 

	// missing by asking the convert.  We also need to consider them as

	// part of the passthrough history for how other passthrough commands

	// should be interpreted.

	TUint8 thisOpId;

	aCommand.Frame().OperationId(thisOpId);

	if(!aCommand.IsAvrcpPassthrough())

		{

		aCommand.SetClick(EFalse);

		}

	// Behaviour depends on previous command

	TUint8 prevOpId;

	if(iPreviousPassthrough)

		{

		__ASSERT_ALWAYS(iPreviousPassthrough->ButtonAct() == AVCPanel::EButtonPress,

	 		AvrcpUtils::Panic(EAvrcpPressNotPreviousPassthroughCommand));

		iPreviousPassthrough->Frame().OperationId(prevOpId);

		}

	if(aCommand.ButtonAct() == AVCPanel::EButtonPress)

		{

		// Respond now so we can decrement users of aCommand at will

		Respond(aCommand, KErrNone);		

		if(iPreviousPassthrough)

			{

			// previous is press, current is press

			if(prevOpId == thisOpId)

				{

				// prevCommand is for same opId as this one.  Drop this

				// command and reset release timer for prevCommand.

				aCommand.DecrementUsers();

				iPreviousPassthrough->CancelTimer(iTimer);

				// If still flagged as a click then the user won't have been notified

				// of the press yet - so do it now.

				if(iPreviousPassthrough->Click())

					{

					iPreviousPassthrough->SetClick(EFalse);

					iPreviousPassthrough->SetCoreButtonAction(ERemConCoreApiButtonPress, ETrue);

					iBearer.MrcciNewCommand(*iPreviousPassthrough, iPreviousPassthrough->ClientId());

					}

				StartReleaseTimer(*iPreviousPassthrough);

				}

			else if(iPreviousPassthrough->Click())

				{

				// prevCommand is click, Hold timer not expired.  Generate click

				// to RemCon then start waiting for click.

				iPreviousPassthrough->CancelTimer(iTimer);

				iPreviousPassthrough->SetCoreButtonAction(ERemConCoreApiButtonClick, ETrue);

				iBearer.MrcciNewCommand(*iPreviousPassthrough, iPreviousPassthrough->ClientId());

				HandledCommand(*iPreviousPassthrough);

				// Start waiting for click (core api) or release (vendor unique)

				NewPress(aCommand);

				}

			else

				{

				// prevCommand is not click, Release timer not expired.  Generate

				// release to RemCon then start waiting for click.

				BalanceHandledCommand(*iPreviousPassthrough);

				// Start waiting for click (core api) or release (vendor unique)

				NewPress(aCommand);

				}

			}

		else

			{

			// No previous command, current is press

			// Start waiting for click (core api) or release (vendor unique)

			NewPress(aCommand);

			}	

		}

	else if(iPreviousPassthrough)

		{

		// previous is press, current is release

		if(prevOpId == thisOpId)

			{

			Respond(aCommand, KErrNone);

			if(iPreviousPassthrough->Click())

				{

				// Button release for same opId with hold timeout

				aCommand.DecrementUsers(); // Drop this command.

				// Cancel hold timer and send the previous command as a click.

				iPreviousPassthrough->CancelTimer(iTimer); 

				iPreviousPassthrough->SetCoreButtonAction(ERemConCoreApiButtonClick, ETrue);

				iBearer.MrcciNewCommand(*iPreviousPassthrough, iPreviousPassthrough->ClientId());

				HandledCommand(*iPreviousPassthrough);

				}

			else

				{

				// Button release for same opId, hold timeout expired

				iPreviousPassthrough->CancelTimer(iTimer);

				HandledCommand(*iPreviousPassthrough);

				if(aCommand.IsAvrcpPassthrough())

					{

					aCommand.SetCoreButtonAction(ERemConCoreApiButtonRelease, ETrue);

					}

				iBearer.MrcciNewCommand(aCommand, aCommand.ClientId());

				aCommand.DecrementUsers();

				}

			}

		else

			{

			// Drop this release and continue waiting for release to

			// prevCommand.

			Respond(aCommand, KErrNone);

			aCommand.DecrementUsers();

			}

		}

	else

		{

		// No prevCommand, this is a release

		// To get here either:

		// - this is a spurious release

		// - we've given up waiting for this

		// Because responses must be made within 100ms we respond before waiting

		// to see what RemCon thinks.

		Respond(aCommand, KErrNone);

		aCommand.DecrementUsers();

		}

	}

void CPassthroughHelper::NewPress(CControlCommand& aCommand)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iPreviousPassthrough, AVRCP_PANIC(EPreviousPassthroughNonNullReplacing));

	iPreviousPassthrough = &aCommand;

	if(aCommand.IsAvrcpPassthrough())

		{

		StartHoldTimer(aCommand);

		}

	else

		{

		iBearer.MrcciNewCommand(aCommand, aCommand.ClientId());

		StartReleaseTimer(aCommand);

		}

	}

/** To be called on completion of command handling for an unbalanced press.

This is a special version of the HandledCommand which which assumes the

command has been notified to the user and so balances the notification

of a press with a generated release command.

@param aCommand The command to tidy up.

*/

void CPassthroughHelper::BalanceHandledCommand(CControlCommand& aCommand)

	{

	LOG_FUNC

	// CancelTimer also frees the timer entries, so needs to be called

	// here even though there's no pending entry.

	aCommand.CancelTimer(iTimer);

	// If this was the previous passthrough reset it to NULL

	if(iPreviousPassthrough == &aCommand)

		{

		iPreviousPassthrough = NULL;

		}

	// Here we handle the case that a press has been informed but a release has yet

	// to be reported, and if it hasn't we provide the notification.

	if(aCommand.ButtonAct() == AVCPanel::EButtonPress && !aCommand.Click())

		{

		if(aCommand.IsAvrcpPassthrough())

			{

			// FIXME I think we might need a new transaction id here?

			TRAPD(err, aCommand.ReSetCoreButtonActionL(ERemConCoreApiButtonRelease, ETrue));

			if (err == KErrNone)

				{

				iBearer.MrcciNewCommand(aCommand, aCommand.ClientId());

				}

				else

				{

				// just silently drop this command, do not send command to remconserv

				}

			}

		else

			{

			// Need see if we can get a valid release from the converter.  Pass

			// it the same AVC Frame as the press, but with the button action 

			// flipped to release.  If we can't do this then there's not a

			// lot we can do.  

			// FIXME

			}

		}

	aCommand.iHandlingLink.Deque();

	aCommand.DecrementUsers();

	}

//------------------------------------------------------------------------------------

// Timer functions

//------------------------------------------------------------------------------------

/** Starts the hold timer (only applicable to press commands).

This is the timer to determine whether a command will be passed to RemCon

as a click.  If the timer expires before a matching release is received

the press and release will be sent separately.  Otherwise,  a click is 

sent.

@param aCommand The command to start the timer for.

*/	

void CPassthroughHelper::StartHoldTimer(CControlCommand& aCommand)

	{

	LOG_FUNC

	// These cannot fail as we use placement new	

	TAvrcpTimerExpiryInfo* timerInfo = new(aCommand.TimerExpiryInfo())TAvrcpTimerExpiryInfo(this, aCommand);

	TCallBack callback(HoldExpiry, timerInfo);

	TDeltaTimerEntry* timerEntry = new(aCommand.TimerEntry())TDeltaTimerEntry(callback);

	iTimer.Queue(KRcpHoldThreshold, *timerEntry);

	}

/** Callback when hold timer expires.

This is a static forwarding function.

@param aExpiryInfo The information used by the real HoldExpiry to

					deal with the timer expiry.

*/	

TInt CPassthroughHelper::HoldExpiry(TAny* aExpiryInfo)

	{

	LOG_STATIC_FUNC

	TAvrcpTimerExpiryInfo *timerInfo = reinterpret_cast<TAvrcpTimerExpiryInfo*>(aExpiryInfo);

	(reinterpret_cast<CPassthroughHelper*>(timerInfo->iHandler))->HoldExpiry(timerInfo->iCommand);

	return KErrNone;

	}

/** Deals with expiry of hold timer.

1) This is not a click.  Set click to false for this command.

2) Inform RemCon of available press command

3) Start release timer.

@param aCommand	The CControlCommand that has expired.

*/

void CPassthroughHelper::HoldExpiry(CControlCommand& aCommand)

	{

	LOG_FUNC

	__ASSERT_DEBUG((aCommand.ButtonAct() == AVCPanel::EButtonPress), AvrcpUtils::Panic(EAvrcpHoldExpiryForRelease));

	// We haven't received a release soon enough to treat this as

	// a click.  Send the press on to RemCon and wait for a release.

	// CancelTimer also frees the timer entries, so needs to be called

	// here even though there's no pending entry.

	aCommand.CancelTimer(iTimer);

	aCommand.SetClick(EFalse);

	aCommand.SetCoreButtonAction(ERemConCoreApiButtonPress, ETrue);

	iBearer.MrcciNewCommand(aCommand, aCommand.ClientId());

	StartReleaseTimer(aCommand);

	}

/** Starts the release timer (only applicable to press commands).

If a release is not received quickly enough to treat this press as

a click, the release timer is started.  2s after receiving a button

press we should assume the release if we haven't received one.

@param aCommand The command to start the timer for.

*/		

void CPassthroughHelper::StartReleaseTimer(CControlCommand& aCommand)

	{

	TAvrcpTimerExpiryInfo* timerInfo = new(aCommand.TimerExpiryInfo())TAvrcpTimerExpiryInfo(this, aCommand);

	TCallBack callback(ReleaseExpiry, timerInfo);

	TDeltaTimerEntry* timerEntry = new(aCommand.TimerEntry())TDeltaTimerEntry(callback);

	iTimer.Queue(KRcpIncomingButtonReleaseTimeout, *timerEntry);

	}

/** Callback when release timer expires.

This is a static forwarding function.

@param aExpiryInfo The information used by the real ReleaseExpiry to

					deal with the timer expiry.

*/	

TInt CPassthroughHelper::ReleaseExpiry(TAny* aExpiryInfo)

	{

	LOG_STATIC_FUNC

	TAvrcpTimerExpiryInfo *timerInfo = reinterpret_cast<TAvrcpTimerExpiryInfo*>(aExpiryInfo);

	(reinterpret_cast<CPassthroughHelper*>(timerInfo->iHandler))->ReleaseExpiry(timerInfo->iCommand);

	return KErrNone;

	}

/** Deals with expiry of release timer.

1) Generate release for this command.

2) Inform RemCon of available release command.

@param aCommand	The CControlCommand that has expired.

*/

void CPassthroughHelper::ReleaseExpiry(CControlCommand& aCommand)

	{

	LOG_FUNC

	__ASSERT_DEBUG((aCommand.ButtonAct() == AVCPanel::EButtonPress), AvrcpUtils::Panic(EAvrcpReleaseExpiryForRelease));

	__ASSERT_DEBUG(!aCommand.Click(), AvrcpUtils::Panic(EAvrcpReleaseExpiryForClick));

	// We haven't received a release within the allotted time.  Assume

	// one and generate it to RemCon.

	BalanceHandledCommand(aCommand);

	}