/*
* Copyright (c) 2006-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:  	This class inherits the common functionalities for requests to the 
*				Location Monitor from EPos_CPosLocMonitorReqHandlerBase.h and also
*				implements the functions specific to Last Known Position Area request.
*
*/




#include "EPos_CPosLastKnownPosAreaHandler.h"
#include  "EPos_CPosCallbackTimer.h"

// ============================ CONSTANTS ===========================================================
#ifdef _DEBUG
_LIT(KTraceFileName, "EPos_CPosLastKnownPosAreaHandler.cpp");
#endif

// ============================== MEMBER FUNCTIONS ===================================================
CPosLastKnownPosAreaHandler* CPosLastKnownPosAreaHandler::NewL()
	{
	CPosLastKnownPosAreaHandler* self = new( ELeave ) CPosLastKnownPosAreaHandler();
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

CPosLastKnownPosAreaHandler::CPosLastKnownPosAreaHandler()
	{
	CActiveScheduler::Add(this);
	}

void CPosLastKnownPosAreaHandler::ConstructL()
	{
    TCallBack timeoutCallBack(HandleTimeOut, this);
    iTimeoutTimer = CPosCallbackTimer::NewL(timeoutCallBack);
	}

CPosLastKnownPosAreaHandler::~CPosLastKnownPosAreaHandler()
	{
	
	if (iStatus==KRequestPending)
		{
		// Cancel the request sent to the location monitor
		Cancel();
		}

	if ( iLocMonAreaPositioner.SubSessionHandle() )
		{
		iLocMonAreaPositioner.Close();
		}
	
	delete iTimeoutTimer;
	
	// The requests on the queue are completed by the base class destructor
	}

/** 
 * GetLastKnownPosAreaL 
 * 		>>  Initiate a new request with the location monitor if the request queue is empty. 
 * 			Otherwise, check if the session and subsession id of any request on the queue matches that of the 
 *			new request [ie. a duplicate request from the client]. If it matches panic the client. 
 * 			If not add the new request to the queue. 
 *
 * @param  aLocMonSession    - The handle to the session with the location monitor passed on from
 * 							   CPosLocMonitorReqHandlerHub.
 * @param  aMessage  		 - The new request from the client 
 */
void CPosLastKnownPosAreaHandler::GetLastKnownPosAreaL(RLbsLocMonitorSession& aLocMonSession, const RMessage2& aMessage)
	{
	DEBUG_TRACE("CPosLastKnownPosAreaHandler::GetLastKnownPosAreaL", __LINE__)

	if ( !(aLocMonSession.Handle()))
		{
		// Session with the location monitor is not found
		RequestComplete(aMessage, KErrCouldNotConnect);
		return;
		}

	if (!(iLocMonAreaPositioner.SubSessionHandle()))
		{
		iLocMonAreaPositioner.OpenL(aLocMonSession);
		}
	
	// Copy the buffers from the address space of the client
	HBufC8* lkposclientbuf = Global::CopyClientBuffer8LC(aMessage, KParamLKPAreaReqPos);
	HBufC8* lkposareaclientbuf = Global::CopyClientBuffer8LC(aMessage, KParamLKPAreaReqArea);

	TPositionInfoBase& posInfoBase = reinterpret_cast<TPositionInfoBase&>
	(const_cast<TUint8&>(*lkposclientbuf->Ptr()));
	TPositionAreaInfoBase& posAreaInfoBase = reinterpret_cast<TPositionAreaInfoBase&>
	(const_cast<TUint8&>(*lkposareaclientbuf->Ptr()));

	Global::ValidatePositionClassBufferL(posInfoBase, lkposclientbuf->Des());
	Global::ValidatePositionClassTypeL(posInfoBase, EPositionInfoClass, KErrArgument);
	Global::ValidatePositionClassBufferL(posAreaInfoBase, lkposareaclientbuf->Des());

	switch (posAreaInfoBase.PositionClassType())
		{
		case EPositionAreaInfoClass:
			Global::ValidatePositionClassTypeL(posAreaInfoBase, EPositionAreaInfoClass, KErrArgument);
			break;
		case (EPositionAreaExtendedInfoClass+EPositionAreaInfoClass): //TODO Check LbsAreaInfo.cpp [constructor]
			Global::ValidatePositionClassTypeL(posAreaInfoBase, (EPositionAreaExtendedInfoClass+EPositionAreaInfoClass), KErrArgument);
			break;
		default:
			User::Leave(KErrArgument); 								//TODO - Check if this is correct ?
			break;
		}

	CleanupStack::PopAndDestroy(lkposareaclientbuf);
	CleanupStack::PopAndDestroy(lkposclientbuf);

	// Check the identity of the subsession and add the request to the queue
	CheckAndAddReqToQueueL(EReqOnSubSession, aMessage);
	
	if ((iLocMonitorReqQ.Count()>0) && !IsActive())
		{
		// Always ask for extended information from the location monitor
		// as initiating a new request for later clients that require extended information
		// is inefficient
		iParameters.iPositionAreaType = (EPositionAreaExtendedInfoClass | EPositionAreaInfoClass);
		
		// Initiate a new last known position request with the location monitor
		iLocMonAreaPositioner.GetLastKnownPositionArea(iPositionInfo, iPositionAreaInfo, iParameters, iStatus);
		SetActive();
		
	    // Start timer if necessary
	    if (KLastKnownPosAreaTimeOut.Int64()>0)
	        {
	        DEBUG_TRACE("CPosLastKnownPosHandler::GetLastKnownPosAreaL() Start Timeout Timer", __LINE__)
	        iTimeoutTimer->StartTimer(KLastKnownPosAreaTimeOut);
	        }
		}

	}

/** 
 * CancelGetLastKnownPosAreaL 
 * 		>> Cancel the outstanding request with the location monitor if there is only one request on the queue. 
 *		>> Otherwise just complete the cancel request with KErrNone, remove the original request from the queue
 * 		   and complete it with KErrCancel.
 * @param  aMessage  		 - The cancel request from the client 
 */
void CPosLastKnownPosAreaHandler::CancelGetLastKnownPosAreaL(const RMessage2& aMessage)
	{
	DEBUG_TRACE("CPosLastKnownPosAreaHandler::CancelGetLastKnownPosAreaL", __LINE__)

	// The subsession with the location monitor is not found
	if ( !(iLocMonAreaPositioner.SubSessionHandle()) )
		{
		RequestComplete(aMessage, KErrNotFound);
		return;
		}
	
	// Call CancelRequest inherited from the baseclass
	CancelRequest(EReqOnSubSession, aMessage);

	}

/** 
 * NotifyOnEmptyLastKnownPosStoreReq 
 * 		>> Cancel the outstanding get last known position area requests with KErrCancel
 * 		   as an empty last known position store request has been issued.
 */
void  CPosLastKnownPosAreaHandler::NotifyOnEmptyLastKnownPosStoreReq()
	{
	// Complete all the requests on the queue with KErrCancel
	QRequestsComplete(KErrCancel);
	
	if (iStatus==KRequestPending)
		{
		Cancel();
		}
	}

/** 
 * RunL 
 * 		>> Complete all the requests on the queue.
 */
void CPosLastKnownPosAreaHandler::RunL()
	{
	
	// Cancel the timeout timer
	iTimeoutTimer->Cancel();
	
	// Serving all the outstanding requests based on the current update
	// from the Location Monitor
	while (iLocMonitorReqQ.Count()>0)
		{
		TInt numReqs = iLocMonitorReqQ.Count()-1;
		// Retrieve the next request to be serviced [first element in the queue - FIFO]
		if (iStatus.Int()==KErrNone)
			{
			// Copy the buffers from the address space of the client
			const TUint8* startAddress = reinterpret_cast <const TUint8*>(&iPositionInfo)+sizeof(TPositionClassTypeBase);
			TInt chunkSize = sizeof(TPositionInfo)-sizeof(TPositionClassTypeBase);
			TPtr8 copyFromDesc(const_cast<TUint8*>(startAddress),chunkSize,chunkSize);
			
			TInt err = Global::Write(iLocMonitorReqQ[numReqs],KParamLKPAreaReqPos,copyFromDesc,sizeof(TPositionClassTypeBase));
			//TInt err = iLocMonitorReqQ[numReqs].Write(KParamLKPAreaReqPos,copyFromDesc,sizeof(TPositionClassTypeBase));

			// To identify the type of the request - last known position area / last known position area + extended info.
			HBufC8* lkposareaclientbuf = Global::CopyClientBuffer8LC(iLocMonitorReqQ[numReqs], KParamLKPAreaReqArea);
			TPositionAreaInfoBase& posAreaInfoBase = reinterpret_cast<TPositionAreaInfoBase&>(const_cast<TUint8&>(*lkposareaclientbuf->Ptr()));
			startAddress = reinterpret_cast <const TUint8*>(&iPositionAreaInfo)+sizeof(TPositionClassTypeBase);
			
			switch (posAreaInfoBase.PositionClassType())
				{
				case EPositionAreaInfoClass:
					chunkSize = sizeof(TPositionAreaInfo)-sizeof(TPositionClassTypeBase);
					copyFromDesc.Set(const_cast<TUint8*>(startAddress),chunkSize,chunkSize);
					//err = iLocMonitorReqQ[numReqs].Write(KParamLKPAreaReqArea,copyFromDesc,sizeof(TPositionClassTypeBase));
					err = Global::Write(iLocMonitorReqQ[numReqs],KParamLKPAreaReqArea,copyFromDesc,sizeof(TPositionClassTypeBase));
					RequestComplete(iLocMonitorReqQ[numReqs], err);
					break;
				case (EPositionAreaExtendedInfoClass+EPositionAreaInfoClass): //TODO Check LbsAreaInfo.cpp [constructor]
					chunkSize = sizeof(TPositionAreaExtendedInfo)-sizeof(TPositionClassTypeBase);
					copyFromDesc.Set(const_cast<TUint8*>(startAddress),chunkSize,chunkSize);
					err = Global::Write(iLocMonitorReqQ[numReqs],KParamLKPAreaReqArea,copyFromDesc,sizeof(TPositionClassTypeBase));
					//err = iLocMonitorReqQ[numReqs].Write(KParamLKPAreaReqArea,copyFromDesc,sizeof(TPositionClassTypeBase));		
					RequestComplete(iLocMonitorReqQ[numReqs], err);
					break;
				default:
					RequestComplete(iLocMonitorReqQ[numReqs], KErrArgument);								//TODO - Check if this is correct ?
					break;
				}
			// Destroy the buffer used to hold the client's data
			CleanupStack::PopAndDestroy(lkposareaclientbuf);
			
			}
		else
			{
			// Complete the client request with aReason
			RequestComplete(iLocMonitorReqQ[numReqs],iStatus.Int());
			}

		// Remove the request that has just been serviced [last element]
		iLocMonitorReqQ.Remove(numReqs);
		}
	
	// Close the subsession with the location monitor when we receive the last known position area from it
	iLocMonAreaPositioner.Close();

	}

TInt CPosLastKnownPosAreaHandler::RunError(TInt aError)
	{
	return aError;
	}


/** 
 * DoCancel 
 * 		>> Cancel the active object.
 */
void CPosLastKnownPosAreaHandler::DoCancel()
	{
	// Cancel the timer as the request with the location monitor is going to be cancelled
	iTimeoutTimer->Cancel();
	
	DEBUG_TRACE("calling RLbsAreaPositioner::CancelGetLastKnownPosition()", __LINE__)
	__ASSERT_DEBUG((iLocMonAreaPositioner.SubSessionHandle())!=NULL, DebugPanic(EPosServerPanicPositionerNotInitialized));
	
	TInt err = iLocMonAreaPositioner.CancelGetLastKnownPositionArea();
	// As the cancel request is immediately completed, this return value 
	// is not useful.
	}

/** 
 * HandleTimeOut 
 * 		>> Complete all the requests on the queue with KErrTimedOut.
 * @param  aRequestHandler - self pointer used to call the appropriate timeout handling method
 */
TInt CPosLastKnownPosAreaHandler::HandleTimeOut(TAny* aRequestHandler)
    {

    DEBUG_TRACE("CPosLastKnownPosAreaHandler::HandleTimeOut()", __LINE__)    
    
    CPosLastKnownPosAreaHandler* self = reinterpret_cast<CPosLastKnownPosAreaHandler*>(aRequestHandler);
    // The request with the location monitor has timed out. So complete all the outstanding 
    // requests with KErrTimedOut
    self->QRequestsComplete(KErrTimedOut);
    // Cancel the pending request with the location monitor
    self->Cancel();

    return KErrNone;
    
    }