// Copyright (c) 2004-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 <bt_sock.h>

#include <e32base.h>

#include <e32msgqueue.h>

#include <remconaddress.h>

#include <remconbeareravrcp.h>

#include "avrcplog.h"

#include "avrcputils.h"

/**

@file

@internalComponent

@released

*/

/** Utility AVRCP panic function.

@param aPanic The panic number.

*/

void AvrcpUtils::Panic(TAvrcpPanic aPanic)

	{

	User::Panic(KAvrcpPanicName, aPanic);

	}

/** Set the command data.  This overwrites the current

contents of the data buffer.

@param aCommandData The buffer in which to set the data.

@param aOffset The offset within aCommandData to set the data.

@param aLength The length of data to replace.

@param aValue The new value for the replaced data.

*/

void AvrcpUtils::SetCommandDataFromInt(RBuf8& aCommandData, 

	TInt aOffset, TInt aLength, TInt aValue)

	{

	LOG_STATIC_FUNC

	__ASSERT_DEBUG(aLength <= 4, Panic(EAvrcpCommandDataTooLong));

	for(TInt i = 0; i < aLength; i++)

		{

		aCommandData[aOffset+i] = aValue >> (8*i);

		}

	}

/** Reads command data from the buffer to an int.

@param aCommandData The buffer from which to read the data.

@param aOffset The offset within aCommandData read from.

@param aLength The length of data to read.  This must not be

				more than 4.

@param aValue On return, the value of the specified data section.

*/	

void AvrcpUtils::ReadCommandDataToInt(const RBuf8& aCommandData, 

	TInt aOffset, TInt aLength, TInt& aValue)

	{

	LOG_STATIC_FUNC

	__ASSERT_DEBUG(aLength <= 4, Panic(EAvrcpCommandDataTooLong));

	aValue = 0;

	for(TInt i = 0 ; i < aLength; i++)

		{

		aValue |= aCommandData[aOffset+i]<<(8*i);

		}

	}

/** Convert from a RemCon address to a bluetooth device address.

@param aRemoteAddress The RemCon format address to convert.

@param aBTAddr On return, the bluetooth device address.

@return Whether the conversion could be performed successfully.

*/	

TInt AvrcpUtils::RemConToBTAddr(const TRemConAddress& aRemoteAddress, TBTDevAddr& aBTAddr)

	{

	LOG_STATIC_FUNC

	TInt err = KErrArgument;

	// Check client has provided us a valid address

	if(aRemoteAddress.Addr().Length() == KBTDevAddrSize)

		{

		aBTAddr = TBTDevAddr(aRemoteAddress.Addr());

		err = KErrNone;

		}

	else

		{

		__ASSERT_DEBUG(EFalse, AvrcpUtils::Panic(EAvrcpBadBTAddr));

		}

	return err;

	}

/** Convert from a bluetooth device address to a RemCon address.

We assume this cannot fail, as bluetooth addresses are generated

internally rather than by a client, so they should always be

valid, and so convertible.

@param aBTAddr The bluetooth device address to convert.

@param aRemoteAddress On return, the RemCon format address.

*/	

void AvrcpUtils::BTToRemConAddr(const TBTDevAddr& aBTAddr, TRemConAddress& aRemConAddress)

	{

	LOG_STATIC_FUNC

	aRemConAddress.Addr() = aBTAddr.Des();

	aRemConAddress.BearerUid() = TUid::Uid(KRemConBearerAvrcpImplementationUid);

	}

NONSHARABLE_CLASS(CSpecificThreadCallBackBody)

	: public CActive

	{

public:

	static CSpecificThreadCallBackBody* NewL(const TCallBack& aCallBack, TInt aPriority);

	~CSpecificThreadCallBackBody();

	TInt Start();

	TInt CallBack();

	void HandleCancel();

private:

	CSpecificThreadCallBackBody(const TCallBack& aCallBack, TInt aPriority);

	void ConstructL();

	TInt AsyncMessage(TInt aParam);

private: // from CActive

	void RunL();

	void DoCancel();

private:

	TCallBack		iCallBack;

	RThread			iLocalThread;

	RMsgQueue<TInt>	iInbound;

	RMsgQueue<TInt>	iOutbound;

	};

RSpecificThreadCallBack::RSpecificThreadCallBack()

	: iBody(NULL)

	{

	LOG_FUNC

	}

TInt RSpecificThreadCallBack::Create(const TCallBack& aCallBack, TInt aPriority)

	{

	TRAPD(err, iBody = CSpecificThreadCallBackBody::NewL(aCallBack, aPriority));

	return err;

	}

void RSpecificThreadCallBack::Close()

	{

	LOG_FUNC

	delete iBody;

	iBody = NULL;

	}

TInt RSpecificThreadCallBack::Start()

	{

	return iBody->Start();

	}

TInt RSpecificThreadCallBack::CallBack()

	{

	return iBody->CallBack();

	}

void RSpecificThreadCallBack::Cancel()

	{

	return iBody->HandleCancel();

	}

CSpecificThreadCallBackBody* CSpecificThreadCallBackBody::NewL(const TCallBack& aCallBack, TInt aPriority)

	{

	CSpecificThreadCallBackBody* self = new(ELeave) CSpecificThreadCallBackBody(aCallBack, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CSpecificThreadCallBackBody::CSpecificThreadCallBackBody(const TCallBack& aCallBack, TInt aPriority)

	: CActive(aPriority)

	, iCallBack(aCallBack)

	{

	LOG_FUNC

	}

void CSpecificThreadCallBackBody::ConstructL()

	{

	User::LeaveIfError(iInbound.CreateLocal(1));

	User::LeaveIfError(iOutbound.CreateLocal(1));

	}

CSpecificThreadCallBackBody::~CSpecificThreadCallBackBody()

	{

	LOG_FUNC

	HandleCancel();

	iInbound.Close();

	iOutbound.Close();

	iLocalThread.Close();

	}

TInt CSpecificThreadCallBackBody::Start()

	{

	TInt err = KErrNone;

	if(!IsAdded())

		{

		err = iLocalThread.Duplicate(RThread());

		if(err == KErrNone)

			{

			CActiveScheduler::Add(this);

			iInbound.NotifyDataAvailable(iStatus);

			SetActive();

			}

		}

	return err;

	}

TInt CSpecificThreadCallBackBody::CallBack()

	{

	TInt err = KErrUnknown;

	if(iLocalThread.Id() == RThread().Id())

		{

		// Simple synchronous case.

		err = iCallBack.CallBack();

		}

	else

		{

		RThread thisThread;

		err = thisThread.Duplicate(RThread());

		if(err == KErrNone)

			{

			err = AsyncMessage(thisThread.Handle());

			}

		}

	return err;

	}

TInt CSpecificThreadCallBackBody::AsyncMessage(TInt aParam)

	{

	TInt err = KErrNone;

	TRequestStatus logonStatus;

	iLocalThread.Logon(logonStatus);

	if(logonStatus == KErrNoMemory)

		{

		// This seems kludgy, but I think it is the most reliable way.

		User::WaitForRequest(logonStatus); // Ensure the all requests are correct...

		err = KErrNoMemory;

		}

	else

		{

		iInbound.SendBlocking(aParam);

		TRequestStatus status;

		iOutbound.NotifyDataAvailable(status);

		User::WaitForRequest(status, logonStatus);

		if(status == KRequestPending)

			{

			// Remote thread is dead

			iOutbound.CancelDataAvailable();

			User::WaitForRequest(status);

			err = KErrDied;

			}

		else

			{

			// Success (the thread may have subsequently died, but we are only concerned with this call).

			iLocalThread.LogonCancel(logonStatus);

			User::WaitForRequest(logonStatus);

			err = status.Int();

			if(err == KErrNone)

				{

				iOutbound.ReceiveBlocking(err);

				}

			}

		}

	return err;

	}

void CSpecificThreadCallBackBody::RunL()

	{

	TInt threadHandle;

	iInbound.ReceiveBlocking(threadHandle);

	if(threadHandle == 0)

		{

		// 0 is a cancel message

		// therefore don't do anything

		iOutbound.SendBlocking(KErrNone);

		}

	else

		{

		RThread remoteThread;

		remoteThread.SetHandleNC(threadHandle);

		TInt result = iCallBack.CallBack();

		// There doesn't seem to be a safe way of handling when the other thread

		// dies......

		iOutbound.SendBlocking(result);

		remoteThread.Close();

		iInbound.NotifyDataAvailable(iStatus);

		SetActive();

		}

	}

void CSpecificThreadCallBackBody::DoCancel()

	{

	if(RThread().Id() == iLocalThread.Id())

		{

		iInbound.CancelDataAvailable();

		}

	else

		{

		// other thread cancelling - so just complete the

		// request

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrCancel);

		}

	}

void CSpecificThreadCallBackBody::HandleCancel()

	{

	if(IsAdded())

		{

		if(RThread().Id() == iLocalThread.Id())

			{

			Cancel(); // synchronous cancel is fine in same thread...

			}

		else

			{

			// In a different thread - this is more interesting...

			TInt err = AsyncMessage(0); // 0 is special as it means cancel.

			if(err == KErrDied && IsActive())

				{

				// Remote thread has already died so we need to tidy up the

				// active object ourselves.

				Cancel();

				}

			}

		}

	// else shouldn't be active...

	}