// Copyright (c) 2003-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 <cflog.h>

#include <commschan.h>

#include <cfshared.h>

using namespace CommsFW;

#include "bm_defs.h"

/**

@file

@internalComponent

*/

CTask* CTask::NewL(const TCFMessage &aMessage, const TUint aTaskId /*= 0*/)

/** Creates new CTask object

@param aMessage the message to be associated with the task

@param aTaskId the tasks identifier

@return Pointer to the new CTask object.

@leave KErrNoMemory

*/

	{

    CTask* pT = new(ELeave) CTask(aMessage, aTaskId);

    CleanupStack::PushL(pT);

    __CFLOG_2(KLogSubSysRS, KLogCode,_L8("CTask(%X)::NewL %d"), pT, aTaskId);

	CleanupStack::Pop(pT);

    return pT;

	}

CTask::CTask(const TCFMessage &aMessage, const TUint aTaskId) :

	iTaskId(aTaskId),

	iMessage(aMessage)

/** Constructor for CTask

@param aMessage the message to be associated with the task

@param aTaskId the tasks identifier

*/

	{

	}

CTask::~CTask()

/** Destructor for CTask

*/

	{

    __CFLOG_1(KLogSubSysRS, KLogCode,_L8("~CTask %d"), iTaskId);

	Dequeue();

	}

TUint CTask::TaskId() const

/** Accessor method for the task id

@return The task identifier

*/

	{

	return iTaskId;

	}

const TCFMessage& CTask::Message() const

/**

@internalComponent 

Accessor method for the message

@return the message

*/

	{

	return iMessage;

	}

void CTask::Dequeue()

/** Remove this from the linked list

*/

	{

	iLink.Deque();

	}

TBool CTask::CheckIfSame(TCFMessage &aMessage) const

/** Compares the message code and parameter block of the task's message with the 

message passed as a parameter and returns the result

@param aMessage the comparator

@return ETrue if the messages match

*/

	{

	TBool match = ETrue;

	if (iMessage.Code() != aMessage.Code())

		{

		return EFalse;

		}

	switch (iMessage.Code())

		{

	case TCFCommsMessage::ECodeBind:

		{

		const TCFBindMsg& iParam = reinterpret_cast<const TCFBindMsg&>(iMessage);

		const TCFBindMsg& aParam = reinterpret_cast<const TCFBindMsg&>(aMessage);

		if (iParam.SubModule1() != aParam.SubModule1() ||

			iParam.SubModule2() != aParam.SubModule2() ||

			iParam.Type() != aParam.Type())

			{

			match = EFalse;

			}

		}	

		break;

	case TCFCommsMessage::ECodeUnbind:

		{

		const TCFUnbindMsg& iParam = reinterpret_cast<const TCFUnbindMsg&>(iMessage);

		const TCFUnbindMsg& aParam = reinterpret_cast<const TCFUnbindMsg&>(aMessage);

		if (iParam.SubModule1() != aParam.SubModule1() ||

			iParam.SubModule2() != aParam.SubModule2() ||

			iParam.PeerIsDead() != aParam.PeerIsDead())

			{

			match = EFalse;

			}

		}	

		break;

	case TCFCommsMessage::ECodeDiscover:

	case TCFCommsMessage::ECodeShutdown:

		// no params to test

		break;

	default:

		__ASSERT_DEBUG(EFalse, User::Panic(KBindMgrPanic, EUnsupportedCFMessage));

		break;

		}

	return match;

	}

TBool CTask::NeedReply() const

/** Checks if the task's message should expect to receive a reply from the 

server or CPM

@return ETrue if a reply is expected

*/

	{

	// test message type

	TBool reply = EFalse;

	switch (iMessage.Code())

		{

	case TCFCommsMessage::ECodeBind:

	case TCFCommsMessage::ECodeUnbind:

	case TCFCommsMessage::ECodeDiscover:

		reply = ETrue;

		break;

	case TCFCommsMessage::ECodeShutdown:

		// no reply

		break;

	default:

		__ASSERT_DEBUG(EFalse, User::Panic(KBindMgrPanic, EUnsupportedCFMessage));

		break;

		}

	return reply;

	}

TBool CTask::ReplyMatches(const TCFMessage &aMessage) const

/** Determines if the message passed as a parameter is a reply to this task's 

message and returns the result

@param aMessage the reply message to test

@return ETrue if the message is the reply

*/

	{

	// test if message is correct type and has same identifier

	TBool match = EFalse;

	if (NeedReply() && 

		(iMessage.Code() == TCFCommsMessage::ECodeBind && aMessage.Code() == TCFCommsMessage::ECodeBindComplete) ||

		(iMessage.Code() == TCFCommsMessage::ECodeUnbind && aMessage.Code() == TCFCommsMessage::ECodeUnbindComplete) ||

		(iMessage.Code() == TCFCommsMessage::ECodeDiscover && aMessage.Code() == TCFCommsMessage::ECodeDiscoverResp))

		{

		TId ida = *((TId*)aMessage.ParamBlock());

		TId idi = *((TId*)iMessage.ParamBlock());

		if (ida==idi)

			{

			match = ETrue;

			}

		}

	return match;

	}

TBool CTask::GetMsgReturnCode(const TCFMessage &aMessage, TInt &aStatus)

/** Extracts the result code from the message supplied and returns it in the 

status parameter

@param aMessage the reply containing the result code

@param aStatus the status to be filled in with the result code

@return ETrue if the a result code was present

*/

	{

	TBool codePresent = EFalse;

	if (aMessage.Code() == TCFCommsMessage::ECodeBindComplete ||

		aMessage.Code() == TCFCommsMessage::ECodeUnbindComplete ||

		aMessage.Code() == TCFCommsMessage::ECodeDiscoverResp)

		{

		aStatus = ((TInt*)aMessage.ParamBlock())[1];

		codePresent = ETrue;

		}

	else

		{

		aStatus = KErrNone;

		}

	return codePresent;

	}