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

// Remote Control session implementation.

// 

//

/**

 @file

 @internalComponent

*/

#include "e32base.h"

#include <bluetooth/logger.h>

#include <remcon/remconbearerinterface.h>

#include <remcon/remconifdetails.h>

#include <s32mem.h>

#include "utils.h"

#include "server.h"

#include "bearermanager.h"

#include "remconmessage.h"

#include "connections.h"

#include "session.h"

#include "messagequeue.h"

#include "remconserver.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);

#endif

#ifdef _DEBUG

PANICCATEGORY("session");

#endif

CRemConSession::CRemConSession(CRemConServer& aServer,

		CBearerManager& aBearerManager,

		TUint aId)

 :	iServer(aServer),

	iBearerManager(aBearerManager),

	iId(aId)

	{

	}

	{

	LOG_FUNC;

	iSendQueue = CMessageQueue::NewL();

	TCallBack cb(SendNextCb, this);

	}

CRemConSession::~CRemConSession()

	{

	LOG(KNullDesC8);

	LOG_FUNC;

	delete iSendNextCallBack;

	delete iSendQueue;

	delete iInterestedAPIs;

	}

void CRemConSession::ServiceL(const RMessage2& aMessage)

	{

	LOG(KNullDesC8);

	LOG_FUNC;

	LOG1(_L("\taMessage.Function() = %d"), aMessage.Function());

	// Switch on the IPC number and call a 'message handler'. Message handlers 

	// complete aMessage (either with Complete or Panic), or make a note of 

	// the message for later asynchronous completion.

	// Message handlers should not leave- the server does not have an Error 

	// function. 

	switch ( aMessage.Function() )

		{

	// Heap failure testing APIs.

	case ERemConDbgMarkHeap:

#ifdef _DEBUG

		LOG(_L("\tmark heap"));

		__UHEAP_MARK;

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgCheckHeap:

#ifdef _DEBUG

		LOG1(_L("\tcheck heap (expecting %d cells)"), aMessage.Int0());

		__UHEAP_CHECK(aMessage.Int0());

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgMarkEnd:

#ifdef _DEBUG

		LOG1(_L("\tmark end (expecting %d cells)"), aMessage.Int0());

		__UHEAP_MARKENDC(aMessage.Int0());

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgFailNext:

#ifdef _DEBUG

		{

		LOG1(_L("\tfail next (simulating failure after %d allocation(s))"), aMessage.Int0());

		if ( aMessage.Int0() == 0 )

			{

			__UHEAP_RESET;

			}

		else

			{

			__UHEAP_FAILNEXT(aMessage.Int0());

			}

		}

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

		// This is a sync API- check that the message has been completed.

		// (NB We don't check the converse for async APIs because the message 

		// may have been panicked synchronously.)

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConSend:

		Send(aMessage);

		break;

	case ERemConSendUnreliable:

		SendUnreliable(aMessage);

		break;

	case ERemConSendCancel:

		SendCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConReceive:

		Receive(aMessage);

		break;

	case ERemConReceiveCancel:

		ReceiveCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGetConnectionCount:

		GetConnectionCount(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGetConnections:

		GetConnections(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConNotifyConnectionsChange:

		NotifyConnectionsChange(aMessage);

		break;

	case ERemConNotifyConnectionsChangeCancel:

		NotifyConnectionsChangeCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConRegisterInterestedAPIs:

		RegisterInterestedAPIs(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	default:

		// Unknown message

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicIllegalIpc);

		break;

		}

	}

void CRemConSession::CompleteClient(const RMessage2& aMessage, TInt aError)

	{

	LOG1(_L("\tcompleting client message with %d"), aError);

	TBool cleanClientInfoMessage = (iClientInfo.Message().Handle() == aMessage.Handle());

	aMessage.Complete(aError);

	if(cleanClientInfoMessage)

		{

		iClientInfo.Message() = RMessage2();

		}

	}

	{

		{

		}

		{

		}

		{

		}

	}

void CRemConSession::Send(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Check we're not already sending...

	if ( iSendMsg.Handle())

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicSendAlreadyOutstanding);

		return;

		}

	iSendMsg = aMessage;

		{

		return;

		}

	// Before we ask the server to send, we must set our ClientInfo 

	// correctly so the TSP can get information about the client. 

	iClientInfo.Message() = aMessage;

	CRemConMessage* msg = NULL;

		{

		}

		{

		ASSERT_DEBUG(iSendQueue);

			{

			iSendQueue->Append(*msg);

			}

		else

			{

			SendToServer(*msg);

			}

		}

	}

void CRemConSession::SendCancel(const RMessage2& aMessage)

	{

	LOG_FUNC;

		{

		return;

		}

	// See comments in ConnectBearerCancel.

	if ( iSendMsg.Handle() )

		{

		DoSendCancel();

		}

	if (iSendMsg.Handle())

		{

		CRemConMessage* msg;

		TBool first = ETrue;

		ASSERT_DEBUG(iSendQueue);

		TSglQueIter<CRemConMessage>& iter = iSendQueue->SetToFirst();

		while ((msg = iter++) != NULL)

			{

			if (msg->IsReliableSend())

				{

				CompleteClient(iSendMsg, KErrCancel);

				iSendQueue->RemoveAndDestroy(*msg);

				if (first)

					{

					ASSERT_DEBUG(iSendNextCallBack);

					iSendNextCallBack->Cancel();

					}

				break;

				}

			first = EFalse;

			}

		}

	CompleteClient(aMessage, KErrNone);

	}

void CRemConSession::Receive(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Messages are pushed from bearers, so we 

	// (a) do some sanity checking, 

	// (b) check the queue of incoming messages in case there's anything 

	// already waiting to be given to the client.

	if ( iReceiveMsg.Handle() )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicReceiveAlreadyOutstanding);

		return;

		}

		{

		return;

		}

	iReceiveMsg = aMessage;

	}

void CRemConSession::ReceiveCancel(const RMessage2& aMessage)

	{

	LOG_FUNC;

		{

		return;

		}

	// See comments in ConnectBearerCancel.

	if ( iReceiveMsg.Handle() )

		{

		CompleteClient(iReceiveMsg, KErrCancel);

		}

	CompleteClient(aMessage, KErrNone);

	}

void CRemConSession::GetConnectionCount(const RMessage2& aMessage)

	{

	LOG_FUNC;

		{

		return;

		}

	// Get the answer to the question- the number of connections at the 

	// current point in time (i.e. the latest entry in the connection 

	// history).

	const TUint connCount = iServer.Connections().Count();

	LOG1(_L("\tconnCount = %d"), connCount);

	TPckg<TUint> count(connCount);

	TInt err = aMessage.Write(0, count);

	// If the client was told the answer with no error, then remember the 

	// current point in the connection history, so that when the client asks 

	// for the connections themselves, we give them a consistent answer.

	if ( err == KErrNone )

		{

		iServer.SetConnectionHistoryPointer(Id());

		}

	CompleteClient(aMessage, err);

	}

void CRemConSession::GetConnections(const RMessage2& aMessage)

	{

	LOG_FUNC;

		{

		return;

		}

	// Get the array of connections at the point in the history we're 

	// interested in and write it back to the client. NB This is not 

	// necessarily the Last item in the history but the item that we were 

	// pointing at when GetConnectionCount was called.

	const CConnections& conns = iServer.Connections(iId);

	const TUint count = conns.Count();

	LOG1(_L("\tcount = %d"), count);

	RBuf8 buf;

	TInt err = buf.Create(count * sizeof(TRemConAddress));

	if ( err == KErrNone )

		{

		TSglQueIter<TRemConAddress>& iter = conns.SetToFirst();

		TRemConAddress* addr;

		while ( ( addr = iter++ ) != NULL )

			{

			buf.Append((TUint8*)addr, sizeof(TRemConAddress));

			}

		// Write back to the client...

		err = aMessage.Write(0, buf);

		buf.Close();

		if ( err != KErrNone )

			{

			// We don't need to call SetConnectionHistoryPointer here because 

			// the server will do it when it cleans up the panicked client.

			PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadDescriptor);

			return;

			}	   		

		}

	// Whether or not there was an error, we're no longer interested in the 

	// history item we're currently registered as being interested in, so tell 

	// the server to bump up our pointer to the current (latest) one. NB This 

	// may in fact be the same record, if no connection changes have occurred 

	// since GetConnectionCount was called, but it's still important to give 

	// the server a chance to remove obsolete history records.

	iServer.SetConnectionHistoryPointer(Id());

	CompleteClient(aMessage, err);

	}

void CRemConSession::NotifyConnectionsChange(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Messages are pushed to us from bearers, so we don't need anything more 

	// than some sanity checking here.

		{

		return;

		}