/*

* 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 request.

*

*/

#include "testEPos_CPosLastKnownPosHandler.h"

#include  "EPos_CPosCallbackTimer.h"

// CONSTANTS

#ifdef _DEBUG

_LIT(KTraceFileName, "testEPos_CPosLastKnownPosHandler.cpp");

#endif

CPosLastKnownPosHandler* CPosLastKnownPosHandler::NewL()

	{

	CPosLastKnownPosHandler* self = new( ELeave ) CPosLastKnownPosHandler();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

CPosLastKnownPosHandler::CPosLastKnownPosHandler()

	{

	CActiveScheduler::Add(this);

	}

void CPosLastKnownPosHandler::ConstructL()

	{

    TCallBack timeoutCallBack(HandleTimeOut, this);

    iTimeoutTimer = CPosCallbackTimer::NewL(timeoutCallBack);

	}

CPosLastKnownPosHandler::~CPosLastKnownPosHandler()

	{

	if (iStatus==KRequestPending)

		{

		// Cancel the request sent to the location monitor

		Cancel();

		}

	if (iLocMonPositioner.SubSessionHandle())

		{

		iLocMonPositioner.Close();

		}

	delete iTimeoutTimer;

	// The requests on the queue are completed by the base class destructor

	}

void CPosLastKnownPosHandler::GetLastKnownPosL(RLbsLocMonitorSession& aLocMonSession, const RMessage2& aMessage)

	{

	DEBUG_TRACE("CPosLastKnownPosHandler::RequestPosL", __LINE__)

	if ( !(aLocMonSession.Handle()) )

		{

		// Session with the location monitor is not found

		RequestComplete(aMessage, KErrCouldNotConnect);

		return;

		}

	if ( !(iLocMonPositioner.SubSessionHandle()) )

		{

		TInt err = iLocMonPositioner.OpenL(aLocMonSession);

		if (err != KErrNone)

			{

			RequestComplete(aMessage, err);

			return;

			}

		}

	CheckAndAddReqToQueueL(EReqOnSubSession, aMessage);

	if ((iLocMonitorReqQ.Count()>0) && !(this->iStatus==KRequestPending) )

		{

		// Initiate a new last known position request with the location monitor

		iLocMonPositioner.GetLastKnownPosition(iPositionInfo, iStatus);

		SetActive();

	    // Start timer if necessary

	    if (KLastKnownPosTimeOut.Int64()>0)

	        {

	        DEBUG_TRACE("CPosLastKnownPosHandler::GetLastKnownPosL() Start Timeout Timer", __LINE__)

	        iTimeoutTimer->StartTimer(KLastKnownPosTimeOut);

	        }

		}

	}

void CPosLastKnownPosHandler::CancelGetLastKnownPosL(const RMessage2& aMessage)

	{

	DEBUG_TRACE("CPosLastKnownPosHandler::CancelGetLastKnownPosL", __LINE__)

	if ( iLocMonPositioner.SubSessionHandle() ) 

		{

		// Call CancelRequest inherited from the baseclass

		CancelRequest(EReqOnSubSession, aMessage);

		}

	else

		{

		// The subsession with the location monitor is not found

		RequestComplete(aMessage, KErrCouldNotConnect); //TODO - KErrCouldNotConnect ?

		}

	}

void CPosLastKnownPosHandler::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)

		{

		// Retrieve the next request to be serviced

		TInt numReqs = iLocMonitorReqQ.Count()-1;

		if (iStatus.Int()==KErrNone)

			{

			// |TPositionClassTypeBase|TPositionInfoBase|TPositionInfo|...

			// No matter what the type of the class derived from TPositionInfo, the location monitor

			// just returns TPositionInfo and we write only the part |TPositionInfoBase|TPositionInfo|

			// skipping the TPositionClassTypeBase as it contains the position class type and size

			// that should not be corrupted.

			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 = iLocMonitorReqQ[numReqs].Write(0,copyFromDesc,sizeof(TPositionClassTypeBase));

			RequestComplete(iLocMonitorReqQ[numReqs], err);

			}

		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 from it

	iLocMonPositioner.Close();

	}

TInt CPosLastKnownPosHandler::RunError(TInt aError)

	{

	return aError;

	}

void CPosLastKnownPosHandler::DoCancel()

	{

	__ASSERT_DEBUG((iLocMonPositioner.SubSessionHandle())!=NULL, DebugPanic(EPosServerPanicPositionerNotInitialized));

	// Cancel the timer as the request with the location monitor is going to be cancelled

	iTimeoutTimer->Cancel();

	DEBUG_TRACE("calling RLbsAreaPositioner::CancelGetLastKnownPosition()", __LINE__)

	TInt err = iLocMonPositioner.CancelGetLastKnownPosition();

	// As the cancel request is immediately completed, this return value 

	// is not useful.

	}

void  CPosLastKnownPosHandler::NotifyOnEmptyLastKnownPosStoreReq()

	{

	// Complete all the requests on the queue with KErrCancel

	QRequestsComplete(KErrCancel);

	if (iStatus==KRequestPending)

		{

		Cancel();

		}

	}

TInt CPosLastKnownPosHandler::HandleTimeOut(TAny* aRequestHandler)

    {

    DEBUG_TRACE("CPosLastKnownPosHandler::HandleTimeOut()", __LINE__)    

    CPosLastKnownPosHandler* self = reinterpret_cast<CPosLastKnownPosHandler*>(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;

    }