/*

* 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:  A class for recording and storing locations.

*

*/

#include <e32cmn.h> 

#include <lbserrors.h>

#include <lbssatellite.h>

#include "rlocationtrail.h"

#include "clocationrecord.h"

#include "cnetworkinfo.h"

#include "locationmanagerdebug.h"

#include "locationtraildefs.h"

#include "locationtrailpskeys.h"

#include "mdeconstants.h"

#include <centralrepository.h>

using namespace MdeConstants;

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

// CLocationRecord::NewL

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

//

EXPORT_C CLocationRecord* CLocationRecord::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CLocationRecord::CLocationRecord

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

//  

CLocationRecord::CLocationRecord()

    : iNetworkInfoTimer( NULL ),

    iState( RLocationTrail::ETrailStopped ),

    iTrailCaptureSetting( RLocationTrail::ECaptureAll ),

    iLocationCounter( 0 ),

    iRequestCurrentLoc( EFalse ),

    iTrailStarted( EFalse ),

    iLastGPSFixState( EFalse ),

    iLastLocationId( 0 )

    {

    iMaxTrailSize = KMaxTrailLength / KUpdateInterval;

    }

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

// CLocationRecord::ConstructL

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

//    

void CLocationRecord::ConstructL()

    {

    const TInt KMillion = 1000000;

    TInt err = iProperty.Define( KPSUidLocationTrail, KLocationTrailState, RProperty::EInt );

    if ( err != KErrNone && err != KErrAlreadyExists )

        {

        User::Leave( err );

        }

    User::LeaveIfError( iProperty.Set( KPSUidLocationTrail,

        KLocationTrailState, (TInt) RLocationTrail::ETrailStopped ) ); 

    iNetworkInfo = CNetworkInfo::NewL( this );

    iPositionInfo = CPositionInfo::NewL( this );

	iRemapper = CLocationRemappingAO::NewL();

    iNetworkInfoTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    TInt interval( 0 );

    TRAP(err, ReadCenRepValueL(KIntervalKey, interval));

    LOG1("CLocationManagerServer::ConstructL, cenrep interval value:%d", interval);

    if (interval == 0 || err != KErrNone )

    	{

        LOG1("CLocationManagerServer::ConstructL, cenrep interval err:%d", err);

    	iInterval = KUpdateInterval;

    	}

    else 

    	{

    	iInterval = interval * KMillion;

    	}

    TRAP(err, ReadCenRepValueL(KLocationDeltaKey, iLocationDelta));

    LOG1("CLocationManagerServer::ConstructL, location delta value:%d", iLocationDelta);

    if (iLocationDelta == 0)

    	{

        LOG1("CLocationManagerServer::ConstructL, location delta err:%d", err);

        iLocationDelta = KLocationDelta;

    	}

    }

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

// CLocationRecord::~CLocationRecord

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

//    

EXPORT_C CLocationRecord::~CLocationRecord()

    {

    Stop();

    iProperty.Delete( KPSUidLocationTrail, KLocationTrailState );

    iProperty.Close();

    iTrail.Close();

    delete iNetworkInfo;

    delete iPositionInfo;

    delete iNetworkInfoTimer;

	if (iRemapper)

		{

		iRemapper->StopRemapping();

		delete iRemapper;

		}

    }

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

// CLocationRecord::CurrentState

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

//

EXPORT_C void CLocationRecord::LocationTrailState( TLocTrailState& aState )

    {

    aState = iState;

    }

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

// CLocationRecord::StartL

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

//

EXPORT_C void CLocationRecord::StartL( RLocationTrail::TTrailCaptureSetting aCaptureSetting )

    {

    LOG( "CLocationRecord::StartL(), begin" );

    iTrailCaptureSetting = aCaptureSetting;

    if ( aCaptureSetting == RLocationTrail::ECaptureAll && !iPositionInfo->IsActive() )

        {

        if( iState == RLocationTrail::ETrailStopped  )

            {

            iTrail.Reset();

            }

        iPositionInfo->StartL( aCaptureSetting, iInterval );

        }

    else if ( aCaptureSetting == RLocationTrail::ECaptureNetworkInfo )

    	{

    	// Update and store network info in location trail immediately.

    	// Timer will trigger the update again later.

    	UpdateNetworkInfo( this );

        if ( iNetworkInfoTimer && iNetworkInfoTimer->IsActive() )

        	{

        	iNetworkInfoTimer->Cancel();

        	}

        StartTimerL();

    	}

    iLastLocationId = 0;

    SetCurrentState( RLocationTrail::ETrailStarting );

    iTrailStarted = ETrue;

    LOG( "CLocationRecord::StartL(), end" );

    }

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

// CLocationRecord::Stop

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

//

EXPORT_C void CLocationRecord::Stop()

    {

    LOG( "CLocationRecord::StopL(), begin" );

    iPositionInfo->Stop();

    iTrailStarted = EFalse;

    if ( iNetworkInfoTimer && iNetworkInfoTimer->IsActive() )

    	{

    	iNetworkInfoTimer->Cancel();

    	}

    if ( iRemapper )

    	{

    	iRemapper->ResetQueue();

    	}

    SetCurrentState( RLocationTrail::ETrailStopped );

    LOG( "CLocationRecord::StopL(), end" );

    }

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

// CLocationRecord::SetStateToStop

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

//

EXPORT_C void CLocationRecord::SetStateToStopping()

	{

	SetCurrentState( RLocationTrail::ETrailStopping );

	}

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

// CLocationRecord::GetLocationByTimeL

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

//

EXPORT_C void CLocationRecord::GetLocationByTimeL( const TTime aTime, 

												   TLocationData& aLocationData,

    {

    LOG( "CLocationRecord::GetLocationByTimeL(), begin" );

    TInt posFound( EFalse );

#ifdef _DEBUG

    _LIT( KDateTimeFormat, "%Y/%M/%D %H:%T:%S" );

    const TInt DateTimeStrMaxLength = 20;

    LOG1( "CLocationRecord::GetLocationByTimeL - aTime: %Ld", aTime.Int64() );

    TBuf<DateTimeStrMaxLength> str1;

    aTime.FormatL( str1, KDateTimeFormat );

    LOG1( "CLocationRecord::GetLocationByTimeL - aTime: %S", &str1 );

#endif

    TTimeIntervalSeconds interval;

    TTimeIntervalSeconds nextInterval;

    for ( TInt i(iTrail.Count()-1) ; i >= 0 && !posFound ; i-- )

        {

        TInt err = iTrail[i].iTimeStamp.SecondsFrom( aTime, interval );

        TInt timeDiff = Abs( interval.Int() );

#ifdef _DEBUG

        LOG1( "CLocationRecord::GetLocationByTimeL - Trail timestamp: %Ld", iTrail[i].iTimeStamp.Int64() );

        TBuf<DateTimeStrMaxLength> str;

        iTrail[i].iTimeStamp.FormatL( str, KDateTimeFormat );

        LOG1( "CLocationRecord::GetLocationByTimeL - Trail timestamp: %S", &str );

        LOG1( "CLocationRecord::GetLocationByTimeL - timeDiff: %d", timeDiff );

#endif

        if ( err == KErrNone && timeDiff <= KMaximumIntervalSeconds )

            {

            // The nearest time is in iTrail[i] or in iTrail[i-1].

            if ( i > 0 )

                {

                iTrail[i-1].iTimeStamp.SecondsFrom( aTime, nextInterval );

                TInt nextDiff = Abs( nextInterval.Int() );

                if ( nextDiff < timeDiff )

                    {

                    aLocationData = iTrail[i-1].iLocationData;

                    aState = iTrail[i-1].iTrailState;

                    }

                else

                    {

                    aLocationData = iTrail[i].iLocationData;

                    aState = iTrail[i].iTrailState;

                    }                    

                }            

            else

                {

                aLocationData = iTrail[i].iLocationData;

                aState = iTrail[i].iTrailState;

                }

            posFound = ETrue;

            }

        }

    if ( !posFound )

        {

        User::Leave( KErrNotFound );

        }

    LOG( "CLocationRecord::GetLocationByTimeL(), end" );

    }

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

// CLocationRecord::RequestLocationL

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

//

EXPORT_C void CLocationRecord::RequestLocationL()

    {

    iRequestCurrentLoc = ETrue;

    if ( iTrailCaptureSetting != RLocationTrail::ECaptureNetworkInfo &&

    	!iPositionInfo->IsActive() )

        {

        iPositionInfo->StartL( iTrailCaptureSetting, iInterval );

        }

    else if ( iTrailCaptureSetting == RLocationTrail::ECaptureNetworkInfo )

    	{

    	TPositionSatelliteInfo posInfo;

    	CTelephony::TNetworkInfoV1 network = CTelephony::TNetworkInfoV1();

    	GetNetworkInfo( network );

       	iObserver->CurrentLocation( posInfo, network, KErrNone );

        iRequestCurrentLoc = EFalse;

    	}

    }

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

// CLocationRecord::CancelLocationRequest

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

//    

EXPORT_C void CLocationRecord::CancelLocationRequest()

    {

    iRequestCurrentLoc = EFalse;

    if ( !iTrailStarted )

        {

        iPositionInfo->Stop();

        }

    }

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

// CLocationRecord::GetNetworkInfo

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

//

    {

    LOG("CLocationRecord::GetNetworkInfo");

    aNetworkInfo = iNetwork;

    }

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

// CLocationRecord::SetObserver

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

//

EXPORT_C void CLocationRecord::SetObserver( MLocationTrailObserver* aObserver) 

    {

    iObserver = aObserver;

    }

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

// CLocationRecord::SetAddObserver

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

//

EXPORT_C void CLocationRecord::SetAddObserver( MLocationAddObserver* aObserver)

    {

    iAddObserver = aObserver;

    }

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

// From MNetworkInfoObserver.

// CLocationRecord::Position

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

//    

void CLocationRecord::Position( const TPositionInfo& aPositionInfo,

    {    

    const TPositionSatelliteInfo& positionSatelliteInfo = 

    	static_cast<const TPositionSatelliteInfo&>(aPositionInfo);

    if ( iRequestCurrentLoc )

        {

        HandleLocationRequest( positionSatelliteInfo, aError );

        }

    if( iState == RLocationTrail::ETrailStopped )

    	{

    	LOG("CLocationRecord::Position - trail stopped");

    	return;

    	}

    if ( !iTrailStarted )

        {

        iPositionInfo->NextPosition();

        return;

        }

    switch ( aError )

        {

        case KPositionPartialUpdate: // fall through

        case KPositionQualityLoss: 

            {

            // Location is stored, even if it may not be valid.

            StoreLocation( positionSatelliteInfo ); 

            LOG("CLocationRecord::Position - partial update");

            if ( iState != RLocationTrail::EWaitingGPSData && 

            	 iState != RLocationTrail::ETrailStopping ) 

                {

                SetCurrentState( RLocationTrail::EWaitingGPSData );

            	LOG("CLocationRecord::Position trail waiting for gps");

                }

            break;

            }

        case KErrNone:

            {

            StoreLocation( positionSatelliteInfo );

            LOG("CLocationRecord::Position - good GPS coordinates");

            if ( iState != RLocationTrail::ETrailStarted ) 

                {

                if ( iRemapper )

                	{

                	LOG("CLocationRecord::Position start remapping");

                	iLastLocationId = 0;

                	TBool createLocation = iRemapper->CheckQueue();

                	if( createLocation )

                		{

                		TRAP_IGNORE(	

                		TItemId locationId = DoCreateLocationL( iNewItem.iLocationData );

                		iRemapper->UpdateRelationsL( locationId );

                		)

                		}

               		iRemapper->StartRemappingObjects( iNewItem.iLocationData );

                	}

                if ( iState != RLocationTrail::ETrailStopping )

                	{

                    SetCurrentState( RLocationTrail::ETrailStarted );

                	LOG("CLocationRecord::Position trail started");

                	}

                }

            break;

            }

        default:

            {

            StoreLocation( positionSatelliteInfo );

            LOG1("CLocationRecord::Position - searching GPS, aError %d", aError );

            if ( iState != RLocationTrail::ESearchingGPS &&

               	 iState != RLocationTrail::ETrailStopping ) 

                {

                SetCurrentState( RLocationTrail::ESearchingGPS );

            	LOG("CLocationRecord::Position trail searching gps");

                }

            break;

            }      

        }

    TBool fixState = CheckGPSFix( positionSatelliteInfo );

    LOG1( "CLocationRecord::Position fixState %d", fixState );

    LOG1( "CLocationRecord::Position iLastGPSFixState %d", iLastGPSFixState );

    if ( iObserver && iLastGPSFixState != fixState )

    	{

    	LOG("CLocationRecord::Position quality changed");

    	iObserver->GPSSignalQualityChanged( positionSatelliteInfo );

    	}

   	iLastGPSFixState = fixState;

    iPositionInfo->NextPosition();

    }

TBool CLocationRecord::CheckGPSFix( const TPositionSatelliteInfo& aSatelliteInfo )

	{

	TPosition position;

	aSatelliteInfo.GetPosition( position );

	LOG1( "CLocationRecord::CheckGPSFix latitude %f", position.Latitude() );

	LOG1( "CLocationRecord::CheckGPSFix longitude %f", position.Longitude() );

	TBool ret = ( Math::IsNaN(position.Latitude()) || Math::IsNaN(position.Longitude()) ) 

		? EFalse : ETrue;

   	return ret;

	}

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

// From MPositionerObserver.

// CLocationRecord::NetworkInfo

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

//    

void CLocationRecord::NetworkInfo( const CTelephony::TNetworkInfoV1 &aNetworkInfo, 

    {

    LOG("CLocationRecord::NetworkInfo");

    if ( aError == KErrNone )

        {

        LOG("CLocationRecord::NetworkInfo - KErrNone");

        iNetwork = aNetworkInfo;

        if (iNetwork.iAccess == CTelephony::ENetworkAccessUtran)

        	{

        	iNetwork.iLocationAreaCode = 0;

        	}

        if ( iState == RLocationTrail::ETrailStarting && iTrailStarted )

        	{

        	SetCurrentState( RLocationTrail::ETrailStarted );

        	}

        }

    else

        {

        LOG1("CLocationRecord::NetworkInfo - %d", aError );

        iNetwork = CTelephony::TNetworkInfoV1();

        iNetwork.iAreaKnown = EFalse;

        iNetwork.iAccess = CTelephony::ENetworkAccessUnknown;

        iNetwork.iCellId = 0;

        iNetwork.iLocationAreaCode = 0;

        iNetwork.iCountryCode.Zero();

        iNetwork.iNetworkId.Zero();

        }

    }

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

// CLocationRecord::StoreLocationL

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

//    

void CLocationRecord::StoreLocation( const TPositionSatelliteInfo& aSatelliteInfo )

    {

    aSatelliteInfo.GetPosition( iNewItem.iLocationData.iPosition );

    aSatelliteInfo.GetCourse( iNewItem.iLocationData.iCourse );

    iNewItem.iLocationData.iSatellites = aSatelliteInfo.NumSatellitesUsed();

    iNewItem.iLocationData.iQuality = aSatelliteInfo.HorizontalDoP();

    // Network info

    GetNetworkInfo( iNewItem.iLocationData.iNetworkInfo );

    // Get Universal time

    iNewItem.iTimeStamp.UniversalTime();

    iNewItem.iTrailState = iState;

    TInt error = iTrail.Append( iNewItem );

    // If appending an item to the trail fails because of OOM, remove oldest trail items

    // until the new item fits or there's only one item left in the trail.

    while ( error == KErrNoMemory && iTrail.Count() > 1 )

		{

		LOG("CLocationRecord::StoreLocation - Out of memory! Shortening trail!");

		iTrail.Remove( 0 );

		error = iTrail.Append( iNewItem );

		}

    if ( iTrail.Count() > iMaxTrailSize )

        {