/*

* 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"

using namespace MdeConstants;

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

// CLocationRecord::NewL

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

//

    {

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CLocationRecord::CLocationRecord

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

//  

    : iNetworkInfoTimer( NULL ),

    iState( RLocationTrail::ETrailStopped ),

    iTrailCaptureSetting( RLocationTrail::ECaptureAll ),

    iLocationCounter( 0 ),

    iRequestCurrentLoc( EFalse ),

    iTrailStarted( EFalse ),

    iLastGPSFixState( EFalse ),

    {

    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 ) ); 

    iPositionInfo = CPositionInfo::NewL( this );

	iRemapper = CLocationRemappingAO::NewL();

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

    TInt interval( 0 );

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

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

    	{

    	iInterval = KUpdateInterval;

    	}

    else 

    	{

    	iInterval = interval * KMillion;

    	}

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

    if (iLocationDelta == 0)

    	{

        iLocationDelta = KLocationDelta;

    	}

    }

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

// CLocationRecord::~CLocationRecord

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

//    

EXPORT_C CLocationRecord::~CLocationRecord()

    {

    Stop();

    iProperty.Delete( KPSUidLocationTrail, KLocationTrailState );

    iProperty.Close();

    iTrail.Close();

    delete iPositionInfo;

    delete iNetworkInfoTimer;

		{

		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  )

            {

            }

        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();

    	}

    SetCurrentState( RLocationTrail::ETrailStarting );

    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,

                                                   TLocTrailState& aState ) 

    {

    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 timeDiff = Abs( interval.Int() );

#ifdef _DEBUG

        TBuf<DateTimeStrMaxLength> str;

        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 )

                {

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

                if ( nextDiff < timeDiff )

                    {

                    }

                else

                    {

                    }                    

                }            

            else

                {

                }

            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

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

//

EXPORT_C void CLocationRecord::GetNetworkInfo( CTelephony::TNetworkInfoV1& aNetworkInfo ) 

    {

    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 TInt aError  )

    {    

    const TPositionSatelliteInfo& positionSatelliteInfo = 

    	static_cast<const TPositionSatelliteInfo&>(aPositionInfo);

    if ( iRequestCurrentLoc )

        {

        HandleLocationRequest( positionSatelliteInfo, aError );

        }