// Copyright (c) 2008-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:
//

/**
 @file
 @InternalComponent
*/

#include <e32base.h>
#include <lbs/epos_mpositionerstatus.h>
#include <ecom/implementationproxy.h>
#include <lbssatellite.h>
#include <lbs/lbsadmin.h>

#include "cagpspositioner.h"
#include "agpspsy.hrh"
#include "agpspsypanic.h"
#include "cpositionerq.h"
#include "crequesthandler.h"
#include "cagpsenvironment.h"
#include "utilfunctions.h"
#include "tagpsrequestparameters.h"
#include "agpsrequestconstants.h"
#include "psylogging.h"
#include "psypanic.h"

/*
* 
*/
CAgpsPositioner::CAgpsPositioner()
    {
	iState = ERequestStateInitial;
	iTerminalAssisted = EFalse;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CAgpsPositioner::~CAgpsPositioner()
    {
	TRACESTRING("CAgpsPositioner::~CAgpsPositioner")

	if(iEnvironment)
		{
		iEnvironment->UnregisterPSY(this);
		}
	
	iNetRegStatus.Close();
    }

/**
 * Creates a new instance of a CPositioner implementation.
 *
 * @param aConstructionParameters Construction parameters for CPositioner.
 * @return The positioner implementation.
 */
CAgpsPositioner* CAgpsPositioner::NewL(TAny* aConstructionParameters)
    {
    CAgpsPositioner* self = new( ELeave ) CAgpsPositioner;

    CleanupStack::PushL( self );
    self->ConstructL(aConstructionParameters);
    CleanupStack::Pop(self);

    return self;
    }

/**
 * 2nd phase constructor
 *
 * @param aConstructionParameters Construction parameters for CPositioner.
 */
void CAgpsPositioner::ConstructL(TAny* aConstructionParameters)
	{
	TRACESTRING("CAgpsPositioner::ConstructL")

	// Must call BaseConstructL first thing during construction.
	BaseConstructL(aConstructionParameters);

	iEnvironment = CAgpsEnvironment::NewL();
	iEnvironment->RegisterPSYL(this);
	iEnvironment->GetEnvCriteriaL(iCriteria, TUid::Uid(KPosAGPSPSYImplUid));
	iInactivityTimeout = iEnvironment->GetInactivityTimeoutL(TUid::Uid(KPosAGPSPSYImplUid));
	iRequestHandler = iEnvironment->GetRequestHandler();

	// Get the request timeout from the LS:
	if(iEnvironment->ProfileInUse())	// default timeout was taken from profile, so let LS know
		{
		TPositionQuality quality;
		iCriteria.GetRequiredQuality(quality);
		iTimeOutInterval = quality.TimeToFirstFix();	
		SetPsyDefaultUpdateTimeOut(iTimeOutInterval);
		}	    

	iNetRegStatus.OpenL();
	}

/**
* Initiate a tracking session.
*
* @param aInterval Interval for position requests.
*/
void CAgpsPositioner::StartTrackingL(const TTimeIntervalMicroSeconds& aInterval)
    {
	TRACESTRING2("CAdaptationPositioner::StartTrackingL, interval = %d", aInterval)

	TTime timeNow;
    
    TTime trackingTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(iTargetTime, aInterval);
	timeNow.UniversalTime();
    
	iTrackingInterval = aInterval;
	    
    if(! (trackingTime < timeNow)) // if this is not a default proxy call to StartTracking
	    {
    	TRACESTRING("Non-DefProxy Start")
	    SetupTrackingRequestL();
        SetAGPSMode();
		iRequestHandler->SubmitNewRequestL(this);
	    }
    }
    
/**
* Requests position info asynchronously. 
*
* @param aPosInfo A reference to a position info object. This object
*                 must be in scope until the request has completed.
*                 The position (TPosition) of this position info object
*                 must be in WGS84 geodetic datum.
* @param aClientStatus The request status
*
*/
void CAgpsPositioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aClientStatus)
    {
    TRACESTRING("CAdaptationPositioner::NotifyPositionUpdate")

	// we're about to submit a new request, so stop warmdown timer if running: 
	StopMaxFixTimer();
    StopWarmDownTimer();
	
    // Clear position info
    ClearPositionInfo(aPosInfo);
    
    aClientStatus = KRequestPending;
    iPosInfo = &aPosInfo;
    iClientStatus = &aClientStatus;
    
    if(!UseLastLocation(aPosInfo)) // Attempt to complete the client immediately with an old position
		{
		TTime timeNow;
		timeNow.UniversalTime();
	    iActive = ETrue;
	
		GetUpdateTimeOut(iTimeOutInterval);

		TDateTime debugTime = timeNow.DateTime();
		TRACESTRING38("Time Now = %d.%d", debugTime.Second(), debugTime.MicroSecond());
		
		// Add on the lag time
		if(iTerminalAssisted)
			{
        	CAgpsEnvironment* agpsEnvironment = static_cast<CAgpsEnvironment*>(iEnvironment);
        	ExtendUpdateTimeOut(agpsEnvironment->GetFinalNetPositionLag());
			}
				
		if( !IsTracking() ||
			(IsTracking() && (iTargetTime <= timeNow)) )
			{
			iTargetTime.UniversalTime();
	        TRACESTRING("CAdaptationPositioner::NotifyPositionUpdate submitting new request")

	        SetAGPSMode();
	        
	        // (re)start maxfix timer so that we know when the module has stopped trying	        
	        TRAPD(error,StartMaxFixTimerL());	 
	        if(!error)
	        	{
	        	TRAP(error, iRequestHandler->SubmitNewRequestL(this));
	        	}
	        if(error)
		        {
				UpdateFailed(error);
		        }
			}
			
		debugTime = iTargetTime.DateTime();
		TRACESTRING38("Target Time = %d.%d", debugTime.Second(), debugTime.MicroSecond());
		}
    }


void CAgpsPositioner::SetModuleId(TPositionInfoBase* aPosInfo)
	{
	if(aPosInfo)
		{
		aPosInfo->SetModuleId(TUid::Uid(KPosAGPSPSYImplUid)); // Use the PSY module Id rather than the AGPS managers
		}
	}

const TRequestParameters* CAgpsPositioner::PositionRequestParams()
	{
	TBool state = (iState == ERequestStateInitial);
	
	iRequestParameters.iTargetTime = iTargetTime;
	iRequestParameters.iTimeForFix = iTimeOutInterval;
	iRequestParameters.iCriteria = iCriteria;
	iRequestParameters.iNewClient = state;
	iRequestParameters.iTracking = IsTracking();
	iRequestParameters.iAGPSMode = iAGPSMode;
	
	return &iRequestParameters;
	}
	
/**
* Checks for a transition into TA mode and extends the max fix time to allow for 
* the final network position arriving  
*
* @param aMode The mode of the last update.
*
*/
void CAgpsPositioner::ModeUpdate(TUint aMode)
	{
    TRACESTRING("CPositionerSubSession::CheckMode()")

	if ( ((aMode & RLbsPositionUpdates::EGpsModeTerminalAssisted) == RLbsPositionUpdates::EGpsModeTerminalAssisted) 
		&& !iTerminalAssisted )
		{
		iTerminalAssisted = ETrue;
		CAgpsEnvironment* agpsEnvironment = static_cast<CAgpsEnvironment*>(iEnvironment);
		ExtendUpdateTimeOut(agpsEnvironment->GetFinalNetPositionLag());
		}
	else if (((aMode & RLbsPositionUpdates::EGpsModeTerminalAssisted) != RLbsPositionUpdates::EGpsModeTerminalAssisted))
		{
		iTerminalAssisted = EFalse;
		}
	}

void CAgpsPositioner::SetAGPSMode()
	{
    TRACESTRING("CPositionerSubSession::GpsMode()")
	
    CLbsAdmin::TGpsMode mode = CLbsAdmin::EGpsModeUnknown;
	iAGPSMode = KAutonomousMode;
	
	RLbsNetworkRegistrationStatus::TLbsNetworkRegistrationStatus netRegStatus(RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown);
	
	// Read the current network registration status
	TInt err = iNetRegStatus.GetNetworkRegistrationStatus(netRegStatus);

	if (err == KErrNone)
		{
		// Read the admin setting
		switch (netRegStatus)
			{
			case RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork:
				{
				err = iEnvironment->Admin().Get(KLbsSettingHomeGpsMode, mode);
				break;
				}
			case RLbsNetworkRegistrationStatus::ERegisteredRoamingNetwork:
			case RLbsNetworkRegistrationStatus::ENotRegistered:
				{
				err = iEnvironment->Admin().Get(KLbsSettingRoamingGpsMode, mode);
				break;
				}		
			case RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown:
			default:
				{
				TRACESTRING("Unrecognised TLbsNetworkRegistrationStatus")
				break;
				}
			}
		
		// Convert to internal mode
		switch (mode)
			{
			case CLbsAdmin::EGpsPreferTerminalBased:
			case CLbsAdmin::EGpsAlwaysTerminalBased:
				iAGPSMode = KTerminalBasedMode;
			break;
			
			case CLbsAdmin::EGpsPreferTerminalAssisted:
			case CLbsAdmin::EGpsAlwaysTerminalAssisted:
				iAGPSMode = KTerminalAssistedMode;
			break;
			
			case CLbsAdmin::EGpsModeUnknown:
				__ASSERT_DEBUG(EFalse,User::Panic(KAdaptationPanicCategory, KErrArgument));
			break;
			
			case CLbsAdmin::EGpsAutonomous:
			default:
				iAGPSMode = KAutonomousMode;
			break;
			}
		}
	}

//  End of File