/*

* 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 <ecom.h>

#include <centralrepository.h>

#include <hwrmpowerstatesdkpskeys.h>

#ifdef LOC_GEOTAGGING_CELLID

#include <lbslocationinfo.h>

#endif //LOC_GEOTAGGING_CELLID

#include "rlocationtrail.h"

#include "clocationrecord.h"

#include "cnetworkinfo.h"

#include "locationmanagerdebug.h"

#include "locationtraildefs.h"

#include "locationtrailpskeys.h"

#include "mdeconstants.h"

#ifdef LOC_REVERSEGEOCODE

#include "reversegeocoderplugin.h"

const TUid KReverseGeoCodeUid = {0x2002DD12}; 

#endif	

using namespace MdeConstants;

const TUint KNetQueryBit = 1; // 1 bit

const TUint KDownloadMediaFile = 2; // 2  bit

const TUint KSnapMediaFile = 4; // 3 bit

const TUint KLocationQueryInProgress = 1; // 1  bit

#ifdef LOC_REVERSEGEOCODE

const TUint KReverseGeoCodingInProgress = 2; // 2 bit

_LIT ( KCountry, "country:");   // country:india 

_LIT ( KCity, "city:");         // city:bangalore|country:india

#endif

const TUint KSnapGeoConvertInProgress = 4; // 3 bit

#ifdef LOC_GEOTAGGING_CELLID

const TUint KSnapGeoConvertInPendingState = 8; // 4 bit

#endif

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

// CLocationRecord::NewL

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

//

EXPORT_C CLocationRecord* CLocationRecord::NewL(MGeoTaggerObserver& aGeoTaggerObserver,

                RMobilePhone& aPhone)

    {

    CLocationRecord* self = new (ELeave) CLocationRecord(aGeoTaggerObserver, aPhone);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CLocationRecord::CLocationRecord

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

//  

CLocationRecord::CLocationRecord(MGeoTaggerObserver& aGeoTaggerObserver,

                RMobilePhone& aPhone)

    : iNetworkInfoTimer( NULL ),

    iState( RLocationTrail::ETrailStopped ),

    iTrailCaptureSetting( RLocationTrail::ECaptureAll ),

    iLocationCounter( 0 ),

    iRequestCurrentLoc( EFalse ),

    iTrailStarted( EFalse ),

    iLastGPSFixState( EFalse ),

	iLocationQuery(NULL),

	iNetLocationQuery(NULL),

    iRemapState( ERemapProgressNone),

	iNamespaceDef(NULL),

	iLocationObjectDef(NULL),

	iLatitudeDef(NULL),

	iLongitudeDef(NULL),

	iAltitudeDef(NULL),

    iMediaHandlingFlag(0),

    iPhone(aPhone),

    iGpsDataAvailableFlag(EFalse),

    iGeoTaggerObserver(aGeoTaggerObserver)

#ifdef LOC_GEOTAGGING_CELLID	

    ,iGeoConverter(NULL)

    , iConvertRetry(ETrue)

#endif

#ifdef LOC_REVERSEGEOCODE

    ,iConnectionOption(ESilent)

	,iImageQuery(NULL)

	,iTagQuery(NULL)

    ,iTagCreator( NULL )

    ,iLastReverseGeocodeFails(EFalse)

	,iRevGeocoderPlugin( NULL )

#endif

    {

    iMaxTrailSize = KMaxTrailLength / KUpdateInterval;

    }

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

// CLocationRecord::ConstructL

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

//    

void CLocationRecord::ConstructL()

    {

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

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

    iNetworkInfoChangeListener = CNetworkInfo::NewL( this );

    iPositionInfo = CPositionInfo::NewL( this );

	iRemapper = CLocationRemappingAO::NewL();

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

#ifdef LOC_REVERSEGEOCODE

    iTagCreator = CTagCreator::NewL();

 #endif

    TInt interval( 0 );

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

    LOG1("Cenrep interval value:%d", interval);

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

    	{

        LOG1("Cenrep interval err:%d", err);

    	iInterval = KUpdateInterval;

    	}

    else 

    	{

    	iInterval = interval * KMillion;

    	}

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

    LOG1("Location delta value:%d", iLocationDelta);

    if (iLocationDelta == 0)

    	{

        LOG1("Location delta err:%d", err);

        iLocationDelta = KLocationDelta;

    	}

    iLastMediaItem.iFlag = 0;

    iLastMediaItem.iLocationId = 0;

#ifdef LOC_REVERSEGEOCODE

    iLastMediaItem.iCityTagId= 0;

    iLastMediaItem.iCountryTagId = 0;

    iLastLocationItem.iFlag = 0;

    iLastLocationItem.iCityTagId= 0;

    iLastLocationItem.iCountryTagId = 0;

    iLastLocationItem.iLocationId = 0;

#endif

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

    }

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

// CLocationRecord::~CLocationRecord

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

//    

EXPORT_C CLocationRecord::~CLocationRecord()

    {

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

    Stop();

    iProperty.Delete( KPSUidLocationTrail, KLocationTrailState );

    iProperty.Close();

    iTrail.ResetAndDestroy();

    iTrail.Close();

    iMediaItems.ResetAndDestroy();

    iMediaItems.Close();

#ifdef LOC_REVERSEGEOCODE

    iLocationItems.ResetAndDestroy();

    iLocationItems.Close();

#endif    

    delete iNetworkInfoChangeListener;

    iNetworkInfoChangeListener = NULL;

    delete iPositionInfo;

    iPositionInfo = NULL;

    delete iNetworkInfoTimer;

    iNetworkInfoTimer = NULL;

#ifdef LOC_GEOTAGGING_CELLID

    if(iGeoConverter)

        {

        delete iGeoConverter;

        iGeoConverter = NULL;

        }

#endif    

    if (iRemapper)

		{

		iRemapper->StopRemapping();

		delete iRemapper;

		}

    if(iLocationQuery)

		{

		iLocationQuery->RemoveObserver(*this);

		iLocationQuery->Cancel();

		delete iLocationQuery;

		iLocationQuery = NULL;

		}

if(iNetLocationQuery)

    {

    iNetLocationQuery->RemoveObserver(*this);

    iNetLocationQuery->Cancel();

    delete iNetLocationQuery;

    iNetLocationQuery = NULL;

    }

#ifdef LOC_REVERSEGEOCODE

    if(iImageQuery)

		{

		iImageQuery->RemoveObserver(*this);

		iImageQuery->Cancel();

		delete iImageQuery;

        iImageQuery = NULL;

		}

    if(iTagQuery)

		{

	    iTagQuery->RemoveObserver(*this);

		iTagQuery->Cancel();

		delete iTagQuery;

        iTagQuery = NULL;

		}	

	delete iTagCreator;

	// set the pointer to NULL, ECOM will destroy object.

    delete iRevGeocoderPlugin;

    iRevGeocoderPlugin = NULL;

    REComSession::DestroyedImplementation(iDtorKey);

#endif

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

    }

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

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

    iGpsDataAvailableFlag = EFalse;

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

        {

        if( iState == RLocationTrail::ETrailStopped  )

            {

            iTrail.ResetAndDestroy();

            }

    	// Capture at least one location with n/w info else we wouldn't be able to tag the immediate taken photograph

    	// incase LBS didn't provide any valid position data. Without this there may be a leave from GetLocationByTimeL 

    	// method while calling this from LocationSnapshotL method

    	UpdateNetworkInfo( this );

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

    	}

    iTrailStarted = ETrue;

    SetCurrentState( RLocationTrail::ETrailStarting );

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

    }

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

// CLocationRecord::Stop

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

//

EXPORT_C void CLocationRecord::Stop()

    {

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

    iPositionInfo->Stop();

    iGpsDataAvailableFlag = EFalse;

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

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

    {

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

    iRequestCurrentLoc = ETrue;

    if ( iTrailCaptureSetting != RLocationTrail::ECaptureNetworkInfo &&

    	!iPositionInfo->IsActive() )

        {

        iPositionInfo->StartL( iTrailCaptureSetting, iInterval );

        SetCurrentState( RLocationTrail::ETrailStarting );

        iTrailStarted = ETrue;

        }

    else if ( iTrailCaptureSetting == RLocationTrail::ECaptureNetworkInfo )

    	{

    	TPositionSatelliteInfo posInfo;

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

    	GetNetworkInfo( network );

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

        iRequestCurrentLoc = EFalse;

    	}

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

    }

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

// CLocationRecord::CancelLocationRequest

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

//    

EXPORT_C void CLocationRecord::CancelLocationRequest()

    {

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

    iRequestCurrentLoc = EFalse;

    if ( !iTrailStarted )

        {

        iGpsDataAvailableFlag = EFalse;

        iPositionInfo->Stop();

        }

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

    }

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

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

    {    

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

    const TPositionSatelliteInfo& positionSatelliteInfo = 

    	static_cast<const TPositionSatelliteInfo&>(aPositionInfo);

    if ( iRequestCurrentLoc )

        {

        HandleLocationRequest( positionSatelliteInfo, aError );

        }

    iGpsDataAvailableFlag = EFalse;

    if ( !iTrailStarted || iState == RLocationTrail::ETrailStopped)

        {