/*

* Copyright (c) 2008 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:  Implementation of coordinate supervisor class

*

*/

#include <e32math.h>

#include <e32const.h>

#include <lbttriggerconditionarea.h>

#include <lbtgeocircle.h>

#include "lbtcelliddatabase.h"

#include "lbtcellchangehandler.h"

#include "lbtlogger.h"

#include "lbtcoordinatesupervisor.h"

#include "lbtstrategyengineobserver.h"

#include "lbtpsychangelistner.h"

// ==================== CONSTANTS ===================================

/**

 * Constant used to adjust trigger radius to accomodate inaccuracy 

 * of position fixes

 */

static const TReal32 KAccuracyMultiplier = 0.666667;

/**

 * The cut off value of the ratio of radius to position accuracy. Over this 

 * value the radius of a trigger will not be expanded.

 */

static const TReal32 KCofftOfHighEdgeLimit = 1.5;

/**

 * Constant used in calculation of trigger hysteresis

 */

static const TUint16 KTriggerRadiusCutoff = 500;

/**

 *  Contant time use in calculation of speed

 */

static const TReal32 constantTime = 20;

/**

 * Defines the number of historic speed values that will be stored

 * and used for calculation of current speed

 */

static const TUint16 maxObsValues = 10;

/**

 * Minimum calculated speed. If this calculated speed drops below this value

 * then the below value is speed as the speed value 

 */

static const TReal KMinProjSpeed = 20.0;

static const TReal KMaxSpeedToUseMvmtDet = 5.0;

/**

 * If the estimated sleep interval goes below this value then location request

 * will be issued immediately with the estimated interval as the time out value

 * for the location rquest

 */

static const TInt KMinSleepInterval = 2;

/**

 * Multiplier used for 10 power 3. Used for conversion of seconds to micro

 * seconds

 */

static const TUint KMicroMultiplier = 1000000;

/**

 * Number of seconds to sleep before making location request in cases where 

 * a location acquisition attempt fails to obtain a fix

 */

static const TUint KSleepTimeOnLocAcqFailure = 10; // 10 seconds

/**

 * Safe range of HA obtained from NPP

 */

//static const TUint KNppSafeHA = 1500; // 1500 meters

// ============================== MEMBER FUNCTIONS ============================================

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::NewL

// CLbtCoOrdinateSupervisor instantiation method

// -----------------------------------------------------------------------------

//

CLbtCoOrdinateSupervisor* CLbtCoOrdinateSupervisor::NewL( TAny* aConstructionParameters, 

                                                          CLbtTriggerView* aView,

                                                          MLbtStrategyEngineObsrvr* aObserver,

                                                          CLbtCellChangeHandler* aCellChangeHandler )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aConstructionParameters, aView,aObserver,aCellChangeHandler );

    CleanupStack::Pop();

    return self;    

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::~CLbtCoOrdinateSupervisor

// Default destructor

// -----------------------------------------------------------------------------

//

CLbtCoOrdinateSupervisor::~CLbtCoOrdinateSupervisor()

    {

    // This is just done as a precautionary measure!

    StopSupervision();

    delete iLocationRequestor;

    delete iStatusManager;

    delete iTimer;

    delete iPsyChangeListner;

    delete iCellIdDatabase;

    iNObservedValues.Close();

    iNearestTriggers.Close();

    }	

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::StartSupervision

// 

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::StartSupervision()

    {

    FUNC_ENTER("CLbtCoOrdinateSupervisor::StartSupervision");

    iCellChangeHandler->SetObserver( this );    

    RequestTerminalPosition( iSettings.iLocationRequestTimeout );    

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::StopSupervision

// 

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::StopSupervision()

    {

    FUNC_ENTER("CLbtCoOrdinateSupervisor::StopSupervision");

    iCellChangeHandler->Remove( this );

    Term(); 

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::SettingsChanged

// Handles notification of triggering settings change provided by server

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::SettingsChanged()

    {    

    iEngObserver->RetrieveTriggeringSettings( iSettings );    

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::Resume

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::Resume()

    {

    FUNC_ENTER("CLbtCoOrdinateSupervisor::Resume");

    TInt err = KErrNone;

    iCellChangeHandler->SetObserver( this );    

    switch( iProjectedState )

            {

        case ELocationAcquisition:

            iProjectedState = EIdle;

            RequestTerminalPosition( iSettings.iLocationRequestTimeout );

            break;

        case ETriggerEvaluation:

            // Reset trigger iterator and start evaluation of all triggers in

            // view            

            iProjectedState = EIdle;

            err = ResetViewIterator();

            if( KErrNone != err )

                {

                return;

                }

            iState = ETriggerEvaluation;

            SetEvent();

            break;

        case EUpdateIntervalEstimation:

            // Evaluate triggers that have undergone changes during the state

            // change. This is to determine any new nearest trigger

            iProjectedState = EIdle;

            iView->DetermineNearestTriggerChanges( &iNearestTriggers );

            if( iNearestTriggers.Count() == 0 )

                {

                // This means all known nearest triggers have been modified. 

                // Reset iterator re-evaluate all triggers in the system. 

                TInt err = ResetViewIterator();

                if( KErrNone != err )

                    {

                    return;

                    }

                iState = ETriggerEvaluation;

                SetEvent();

                }

            else

                {

                // Evaluate only the modified triggers

                TBool makeLocReq = EFalse;

                TRAP( err, makeLocReq = EvaluateModifiedTriggersL() );

                if( KErrNone == err )

                    {

                    if( makeLocReq )

                    	{

                    	// Location request is needed based on evaluating

            			// modified triggers

                    	RequestTerminalPosition( iSettings.iLocationRequestTimeout );

                    	return;

                    	}

                    // Switch to estimation of update interval

                    iState = EUpdateIntervalEstimation;

                    SetEvent();

                    }

                else

                    {

                    Term();

                    }

                }

            break;

        case ESleep:

            iProjectedState = EIdle;

            iState = ESleep;

            SetEvent();

            break;

        case EIdle:

            if( EIdle == iState && EIdle == iProjectedState

                           && iView->CoordTriggerCount() )

                {

                RequestTerminalPosition( iSettings.iLocationRequestTimeout );

                }

            break;

        default:

            break;

            }

     }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::Suspend

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::Suspend()

    {

    FUNC_ENTER("CLbtCoOrdinateSupervisor::Suspend");

    iCellChangeHandler->Remove( this );

    switch( iState )

        {

    case ELocationAcquisition:

    	if( iLastLocationFixType == EProperFix )

    		{

    		iLocationRequestor->Cancel();

    		}

    	else

    		{

    		iLocationRequestor->CancelFixFromNpp();

    		}

        iProjectedState = iState;

        iState = EIdle;

        break;

    case ETriggerEvaluation:

        iProjectedState = ETriggerEvaluation;

        iState = EIdle;

        break;

    case EUpdateIntervalEstimation:

        iProjectedState = EUpdateIntervalEstimation;

        iState = EIdle;

        break;

    case ESleep:

        iTimer->Cancel();

        iProjectedState = iState;

        iState = EIdle;

    case EIdle:

        break;

    default:

        break;

        }

    Cancel();

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::Reset

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::Reset()

    {

    iState = iProjectedState = EIdle;

    iNearestTriggers.Reset();

    iLocReqCount = 0;

    TPositionInfo posInfo;

    iPosInfo = posInfo;

    iFixForFiringCloseTriggers = EFalse;

    }

// -----------------------------------------------------------------------------

// CLbtCoOrdinateSupervisor::GetPositionInfo

// Processes the location information obtained from location requestor

// -----------------------------------------------------------------------------

//

void CLbtCoOrdinateSupervisor::GetPositionInfoL()

    {

    FUNC_ENTER("CLbtCoOrdinateSupervisor::GetPositionInfo");

    // Update location acquisition status information

    if( !( (KErrNone == iStatus.Int()) ||

    	   (KPositionQualityLoss == iStatus.Int()) ) )

    	{

    	ERROR("Position Information with : %d",iStatus.Int());

    	iStatusManager->ReportLocationAcquisitionStatus( iStatus.Int() );

    	// The following check determines if there was a problem using the 

    	// specified positioning technology to retrieve position information

    	if( KErrNotFound == iStatus.Int() &&

    	    iLastLocationFixType == EProperFix )

    	    {

    	    LOG("Specified PSY not found");

    	    iAcquisitionStatus = ELocationAcquisitionNoMethod;

    	    if( iPsyChangeListner == NULL )

    	        {

    	        iPsyChangeListner = CLbtPsyChangeListner::NewL( *this );

    	        }

    	    iPsyChangeListner->StartToListen( iModuleId );

    	    LOG1("Listen to PSY change:%x",iModuleId);

    	    TUid defaultID = { 0XFFFFFFFF };

    	    if( iLocationRequestor->GetPositionModuleId() != defaultID )

    	        {

    	        LOG("Use default proxy");

    	        // switch to using default positioning technology

    	        iModuleId = defaultID;

    	        RequestTerminalPosition( iSettings.iLocationRequestTimeout,EProperFix );   

    	        }

    	    }

    	else

    	    {

    	    LOG("Location acquisition failed");

    	    if( iFixForFiringCloseTriggers && 

    	        (KErrTimedOut == iStatus.Int())&&

    	        iLastLocationFixType == EProperFix )

    	        {

    	        LOG("Firing Close triggers");

                FireClosestTriggers();                

                RequestTerminalPosition(iSettings.iLocationRequestTimeout, EProperFix);

                }

            else

                {

                if( iLastLocationFixType == EProperFix )

                    {

                    // Get fix from NPP PSY

                    LOG("Timed Out. Taking fix from NPP");

                    RequestTerminalPosition( iSettings.iLocationRequestTimeout, EFixFromNpp );

                    return;

                    /*

                    iState = ESleep;

                    iTimer->Set( iStatus, KSleepTimeOnLocAcqFailure, ETrue );               

                    SetActive();

                    if( KErrAccessDenied == iStatus.Int() )

                        {

                        iAcquisitionStatus = ELocationAcquisitionPrivacyReject;

                        }

                    else 

                        {

                        iAcquisitionStatus = ELocationAcquisitionFailure;

                        }*/

                    }

                else

                    {

                    LOG("Npp psy failed to provide fix. Sleep now");

                    iState = ESleep;

                    iTimer->Set( iStatus, KSleepTimeOnLocAcqFailure, ETrue );               

                    SetActive();

                    if( KErrAccessDenied == iStatus.Int() )

                        {

                        iAcquisitionStatus = ELocationAcquisitionPrivacyReject;

                        }

                    else 

                        {

                        iAcquisitionStatus = ELocationAcquisitionFailure;

                        }

                    }

                }

    	    }

    	if( iFixForFiringCloseTriggers )

    	    {

    	    iFixForFiringCloseTriggers = EFalse;

    	    }

    	// Update supervision dynamic info to the strategy class

        TLbtStrategySupervisionDynamicInfo supervisionDynamicInfo;

        supervisionDynamicInfo.iDistanceToNearestTrigger = 0.0;

        supervisionDynamicInfo.iLatestAcquiredPosInfo = iPosInfo;

        supervisionDynamicInfo.iLocationAcquisitionStatus = iAcquisitionStatus;

        supervisionDynamicInfo.iNearestTriggerId = 0;

        iEngObserver->ReportTriggeringSupervisionStatus( supervisionDynamicInfo );    

    	return;

    	}

	if( iStatus.Int() == KPositionQualityLoss )

		{

		TPosition currentPosition;

		iPosInfo.GetPosition( currentPosition );

		LOG("Received KPositionQualityLoss");

		LOG1("Lat:%f",currentPosition.Latitude());

		LOG1("Long:%f",currentPosition.Longitude());

		LOG1("HA:%f",currentPosition.HorizontalAccuracy());

		}

    iStatusManager->ReportLocationAcquisitionStatus( KErrNone );

    // The fix was taken to fire nearest triggers then reset the flag

    // to EFalse since the fix was successful and the nearest triggers will be

    // evaluated and will be fired

    if(iFixForFiringCloseTriggers)

        {

        iFixForFiringCloseTriggers = EFalse;

        }

    TPosition currentPosition, prevPosition;

    iPosInfo.GetPosition( currentPosition );

    iPrevPosInfo.GetPosition( prevPosition );

    if( Math::IsNaN( currentPosition.Latitude() ) || 

        Math::IsNaN( currentPosition.Longitude() ) )

    	{

    	LOG("ERROR:Lat/Long is Nan. Sleep now");

    	iState = ESleep;

        iTimer->Set( iStatus, KSleepTimeOnLocAcqFailure, ETrue );               

        SetActive();

        if( KErrAccessDenied == iStatus.Int() )

            {

            iAcquisitionStatus = ELocationAcquisitionPrivacyReject;

            }

        else 

            {

            iAcquisitionStatus = ELocationAcquisitionFailure;

            }

    	return;

    	}

    // Record the time at which we got the fix

    iLastFixTime.UniversalTime();

    // Take note of reference time that would be used during estimation of 

    // sleep interval

    iAcquisitionStatus = ELocationAcquisitionActive;

    iLocReqCount++;

    iLocationRequestor->GetModuleInfo( iPosInfo.ModuleId() );    

    if( iLocArea.iCellId && iLastCellRequestStatus == KErrNone )

        {

        LOG("Writing position to DB");

        LOG1("Cell Id = %d", iLocArea.iCellId );

        LOG1("LAC = %d", iLocArea.iLocationAreaCode );

        // Add current cell id position to cell-id database

        TInt countryCode,networkCode;

        TLex lex( iNwInfo.iCountryCode );

        lex.Val( countryCode );

        lex.Assign( iNwInfo.iNetworkId );

        lex.Val( networkCode );

        TPosition cellPosition;

        iPosInfo.GetPosition( cellPosition );

        if( iLastLocationFixType == EProperFix )

            {

            cellPosition.SetHorizontalAccuracy( 3000 );

            }

        iCellIdDatabase->InsertCidLocation( countryCode,

                                            networkCode,

                                            iLocArea.iLocationAreaCode,

                                            iLocArea.iCellId,

                                            cellPosition );

        }

    // Check if there is no movement from last location fix. If true then 

    // re-evaluate sleep interval

    TReal32 dist;

    currentPosition.Distance( prevPosition, dist );

    if( dist == 0 )

        {

        iState = EUpdateIntervalEstimation;

        SetEvent();

        }