/*
* Copyright (c) 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:  	The base class that provides the common functionalities of 
*				all the requests to the Location Monitor
*
*/



#include "EPos_CPosLocMonitorReqHandlerBase.h"


// ============================== MEMBER FUNCTIONS ===================================================
/**
 * C++ default constructor
 */
CPosLocMonitorReqHandlerBase::CPosLocMonitorReqHandlerBase() :
CActive(EPriorityStandard),
iSubsessionIdentity(CPosLocMonitorReqHandlerBase::MatchSessionAndSubsession),
iSessionIdentity(CPosLocMonitorReqHandlerBase::MatchSession)
	{
	
	
	}

/**
 * Destructor
 */
CPosLocMonitorReqHandlerBase::~CPosLocMonitorReqHandlerBase()
	{
	QRequestsComplete(KErrNotFound);

	iLocMonitorReqQ.Close();
	}

/**
 * RequestComplete
 * 				>> Complete a request with the given code
 * @param aMessage 		- The request to be completed
 * @param aCompleteCode - The completion code
 */
void CPosLocMonitorReqHandlerBase::RequestComplete(const RMessage2& aMessage, TInt aCompleteCode)
	{
	// Complete the client request with the respective status code
	if (!aMessage.IsNull())
		{
		aMessage.Complete(aCompleteCode);
		}
	}

/** 
 * CheckAndAddReqToQueueL 
 * 		>> If the client has issued a duplicate request on a session or subsession when one is already oustanding,
 * 		   panic the client. Otherwise add the request to the queue.
 *
 * @param  aRequestType      - Type of request [ on session or subsession ]
 * @param  aMessage  		 - The new request from the client 
 */
void CPosLocMonitorReqHandlerBase::CheckAndAddReqToQueueL(TLocMonitorRequestType aRequestType, const RMessage2& aMessage)
	{
		// Find if any request from this client already exists on the queue
    	TInt reqQMatchIndex=KErrNotFound;
    	reqQMatchIndex = MatchRequestInQueue(aRequestType,aMessage);
    	
    	if (KErrNotFound==reqQMatchIndex)
    		{
    		// Request has to be queued
    		iLocMonitorReqQ.AppendL(aMessage);
    		}
    		else
    		{
    		// Remove the request from the queue
    		iLocMonitorReqQ.Remove(reqQMatchIndex);
 
    		aMessage.Panic(KPosClientFault, EPositionDuplicateRequest);
    		}
	}

/** 
 * CancelRequest 
 * 		>> Complete the cancel request with KErrNone, remove the original request from the queue
 * 		   and complete it with KErrCancel.
 *
 * @param  aRequestType      - Type of request [ on session or subsession ]
 * @param  aMessage  		 - The new request from the client 
 */
void CPosLocMonitorReqHandlerBase::CancelRequest(TLocMonitorRequestType aRequestType, const RMessage2& aMessage)
	{
	// Atleast one oustanding request exists
	if (iLocMonitorReqQ.Count()>0)
		{
		// [The request queue is not empty]
		if (iLocMonitorReqQ.Count()==1)
			{
			// If there is currently only one ongoing request and a cancel has been issued
			// Complete the requests immediately and then call cancel on the active object
			// which cancels the request to the location monitor
			
			// Complete the pending last known position request with KErrCancel
			RequestComplete(iLocMonitorReqQ[0], KErrCancel);
			
			// Remove the request from the queeu
			iLocMonitorReqQ.Remove(0);

			// Complete the request to cancel the last known position request with KErrNone
			RequestComplete(aMessage, KErrNone);
			
			// Calling Cancel inturn calls DoCancel which cancels the request with the 
			// location monitor
			Cancel();
			}
		else
			{
			FindRequestAndCancel(aRequestType, aMessage);
			}
		}

	else
		{
		// No request found (on the queue) -> No oustanding request
		RequestComplete(aMessage, KErrNotFound);
		}
	}

/** 
 * FindRequestAndCancel 
 * 		>> Find the matching request in the queue using session / subsession id based on aRequestType
 *         and complete it with KErrCancel. Complete the cancel request with KErrNone.
 *
 * @param  aRequestType      - Type of request [ on session or subsession ]
 * @param  aMessage  		 - The new request from the client 
 */
void CPosLocMonitorReqHandlerBase::FindRequestAndCancel(TLocMonitorRequestType aRequestType, const RMessage2& aMessage)
	{
	// Called only if there is more than one request on the queue
	// Find the index of the request to be removed from the queue
	TInt reqQMatchIndex=KErrNotFound;
	reqQMatchIndex = MatchRequestInQueue(aRequestType, aMessage);

	if (KErrNotFound==reqQMatchIndex)
		{
		RequestComplete(aMessage,KErrNotFound); // TODO KErrNotFound is correct ? 
		}
	else
		{
		// Complete the pending LKPosArea request with KErrCancel
		RequestComplete(iLocMonitorReqQ[reqQMatchIndex], KErrCancel);
		// Remove the request from the queue
		iLocMonitorReqQ.Remove(reqQMatchIndex);

		// Complete the request to cancel LKPosArea request with KErrNone
		RequestComplete(aMessage,KErrNone);
		}
	
	}

/** 
 * MatchRequestInQueue 
 * 		>> Find the matching request in the queue using session / subsession id.
 *
 * @param  aRequestType      - Type of request [ on session or subsession ]
 * @param  aMessage  		 - The new request from the client 
 */
TInt CPosLocMonitorReqHandlerBase::MatchRequestInQueue(TLocMonitorRequestType aRequestType, const RMessage2& aMessage)
	{
	TInt reqQMatchIndex=KErrNotFound;
	
	switch (aRequestType)
		{
		case EReqOnSession :
			// Match the session
			reqQMatchIndex = iLocMonitorReqQ.Find(aMessage,iSessionIdentity);
			break;
		case EReqOnSubSession :
			// Match the session and the subsession
			reqQMatchIndex = iLocMonitorReqQ.Find(aMessage,iSubsessionIdentity);
			break;
		default :
			break;
		}
	
	return reqQMatchIndex;
	}

/** 
 * MatchSession 
 * 		>> Check if  the Session corresponding to an outstanding request [on the queue] 
 * 		   matches that of the new request
 *
 * @param  qClient    - An entry from the queue of oustanding requests
 * @param  newClient  - The new request from the client 
 */
TBool CPosLocMonitorReqHandlerBase::MatchSession(const RMessage2& qClient, const RMessage2& newClient)
	{
	return ( qClient.Session()== newClient.Session() );
	}

/** 
 * MatchSubsession 
 * 		>> Check if  the Subsession corresponding to an outstanding request [on the queue] 
 * 		   matches that of the new request
 *
 * @param  qClient    - An entry from the queue of oustanding requests
 * @param  newClient  - The new request from the client 
 */
TBool CPosLocMonitorReqHandlerBase::MatchSessionAndSubsession(const RMessage2& qClient, const RMessage2& newClient)
	{
	return ( (qClient.Session()== newClient.Session()) && (qClient.Int3()== newClient.Int3()) );
	}

/** 
 * QRequestsComplete 
 * 		>> Complete all the requests in the queue with the given errorcode.
 *
 * @param  aCompleteCode   - Requests completed with this code.
 */
void CPosLocMonitorReqHandlerBase::QRequestsComplete(TInt aCompleteCode)
	{
	// Complete all the requests on the queue with the given completion code
	while(iLocMonitorReqQ.Count()>0)
		{
		TInt index = iLocMonitorReqQ.Count()-1;
		// Complete all the requests in the queue with KErrServerTerminated
		if (!iLocMonitorReqQ[index].IsNull())
			{
			iLocMonitorReqQ[index].Complete(aCompleteCode);
			}
		iLocMonitorReqQ.Remove(index);
		}
	
	}

/** 
 * NotifySubSessionClosed 
 * 		>> Clear the queue of requests issued on subsession if it is closed prematurely.
 *
 * @param  aMessage   - The client request used to retrieve the subsession id.
 */
void CPosLocMonitorReqHandlerBase::NotifySubSessionClosed(const RMessage2& aMessage)
	{
	// If the subsession is closed before the Last Known Position is received from the Loc Monitor,
	// then complete the requests from that subsession with KErrDisconnected
	TInt reqQMatchIndex=KErrNotFound;
	reqQMatchIndex = iLocMonitorReqQ.Find(aMessage,iSubsessionIdentity);

	if (reqQMatchIndex != KErrNotFound)
		{
		if ((iLocMonitorReqQ.Count()==1)&&(iStatus==KRequestPending))
			{
			// Only one outstanding request - issue a cancel to the location monitor
			Cancel();
			}
		if (iLocMonitorReqQ.Count()>=1)
			{
			// Remove the request from the queue
			iLocMonitorReqQ.Remove(reqQMatchIndex);
			}
		}
	}

/** 
 * NotifySubSessionClosed 
 * 		>> Clear the queue of requests issued on the session & subsession if 
 * 		   the session is closed prematurely.
 *
 * @param  aSessionPtr   - The session id [session pointer].
 */
void CPosLocMonitorReqHandlerBase::NotifySessionClosed(const CSession2* aSessionPtr)
	{
	// As it is easier to delete the entries from the end of the queue
	// store the index of the final element
	TInt index = iLocMonitorReqQ.Count()-1;

	// Clear all the outstanding Last Known Position Requests on the queue 
	// and panic the client with EPositionRequestsNotCancelled
	while (index>=0)
		{
		if ( aSessionPtr ==  const_cast<const CSession2*>( (iLocMonitorReqQ[index].Session()) ) )
			{
			//TODO Panic or RequestComplete? RequestComplete(iLKPosQ[index],KErrDisconnected);
			iLocMonitorReqQ[index].Panic(KPosClientFault, EPositionRequestsNotCancelled);
			iLocMonitorReqQ.Remove(index);
			}
		index--;
		}

	// No more request on the queue - So issue a cancel to the location monitor
	if ((iLocMonitorReqQ.Count()<=0)&&(iStatus==KRequestPending))
		{
		Cancel();
		}
	}

/** 
 * NotifyServerShutDown 
 * 		>> Clear the queue of requests.
 */
void CPosLocMonitorReqHandlerBase::NotifyServerShutDown()
	{
		// Complete all the requests on the queue with KErrServerTerminated
		// The Client/Server framework doesnot guarantee the completion
		QRequestsComplete(KErrServerTerminated);
	}