/*

* 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 session class for LocationManagerServer.

*

*/

#include <e32debug.h>

#include <s32mem.h>

#include <lbssatellite.h> 

#include <locationdatatype.h>

#include <locationeventdef.h>

#include "clocationmanagerserver.h"

#include "clocationmanagersession.h"

#include "locationmanagerdefs.h"

#include "locationmanagerdebug.h"

#include "rlocationtrail.h"

#include "rlocationobjectmanipulator.h"

#include "rlocationtrail.h"

#include "mdsutils.h"

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

// CLocationManagerSession::CLocationManagerSession

// C++ constructor.

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

//

CLocationManagerSession::CLocationManagerSession() 

    {

    }

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

// CLocationManagerSession::~CLocationManagerSession

// C++ destructor.

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

//

CLocationManagerSession::~CLocationManagerSession()

    {

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

    // don't call stop GPS positioning from here...

    // we are expecting the application to start and stop else on server terminate, we will do the same.

    // this is not okay when user takes a photograph and then transfer photo using BT/PC .

    // at this point, it will stop the trail for camera where as camera session is still valid.

    Server().CancelNotificationRequest( iNotificationHandle );

    Server().CancelLocationRequest( iLocationHandle );

    Server().CancelTrackLogNotificationRequest( iTrackLogNotificationHandle );

    Server().RemoveSession();

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

    }

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

// CLocationManagerSession::CreateL

// From CSession2, used to increase server's session count.

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

//

void CLocationManagerSession::CreateL()

    {

    LOG( "CLocationManagerSession::CreateL(), begin" );

    Server().AddSession();

    LOG( "CLocationManagerSession::CreateL(), end" );

    }

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

// CLocationManagerSession::Server

// Reference to server.

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

//

CLocationManagerServer& CLocationManagerSession::Server()

    {   

    return *static_cast<CLocationManagerServer*>

           ( const_cast<CServer2*>( CSession2::Server() ) );

    }

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

// CLocationManagerSession::ServiceL

// From CSession2, passes the request forward to DispatchMessageL.

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

//

void CLocationManagerSession::ServiceL( const RMessage2& aMessage )

    {

    LOG( "CLocationManagerSession::ServiceL, begin" );

    LOG1("Message id - %d", aMessage.Function());

    iMessage = RMessage2( aMessage );

    TRAPD( err, DispatchMessageL( aMessage ) );

    if ( err != KErrNone )

        {

        aMessage.Complete( err );

        }    

    LOG( "CLocationManagerSession::ServiceL, end" );

    }

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

// CLocationManagerSession::DispatchMessageL

// Handles the request from client.

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

//

void CLocationManagerSession::DispatchMessageL( const RMessage2& aMessage )

    {

    LOG( "CLocationManagerSession::DispatchMessageL" );

    switch( aMessage.Function() )

        {

        case ELocManStartTrail:

            StartLocationTrailL( aMessage );

            break;        

        case ELocManStopTrail:

            StopLocationTrailL( aMessage );

            break;        

        case ELocManTrailState:

            GetLocationTrailStateL( aMessage );

            break;        

        case ELocManNotifyTrailStateChange:

            NotifyLocationTrailStateChangeL( aMessage );

            break;        

        case ELocManCancelNotification:

            CancelNotificationRequest( aMessage );

            break;

        case ELocManRetrieveLoc:

            RetrieveLocationL( aMessage );

            break;

        case ELocManCurrentLoc:

            CurrentLocationL( aMessage );

            break;

        case ELocManCancelCurrentLoc:

            CancelLocationRequest( aMessage );

            break;

        case ELocManCreateLocationObject:

        	CreateLocationObjectL( aMessage );

        	break;

        case ELocManLocationSnapshot:

        	LocationSnapshotL( aMessage );

        	break;

        case ELocManRemoveLocationObject:

        	RemoveLocationObjectL( aMessage );

        	break;

        case ELocManCopyLocationDataById:

        	CopyLocationDataByIdL( iMessage );

        	break;

        case ELocManCopyLocationDataByUri:

	    	CopyLocationDataByURIL( iMessage );

	    	break;		

        case ELocManStartTrackLog:

        	StartTrackLogL( aMessage );

        	break;

        case ELocManStopTrackLog:

        	StopTrackLogL( aMessage );

        	break;

        case ELocManGetTrackLogStatus:

        	GetTrackLogStatusL( aMessage );

        	break;

        case ELocManDeleteTrackLog:

        	DeleteTrackLogL( aMessage );

        	break;

        case ELocManIsTrackLogRecording:

        	IsTrackLogRecordingL( aMessage );

        	break;

        case ELocManTrackLogName:

        	TrackLogNameL( aMessage );

        	break;

        case ELocManRegObserver:

        	RegisterTrackLogObserver( aMessage );

        	break;

        case ELocManGetCaptureSetting:

        	GetCaptureSettingL( aMessage );

        	break;

        case ELocManCancelTrackLogNotify:

        	CancelTrackLogNotificationRequest( aMessage );

        	break;

        case ELocManTagPending:

        	Server().TagPendingRequestL(aMessage);

        	break;

        case ELocManStartGeoTaging:

            Server().StartGeoTaggingL(aMessage);

            break;

        case ELocManCancelTagPendingReq:

            Server().CancelTagPendingRequest(aMessage);

			break;

		case ELocManCancelGeoTaggingReq:

            Server().CancelGeoTaggingRequest(aMessage);

            break;

        default:

            aMessage.Complete( KErrArgument );

            break;

        }

    }

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

// CLocationManagerSession::StartLocationTrailL

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

//

void CLocationManagerSession::StartLocationTrailL( const RMessage2& aMessage )

    {

    const TInt KParamSetting = 0;

    RLocationTrail::TTrailCaptureSetting setting;

    TPckg<RLocationTrail::TTrailCaptureSetting> locSetting( setting ); 

    aMessage.ReadL(KParamSetting, locSetting);    

    LOG1 ("CLocationManagerSession::StartLocationTrailL TTrailCaptureSetting: %d", setting);

    Server().StartGPSPositioningL( setting );

    aMessage.Complete( KErrNone );

    }

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

// CLocationManagerSession::StopLocationTrailL

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

//

void CLocationManagerSession::StopLocationTrailL( const RMessage2& aMessage )

    {

    Server().StopGPSPositioningL();

    if( !aMessage.IsNull() )

        {

        aMessage.Complete( KErrNone );

        }

    }

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

// CLocationManagerSession::GetLocationTrailStateL

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

//

void CLocationManagerSession::GetLocationTrailStateL( const RMessage2& aMessage )

    {

    RLocationTrail::TTrailState state;

    Server().GetLocationTrailState( state );

    TPckg<RLocationTrail::TTrailState> locState( state );    

    aMessage.WriteL( 0, locState );

    aMessage.Complete( KErrNone );    

    }

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

// CLocationManagerSession::NotifyLocationTrailStateChangeL

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

//

void CLocationManagerSession::NotifyLocationTrailStateChangeL( const RMessage2& aMessage )

    {

    iNotificationHandle = aMessage.Handle();

    Server().AddNotificationRequestL( aMessage );

    }

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

// CLocationManagerSession::CancelNotificationRequest

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

//

void CLocationManagerSession::CancelNotificationRequest( const RMessage2& aMessage )

    {

    Server().CancelNotificationRequest( iNotificationHandle );

    aMessage.Complete( KErrNone );

    }

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

// CLocationManagerSession::RetrieveLocationL

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

//

void CLocationManagerSession::RetrieveLocationL( const RMessage2& aMessage )

    {

    TTime time( 0 );

    TPckg<TTime> timeBuf( time );

    aMessage.ReadL( EArgumentTime, timeBuf );

    TLocationData locationData;

    TLocTrailState state;

    Server().GetLocationByTimeL( time, locationData, state );

    TPckg<TLocationData> locDataBuf( locationData );

    aMessage.WriteL( EArgumentLocationData, locDataBuf );

    TPckg<TUint> stateBuf( state );

    aMessage.WriteL( EArgumentState, stateBuf );

    aMessage.Complete( KErrNone );

    }

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

// CLocationManagerSession::CurrentLocationL

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

//    

void CLocationManagerSession::CurrentLocationL( const RMessage2& aMessage )

    {

    LOG ("CLocationManagerSession::CurrentLocationL begin");

    iLocationHandle = aMessage.Handle();

    // server creates completion after it has received current location data

    Server().RequestCurrentLocationL( aMessage );

    LOG ("CLocationManagerSession::CurrentLocationL end");

    }

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

// CLocationManagerSession::CancelLocationRequest()

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

//    

void CLocationManagerSession::CancelLocationRequest( const RMessage2& aMessage )

    {

    Server().CancelLocationRequest( iLocationHandle );

    aMessage.Complete( KErrNone );

    }

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

// CLocationManagerSession::CancelTrackLogNotificationRequest()

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

//    

void CLocationManagerSession::CancelTrackLogNotificationRequest( const RMessage2& aMessage )

    {

    Server().CancelTrackLogNotificationRequest( iTrackLogNotificationHandle );

    aMessage.Complete( KErrNone );

    }

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

// CLocationManagerSession::CreateLocationObjectL

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

//    

void CLocationManagerSession::CreateLocationObjectL( const RMessage2& aMessage )

    {

    LOG( "CLocationManagerSession::CreateLocationObjectL begin" );

    const TInt KParamData = 0;

    const TInt KParamId = 1;

    TLocationData locationData;

    TUint objectId;

    TPckg<TLocationData> locData( locationData );

    aMessage.ReadL( KParamData, locData );

    TPckg<TUint> objId( objectId);

    aMessage.ReadL( KParamId, objId );

    Server().CreateLocationObjectL( locationData, objectId );

    aMessage.Complete( KErrNone );

    LOG( "CLocationManagerSession::CreateLocationObjectL end" );

    }

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

// CLocationManagerSession::LocationSnapshotL

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

//    

void CLocationManagerSession::LocationSnapshotL( const RMessage2& aMessage )

    {

    LOG( "CLocationManagerSession::LocationSnapshotL begin" );

    const TInt KParamId = 0;

    TUint objectId;

    TPckg<TUint> objId( objectId);

    aMessage.ReadL( KParamId, objId );

    Server().LocationSnapshotL( objectId );

    aMessage.Complete( KErrNone );

    LOG( "CLocationManagerSession::LocationSnapshotL end" );

    }

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

// CLocationManagerSession::RemoveLocationObjectL

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

//    

void CLocationManagerSession::RemoveLocationObjectL( const RMessage2& aMessage )

    {

    LOG( "CLocationManagerSession::RemoveLocationObjectL begin" );

    const TInt KParamId = 0;

    TUint objectId;

    TPckg<TUint> locObjectId( objectId );

    aMessage.ReadL(KParamId, locObjectId);

    Server().RemoveLocationObjectL(objectId);

    aMessage.Complete( KErrNone );

    LOG( "CLocationManagerSession::RemoveLocationObjectL end" );

    }

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

// CLocationManagerSession::CopyLocationDataByIdL

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

//    

void CLocationManagerSession::CopyLocationDataByIdL( const RMessage2& aMessage )

    {

    Server().InitCopyLocationByIdL( aMessage );

    }

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

// CLocationManagerSession::CopyLocationDataByURIL

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

//    

void CLocationManagerSession::CopyLocationDataByURIL( const RMessage2& aMessage )

    {

    Server().InitCopyLocationByURIL( aMessage );

    }

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

// CLocationManagerSession::StartTrackLog

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

//    

void CLocationManagerSession::StartTrackLogL( const RMessage2& aMessage )

	{

	RLocationTrail::TTrailState state;

	Server().GetLocationTrailState( state );

	if ( state == RLocationTrail::ETrailStopped )

		{

		Server().StartGPSPositioningL( RLocationTrail::ECaptureAll );

		}

	Server().StartTrackLogL();

	aMessage.Complete( KErrNone );

	}

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

// CLocationManagerSession::StopTrackLog

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

//    

void CLocationManagerSession::StopTrackLogL( const RMessage2& aMessage )

	{

	Server().StopTrackLogL();

	aMessage.Complete( KErrNone );

	}

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

// CLocationManagerSession::GetStatus

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

//    

void CLocationManagerSession::GetTrackLogStatusL(const RMessage2& aMessage)

	{

	const TInt KParamRec = 0;

	const TInt KParamQuality = 1;

	TBool rec = EFalse;

	TPositionSatelliteInfo fixQuality;

	Server().GetTrackLogStatus( rec, fixQuality );

	TPckg<TBool> wrapRec( rec );

	aMessage.WriteL( KParamRec, wrapRec );

	TPckg<TPositionSatelliteInfo> wrapQuality( fixQuality );

	aMessage.WriteL( KParamQuality, wrapQuality );

	aMessage.Complete( KErrNone );

	}

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

// CLocationManagerSession::DeleteTrackLog

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

//    

void CLocationManagerSession::DeleteTrackLogL(const RMessage2& aMessage)

	{

	const TInt KParamUri = 0;

	const TInt KParamUriLength = aMessage.GetDesLength(KParamUri);

    TInt err = KErrNone;	

	if (KParamUriLength > 0)

    	{

    	// read TDesC& aURI from request

	    HBufC* uriBuf = HBufC::NewLC( KParamUriLength );

	    TPtr ptrUri( uriBuf->Des() );

	    aMessage.ReadL( KParamUri, ptrUri );  

	    err = Server().DeleteTrackLogL( ptrUri );

	    CleanupStack::PopAndDestroy( uriBuf );

    	}

	aMessage.Complete( err );

	}

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

// CLocationManagerSession::IsTrackLogRecordingL

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

//    

void CLocationManagerSession::IsTrackLogRecordingL(const RMessage2& aMessage)

	{	

	const TInt KParamRec = 0;

	TBool rec = EFalse;

	Server().IsTrackLogRecording( rec );

	TPckg<TBool> wrapRec( rec );

	aMessage.WriteL(KParamRec, wrapRec);

	aMessage.Complete( KErrNone );

	}

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

// CLocationManagerSession::TrackLogName

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

//    

void CLocationManagerSession::TrackLogNameL(const RMessage2& aMessage)

	{	

	const TInt KParamName = 0;

	TFileName fileName;

	TInt err;

	err = Server().TrackLogName( fileName );

	aMessage.WriteL(KParamName, fileName);

	aMessage.Complete( err );

	}

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

// CLocationManagerSession::RegisterTrackLogObserver

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

//  

void CLocationManagerSession::RegisterTrackLogObserver( const RMessage2& aMessage )

	{

	iTrackLogNotificationHandle = aMessage.Handle();

	TRAP_IGNORE( Server().AddTrackLogNotificationRequestL( aMessage ) );

	}

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

// CLocationManagerSession::GetCaptureSettingL

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

//

void CLocationManagerSession::GetCaptureSettingL( const RMessage2& aMessage )

	{

	TInt KParamCaptureSetting = 0;

	RLocationTrail::TTrailCaptureSetting captureSetting = RLocationTrail::EOff;