// 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:
//

/**
 @file
 @internalComponent
*/

#include "utils.h"
#include <e32msgqueue.h>
#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_REMCON_UTILS);
#endif

#ifdef _DEBUG
PANICCATEGORY("RCFUtils");
#endif

/**
Function passed in as a parameter to TCleanupItem constructor to reset and 
destroy the received aPtr.
@param aPtr A pointer to the object that is to be cleaned up
*/
void ResetAndDestroy(TAny* aPtr)
	{
	ASSERT_DEBUG(aPtr);
	reinterpret_cast<RImplInfoPtrArray*>(aPtr)->ResetAndDestroy();
	}

/**
Function that creates a cleanup item for aArray and specifies the cleanup 
function as ResetAndDestroy. When the item is removed from the cleanup stack 
the function ResetAndDestroy will be called on aArray.
@param aArray The array to be destroyed.
*/
void CleanupResetAndDestroyPushL(RImplInfoPtrArray& aArray)
	{		
	TCleanupItem item(ResetAndDestroy, &aArray);
	CleanupStack::PushL(item);
	}

void SwitchHeap(TAny* aPtr)
	{
	ASSERT_DEBUG(aPtr);
	User::SwitchHeap(reinterpret_cast<RHeap*>(aPtr));
	}

void CleanupSwitchHeapPushL(RHeap& aHeap)
	{
	TCleanupItem item(SwitchHeap, &aHeap);
	CleanupStack::PushL(item);
	}


RNestableLock::RNestableLock()
	: iThreadId(KInvalidThreadId)
	, iRefCount(0)
	{
	LOG_FUNC
	}

TInt RNestableLock::CreateLocal()
	{
	TInt err = iLock.CreateLocal();
	if(err == KErrNone)
		{
		err = iMetaLock.CreateLocal();
		}
	if(err != KErrNone)
		{
		Close();
		}
	return err;
	}

void RNestableLock::Close()
	{
	LOG_FUNC
	iLock.Close();
	iMetaLock.Close();
	iRefCount = 0;
	iThreadId = TThreadId(KInvalidThreadId);
	}

void RNestableLock::Wait()
	{
	iMetaLock.Wait();
	TThreadId currentThreadId = RThread().Id();
	if(iThreadId == TThreadId(KInvalidThreadId) || currentThreadId != iThreadId)
		{
		iMetaLock.Signal();
		iLock.Wait();
		iMetaLock.Wait();
		iThreadId = currentThreadId;
		}
	++iRefCount;
	iMetaLock.Signal();
	}

void RNestableLock::Signal()
	{
	iMetaLock.Wait();
	// Assert if current thread is stored current thread?
	if(--iRefCount == 0)
		{
		iLock.Signal();
		iThreadId = TThreadId(KInvalidThreadId);
		}
	iMetaLock.Signal();
	}




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()
	{
	ASSERT_DEBUG(iBody);
	return iBody->Start();
	}

TInt RSpecificThreadCallBack::CallBack()
	{
	ASSERT_DEBUG(iBody);
	return iBody->CallBack();
	}

void RSpecificThreadCallBack::Cancel()
	{
	ASSERT_DEBUG(iBody);
	return iBody->HandleCancel();
	}








CSpecificThreadCallBackBody* CSpecificThreadCallBackBody::NewL(const TCallBack& aCallBack, TInt aPriority)
	{
	LOG_STATIC_FUNC
	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...
	}


#ifdef _DEBUG
_LIT(KCountSizeWriteStreamPanic, "CountStream");
#endif // _DEBUG
#define ASSERT_NOT_CALLED __ASSERT_DEBUG(EFalse, User::Panic(KCountSizeWriteStreamPanic, 0));

RCountSizeWriteStream::RCountSizeWriteStream()
	: RWriteStream()
	, iSize(0)
	{
	Attach(this);
	}

TInt RCountSizeWriteStream::Size() const
	{
	return iSize;
	}

void RCountSizeWriteStream::Reset()
	{
	iSize = 0;
	}

void RCountSizeWriteStream::DoRelease()
	{
	// No resources to free - Nothing to do
	}

void RCountSizeWriteStream::DoSynchL()
	{
	// No buffering - Nothing to do
	}

TInt RCountSizeWriteStream::DoReadL(TAny* /*aPtr*/,TInt /*aMaxLength*/)
	{
	LOG_FUNC
	ASSERT_NOT_CALLED;
	User::Leave(KErrNotSupported);
	return 0;
	}

TInt RCountSizeWriteStream::DoReadL(TDes8& /*aDes*/,TInt /*aMaxLength*/,TRequestStatus& /*aStatus*/)
	{
	LOG_FUNC
	ASSERT_NOT_CALLED;
	User::Leave(KErrNotSupported);
	return 0;
	}

TStreamTransfer RCountSizeWriteStream::DoReadL(MStreamInput& /*anInput*/,TStreamTransfer /*aTransfer*/)
	{
	LOG_FUNC
	ASSERT_NOT_CALLED;
	User::Leave(KErrNotSupported);
	return 0;
	}

void RCountSizeWriteStream::DoWriteL(const TAny* /*aPtr*/,TInt aLength)
	{
	iSize += aLength;
	}

TInt RCountSizeWriteStream::DoWriteL(const TDesC8& /*aDes*/,TInt aMaxLength,TRequestStatus& aStatus)
	{
	iSize += aMaxLength;
	TRequestStatus* stat = &aStatus;
	User::RequestComplete(stat, KErrNone);
	return aMaxLength;
	}

TStreamTransfer RCountSizeWriteStream::DoWriteL(MStreamOutput& /*anOutput*/,TStreamTransfer /*aTransfer*/)
	{
	ASSERT_NOT_CALLED;
	User::Leave(KErrNotSupported);
	return 0;
	}

TStreamPos RCountSizeWriteStream::DoSeekL(TMark /*aMark*/,TStreamLocation /*aLocation*/,TInt /*anOffset*/)
	{
	ASSERT_NOT_CALLED;
	User::Leave(KErrNotSupported);
	return 0;
	}

#undef ASSERT_NOT_CALLED