// 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:

// Definition of main logoc of agps manager

// 

//

/**

 @file

 @internalTechnology

*/

#ifndef MAINLOGIC_H

#define MAINLOGIC_H

#include <e32base.h>

#include <lbs.h>

#include <lbs/lbsextendedsatellite.h>

#include <lbs/lbsassistancedatabase.h>

#include <lbs/lbslocdatasourcegpsbase.h>

#include <lbs/epos_intgpshwstatus.h>

#include "LbsInternalInterface.h"

#include "lbscommoninternaldatatypes.h"

#include "lbsrootapi.h"

#include "lbsprocesssupervisor.h"

#include "lbstimer.h"

#include "lbslocationrequesthandler.h"

#include "lbsassistancedatacacheapi.h"

#include "lbsnetworkgatewayhandler.h"

#include "cquietus.h"

#include "lbsautoclockadjust.h"

#include "lbsearlycompletionupdatehandler.h"

#include "LbsLogger.h"

#include "lbsnetregstatusint.h"

#if defined(_DEBUG)

#include "LbsOomListener.h"

#endif

class CLbsAdmin;

const TPositionModuleId KSirfModuleId= {0x10282249}; // Ecom plugin implementation Id

//************************************************************************************************************

//	CManagerMainLogic

//************************************************************************************************************

class CManagerMainLogic :	public CBase,

							public MLbsLocationSourceGpsObserver,

							public MLbsCallbackTimerObserver,

							public MLocationRequestHandlerObserver,

							public MNetworkGatewayHandlerObserver,

							public MLbsProcessCloseDown,

							public MLbsEarlyCompletionUpdateObserver

	{

public:

	static CManagerMainLogic* NewL();

	~CManagerMainLogic();

public:

	enum TLocReqStatus

		{

		EReqNone 			 = 0,

		EReqReceived 		 = 1,

		EReqSessionStarted 	 = 2,

		EReqReceivedDuringSession = 3,

		EReqSessionCompleted = 4

		};

	class TSessionClosureData

		{

	public:

		TInt iLastStatus;

		TPositionExtendedSatelliteInfo iLastPosInfo;

		TTime iLastTargetTime;

		TBool iNotify;

		};

public:

	// from MLbsLocationSourceGpsObserver

	TVersion Version();

	void UpdateLocation(TInt aStatus, const TPositionInfoBase* aPosition[], TInt aNumItems, const TTime& aTargetTime);

	void UpdateDeviceStatus(TPositionModuleStatus::TDeviceStatus aDeviceStatus);

	void UpdateDataQualityStatus(TPositionModuleStatus::TDataQualityStatus aDataQuality);

	TInt GetAssistanceDataItem(TLbsAssistanceDataItem aItem, RDataReaderRootBase& aDataRoot, TTime& aTimeStamp);

	TInt GetAssistanceDataItemTimeStamp(TLbsAssistanceDataItem aItem, TTime& aTimeStamp);

	void RequestAssistanceData(TLbsAsistanceDataGroup aDataItemMask);

	void Shutdown();

	void NotifyServiceToClose(TRequestStatus* aStatus);

	// from MLocationRequestHandlerObserver

	void OnLocationRequestStateChanged(const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel,const TRequestStateChangeReason& aReason);

	void OnSystemStatusAdvice(const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel, TBool aTracking);

	void OnPowerModeAdvice(const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel, CLbsLocationSourceGpsBase::TPowerMode& aPowerMode);

	// from MNetworkGatewayHandlerObserver

	void OnAssistanceDataResponse(TInt aError, TLbsAsistanceDataGroup aMask);

    void OnSessionComplete(TInt aReason, const TLbsNetSessionIdInt& aSessionId);

	// from MLbsCloseDownObserver

	void OnProcessCloseDown();

	// from MLbsCallbackTimerObserver

	virtual void OnTimerEventL(TInt aTimerId);

	virtual TInt OnTimerError(TInt aTimerId, TInt aError);

	// from MLbsEarlyCompletionUpdateObserver

	virtual void EarlyCompletionUpdate(TPositionInfo& aEarlyCompletionUpdate, TTime& aTargetTime, TTime& aActualTime);

private:

	CManagerMainLogic();

	void ConstructL();

	void CombineLocationRequests(const TUid& aOriginatingChannel, const TRequestStateChangeReason& aOriginatorReason = EReasonNone);

	void ConfigureGpsMode(const TUid& aChannelId, const TRequestStateChangeReason& aReason);

	void GetTimeAndQuality(const CLocationRequestHandler& aRequestHandler, TTime& aStartTime, TLbsLocRequestQualityInt& aQuality);

	TPositionModuleInfo::TTechnologyType GetTechnologyTypeFromNrhRequest(const TInt& aIndex);

	TPositionModuleInfo::TTechnologyType GetTechnologyTypeFromLsRequest(const TInt& aIndex);

	void RestartTimerIfTracking();

	void SendSystemStatusAdvice(TBool aTracking);

	void GetFinalNetPositionLagFromAdminProfileL();	

	void SetGpsOptions(const TPositionModuleInfo::TTechnologyType aNewPositioningMethod);

	TBool IsUpdateAsExpected(const TPositionInfoBase* aPosInfoArray[],const TInt& aNumItems, TInt& aPositionCalculationIndex, TInt& aMeasurementIndex);

	void GetGpsUpdateIndexes(const TPositionInfoBase* aPosInfoArray[], const TInt& aNumItems, TInt& aPositionCalculationIndex, TInt& aMeasurementIndex);

	void PublishDummyPosition(TInt aReason);

	void PublishDummyAssistDataEvent(TInt aReason);

	void ConvertToTLbsLocRequestQuality(const TLbsLocRequestQualityInt& aSource, TLbsLocRequestQuality& aDest) const;

	void GetTaGpsModeFromAdmin(CLbsAdmin::TGpsMode& aGpsMode);

	TPositionModuleInfo::TTechnologyType CalculatePositioningMethod();

	TPositionModuleInfo::TTechnologyType LookUpPositioningMethodInCombinationTables();

	void CalculateActiveLSMode(const TUid& aChannelId, const TRequestStateChangeReason& aReason, TBool& aForceSelfLocate);

private:

	TBool iClosingDown;

	CLbsCloseDownRequestDetector*	iCloseDownRequestDetector;

	CQuietus*					iQuietus;

	CLbsLocationSourceGpsBase*	iLocationSource;

	CNetworkGatewayHandler*		iNetworkGatewayHandler;

	CLocationRequestHandler*	iNRHLocationRequestHandler;

	CLocationRequestHandler*	iLocSvrLocationRequestHandler;

	CEarlyCompletionUpdateHandler* iEarlyCompletionUpdateHandler;

	CLbsCallbackTimer*			iTimer;

	CAutoClockAdjust*			iAutoClockAdjust;

	RLbsPositionUpdates 		iPositionUpdates;// For publishing position updates for Loc Server and NRH.

	RLbsGpsMeasurementUpdates	iMeasurementUpdates;

	RLbsModuleStatus			iModuleStatus;

	TLocReqStatus				iLSReqState;

	TBool       				iIsNrhCancelDue; // A NRH request must be cancelled even if it has timed out

	TLbsNetSessionIdInt			iSessionId;

	TBool						iLastTrackingFlagSentToNG;

	TBool						iTrackingStateUnknown;

	// LBSLogging

	RLbsLogger					iLogger;

	TLbsAsistanceDataGroup		iLogAssitaceDataGroup;

	// Position update cache (for republishing in some scenarios only)

	TSessionClosureData         iSessionClosureData;

	TTimeIntervalMicroSeconds 	iFinalNetPositionLag;	

	CLbsAdmin*                  iAdmin;

	//Stores the last power advice recieved

	CLbsLocationSourceGpsBase::TPowerMode iPowerModeLS;

	CLbsLocationSourceGpsBase::TPowerMode iPowerModeNRH;

	// the current behaviour mode of Lbs

	CLbsAdmin::TLbsBehaviourMode iLbsBehaviourMode;

	// Capabilities of underlying GPS hardware regarding

	// positioning methods it supports

	TPositionModuleInfoExtended::TDeviceGpsModeCapabilities iCapabilities;

	RLbsNetworkRegistrationStatus iNetRegStatus;

	// Positioning method used last to configure GPS options

	TPositionModuleInfo::TTechnologyType iCurrentPositioningMethod;

	// Positioning method last used to configure the GPS module

	// options due to a Location Request from the Location server.

	// It is set to KLbsMethodNone when the Location server reques goes inactive.

	TPositionModuleInfo::TTechnologyType iActiveLSMode;

	// Positioning method last sent to the Network Gateway in

	// a SelfLocateRequest. It is set to KLbsMethodNone

	// when self location session terminates.

	TPositionModuleInfo::TTechnologyType iCurrentNetworkMode;

    #if defined(_DEBUG)

		CLbsOomListener*	iOomListener;

    #endif	

	// Flag which gets set when in Prefer Terminal Assisted and there is 

	// an error from the network. This flag is needed because the AGPS manager 

	// always ensures positions/measurements are returned correctly. So it 

	// would typically wait for measurements when in PTA. But in the case 

	// of a fatal network error the module can fall-back to Autonomous. In that 

	// case the PTA mode is set and positions are returned. So we need this 

	// flag to know when we can accept positions in PTA.

	TBool iFallbackFromPTAToAutonomousPossible;

	// Flag that specifies if currently gps timing of cell frames is requested 

	TBool iCurrentGpsTimingOfCellFramesRequested;

	CPosIntGpsHwStatus* 	iPosIntGpsHwStatus;

	};

#endif //MAINLOGIC_H