// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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 T_Lbschannel.cpp
// This is the Cpp file which contains the channel for communication between
// the test harness and the test AGps module.
// 
//

// User includes
#include "tlbschannel.h"

const TInt KLbsChannelIdMax = RT_LbsChannel::EChannelTAGPS2TH;
//const TInt KCategoryKeyIndex	 = 0;
const TInt KReadPropKeyIndex 	 = 1;
const TInt KReadPropAckKeyIndex  = 2;
const TInt KWritePropKeyIndex 	 = 3;
const TInt KWritePropAckKeyIndex = 4;

/** The array contains description (property size, keys and Ids) of all the channels supported by 
    the RT_LbsChannel interface */
const TUint KPropTable[KLbsChannelIdMax+1][5]=
	{
	{0, KTH2TAGPSMessageKey, KTH2TAGPSMessageReadAckKey, KTAGPS2THMessageKey, KTAGPS2THMessageReadAckKey}, 
	{0, KTAGPS2THMessageKey, KTAGPS2THMessageReadAckKey, KTH2TAGPSMessageKey, KTH2TAGPSMessageReadAckKey}, 
	};

///////////////////////////////////////////////////////////////////////////////
// RT_LbsChannel
///////////////////////////////////////////////////////////////////////////////

EXPORT_C void RT_LbsChannel::InitializeL(TT_LbsChannelId aChannelId)
	{
	const TSecurityPolicy KReadPolicy(ECapability_None);
	const TSecurityPolicy KWritePolicy(ECapabilityWriteDeviceData);
	
	TInt err = RProperty::Define(KUidSystemCategory,
								 KPropTable[aChannelId][KWritePropKeyIndex],
								 RProperty::ELargeByteArray, 
								 KReadPolicy, KWritePolicy, 
								 sizeof(TT_LbsMsgBase));
	if (err != KErrNone && err != KErrAlreadyExists)
		{
		User::Leave(err);
		}
						 
	err = RProperty::Define(KUidSystemCategory,
							KPropTable[aChannelId][KWritePropAckKeyIndex],
							RProperty::EInt,
							KReadPolicy, KWritePolicy);
	if (err != KErrNone && err != KErrAlreadyExists)
		{
		User::Leave(err);
		}
										 
	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KPropTable[aChannelId][KWritePropAckKeyIndex], 0));
	}


EXPORT_C void RT_LbsChannel::ShutDownL(TT_LbsChannelId aChannelId)
	{
	User::LeaveIfError(RProperty::Delete(KPropTable[aChannelId][KWritePropKeyIndex]));
	User::LeaveIfError(RProperty::Delete(KPropTable[aChannelId][KWritePropAckKeyIndex]));
	}


EXPORT_C RT_LbsChannel::RT_LbsChannel()
	{
	}
	

/** 

The channel must first be initialised before this is called, otherwise the
resources needed by the channel will not have been allocated.

@param aObserver Reference to the observer class used to notify of new messages. 
@param aChannelId Uid of the RProperty category used for this channel.

@leave
*/
EXPORT_C void RT_LbsChannel::OpenL(TT_LbsChannelId aChannelId, MT_LbsChannelObserver& aObserver)
	{	
	__ASSERT_DEBUG(iSendProperty.Handle()==NULL, User::Invariant());
	__ASSERT_DEBUG(iSendMsgReadProperty.Handle()==NULL, User::Invariant());
	
	User::LeaveIfError(iSendProperty.Attach(KUidSystemCategory, KPropTable[aChannelId][KWritePropKeyIndex]));
	User::LeaveIfError(iSendMsgReadProperty.Attach(KUidSystemCategory, KPropTable[aChannelId][KWritePropAckKeyIndex]));
	
	iMonitor = CT_ChannelMonitor::NewL(aObserver, aChannelId, KUidSystemCategory, 
										KPropTable[aChannelId][KReadPropKeyIndex], 
										KPropTable[aChannelId][KReadPropAckKeyIndex]);
	}

/** Close the connection.

This function closes the connection and frees any resources 
created in RTbsChannel::OpenL().
*/	
EXPORT_C void RT_LbsChannel::Close()
	{
	CancelSendMessageNotification();
	
	delete iMonitor;
	iSendProperty.Close();
	iSendMsgReadProperty.Close();
	}

/** Send a message through the channel.
    
This is an asynchronous function that only completes when the message 
has been read. 

If another call is made to this function before a previous one has 
completed then aStatus will be completed straight away, with the 
completion code KErrInUse.
    
@param aMessage The message to be sent.
@param aStatus Request status that is completed when the message has
			   been read. If there is an error sending the message
			   it will be stored in aStatus.Int().
*/
EXPORT_C void RT_LbsChannel::SendMessage(const TT_LbsMsgBase& aMessage, 
												 TRequestStatus& aStatus)
	{
	// Must check that the previous message was read
	TInt sendAck;
	iSendMsgReadProperty.Get(sendAck);
	if (sendAck == 1)
		{
		// Pending message has not been read yet; flag an error
		TRequestStatus* statPtr = &aStatus;
		User::RequestComplete(statPtr, KErrInUse);
		}
	else
		{
		// Publish the new message
		iSendMsgReadProperty.Set(1);
		iSendMsgReadProperty.Subscribe(aStatus);
		TPckgC<TT_LbsMsgBase> pckg(aMessage);
		iSendProperty.Set(pckg);
		}	
	}
			
/** Cancel the current request status for SendMessage().
*/
EXPORT_C void RT_LbsChannel::CancelSendMessageNotification()
	{
	iSendMsgReadProperty.Cancel();
	}	


///////////////////////////////////////////////////////////////////////////////
// CT_ChannelMonitor - used to listen for incoming messages 
///////////////////////////////////////////////////////////////////////////////
CT_ChannelMonitor* CT_ChannelMonitor::NewL(MT_LbsChannelObserver& aObserver, RT_LbsChannel::TT_LbsChannelId aChannelId, TUid aPropId, TUint aPropKey, TUint aAckPropKey)
	{
	CT_ChannelMonitor* self = new (ELeave) CT_ChannelMonitor(aObserver, aChannelId);
	CleanupStack::PushL(self);
	self->ConstructL(aPropId, aPropKey, aAckPropKey);
	CleanupStack::Pop();
	return self;
	}

CT_ChannelMonitor::CT_ChannelMonitor(MT_LbsChannelObserver& aObserver, RT_LbsChannel::TT_LbsChannelId aChannelId) :
	CActive(EPriorityStandard),
	iObserver(aObserver),
	iChannelId(aChannelId)
	{
	CActiveScheduler::Add(this);
	}

CT_ChannelMonitor::~CT_ChannelMonitor()
	{
	Cancel();
	iReceiveProperty.Close();
	iReceiveMsgReadProperty.Close();	
	}

void CT_ChannelMonitor::ConstructL(TUid aPropId, TUint aPropKey, TUint aAckPropKey)
	{
	__ASSERT_DEBUG(iReceiveProperty.Handle()==NULL, User::Invariant());		//Handle open.
	__ASSERT_DEBUG(iReceiveMsgReadProperty.Handle()==NULL, User::Invariant());		//Handle open.
	
	User::LeaveIfError(iReceiveProperty.Attach(aPropId, aPropKey));
	User::LeaveIfError(iReceiveMsgReadProperty.Attach(aPropId, aAckPropKey));
	
	NotifyChannelMessage();
	// flag we are ready for receiving messages
	iReceiveMsgReadProperty.Set(0);
	}
	
void CT_ChannelMonitor::NotifyChannelMessage()
	{
	iReceiveProperty.Subscribe(iStatus);
	SetActive();	
	}

void CT_ChannelMonitor::RunL()
	{
	TInt result = iStatus.Int();
	switch (result)
		{
		case KErrNone:
			{
			// Read property
			TT_LbsMsgBase msg;
			TPckg<TT_LbsMsgBase> pckg(msg);
			iReceiveProperty.Get(pckg);
			
			// resubscribe for further messages
			NotifyChannelMessage();
			
			// Notify observer
			iObserver.ProcessChannelMessage(iChannelId, msg);

			// flag message as read
			iReceiveMsgReadProperty.Set(0);
			break;	
			}
		default:
			{
			User::Leave(result);
			break;
			}
		}
	}
	
void CT_ChannelMonitor::DoCancel()
	{
	iReceiveProperty.Cancel();
	}
	
TInt CT_ChannelMonitor::RunError(TInt /*aError*/)
	{
	return KErrNone;
	}