/*

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

*

*/

#include <e32debug.h>

#include <w32std.h>

#include "clocationmanagerserver.h"

#include "clocationmanagersession.h"

#include "locationtraildefs.h"

#include "locationmanagerdebug.h"

#include "mdesession.h"

#include "mdenamespacedef.h"

#include "mdeobjectdef.h"

#include "mdepropertydef.h"

#include "mdcserializationbuffer.h"

using namespace MdeConstants;

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

// RunServerL

// Initialize and run the server.

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

//

static void RunServerL()

    {

    User::LeaveIfError( RThread().RenameMe( KLocServerName ) );

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    CLocationManagerServer* server = CLocationManagerServer::NewLC();

    RProcess::Rendezvous( KErrNone );

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(server); 

    CleanupStack::PopAndDestroy(scheduler); 

    }

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

// E32Main

// Server process entry-point.

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

//

TInt E32Main()

    {   

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt ret( KErrNoMemory );

    if( cleanup )

        {

        TRAP( ret, RunServerL() );

        delete cleanup;

        }

    return ret;

    }

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

// CLocationManagerServer::NewLC

// 2-phased constructor.

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

//

CLocationManagerServer* CLocationManagerServer::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CLocationManagerServer::CLocationManagerServer()

// C++ constructor.

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

//

CLocationManagerServer::CLocationManagerServer() 

    : CPolicyServer( CActive::EPriorityStandard, 

                     KLocationManagerPolicy, 

                     ESharableSessions ),

                     iTimer( NULL ),

			         iSessionReady( EFalse ),

                     iTagId( 0 ),

                     iLocManStopDelay( 0 ),

                     iLocManStopRemapDelay( 0 ),

                     iCaptureSetting( RLocationTrail::EOff ),

    {

    }

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

// CLocationManagerServer::ConstructL

// 2nd phase constructor.

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

//

void CLocationManagerServer::ConstructL()

    {

    LOG ("CLocationManagerServer::ConstructL() begin");

    StartL( KLocServerName );

    RProcess process;

    process.SetPriority( EPriorityBackground );

    process.Close();

    iASW = new (ELeave) CActiveSchedulerWait();

    iMdeSession = CMdESession::NewL( *this );

    iLocationRecord = CLocationRecord::NewL();

    iTrackLog = CTrackLog::NewL();

    iASW->Start();

    iLocationRecord->SetObserver( this );

    iLocationRecord->SetAddObserver( iTrackLog );

    iTrackLog->AddGpxObserver( this );

    CRepository* repository = CRepository::NewLC( KRepositoryUid );

	TInt err = repository->Get( KLocationTrailShutdownTimer, iLocManStopDelay );

    LOG1("CLocationManagerServer::ConstructL, iLocManStopDelay:%d", iLocManStopDelay);

    if ( err != KErrNone )

    	{

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

        iLocManStopDelay = KLocationTrailShutdownDelay;

    	}

    err = repository->Get( KLocationTrailRemapShutdownTimer, iLocManStopRemapDelay );

    CleanupStack::PopAndDestroy( repository );

    LOG1("CLocationManagerServer::ConstructL, iLocManStopRemapDelay:%d", iLocManStopRemapDelay);

    if ( err != KErrNone )

        {

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

        iLocManStopRemapDelay = KLocationTrailRemapShutdownDelay;

        }

    LOG ("CLocationManagerServer::ConstructL() end");

    }

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

// CLocationManagerServer::~CLocationManagerServer()

// C++ destructor.

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

//

CLocationManagerServer::~CLocationManagerServer()

    {

    delete iLocationRecord;    

    delete iTrackLog;    

    delete iTimer;

    //delete iRelationQuery;

    delete iASW;

    delete iMdeSession;

    iTargetObjectIds.Close();

    CancelRequests(iNotifReqs);

    iNotifReqs.Close();

    CancelRequests(iLocationReqs);

    iLocationReqs.Close();

    CancelRequests(iTrackLogNotifyReqs);

    iTrackLogNotifyReqs.Close();

    CancelCopyRequests(iCopyReqs);

    iCopyReqs.Close();

    iSessionCount = 0;

    }

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

// CLocationManagerServer::CompleteRequests()

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

//

void CLocationManagerServer::CancelRequests(RArray<RMessage2>& aMessageList)

	{

	const TInt count = aMessageList.Count();

    for ( TInt i(0) ; i < count; i++ )

        {

        RMessage2& msg = aMessageList[i];

        if( !msg.IsNull() )

        	{

        	msg.Complete( KErrCancel );

        	}

        }

    aMessageList.Reset();

	}

void CLocationManagerServer::CancelCopyRequests(RArray<TMessageQuery>& aMessageList)

	{

	const TInt count = aMessageList.Count();

    for ( TInt i(0) ; i < count; i++ )

        {

        const RMessage2& msg = aMessageList[i].iMessage;

        if( !msg.IsNull() )

        	{

        	msg.Complete( KErrCancel );

        	}

        }

    aMessageList.Reset();

	}

void CLocationManagerServer::HandleSessionOpened(CMdESession& /*aSession*/, TInt aError)

	{

	if ( iASW->IsStarted() )

		{

		iASW->AsyncStop();

		}

	if ( KErrNone == aError )

		{

		iSessionReady = ETrue;

		TRAP_IGNORE( iTrackLog->StartRecoveryL() );

	    iLocationRecord->SetMdeSession( iMdeSession );

		}

	else

		{

		iSessionReady = EFalse;

		delete iMdeSession;

		iMdeSession = NULL;

		}

	}

void CLocationManagerServer::HandleSessionError(CMdESession& /*aSession*/, TInt /*aError*/)

	{

	iSessionReady = EFalse;

	delete iMdeSession;

	iMdeSession = NULL;

	if ( iASW->IsStarted() )

		{

		iASW->AsyncStop();

		}	

	}

TBool CLocationManagerServer::IsSessionReady()

	{

	return iSessionReady;

	}

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

// CLocationManagerServer::NewSessionL

// from CServer2, creates a new session.

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

//

CSession2* CLocationManagerServer::NewSessionL( const TVersion& aVersion, 

                                             const RMessage2& /*aMsg*/ ) const

    {

    TBool supported = User::QueryVersionSupported( TVersion( 

                                                KLocationManagerServerMajor,

                                                KLocationManagerServerMinor,

                                                KLocationManagerServerBuild ),

                                                aVersion );

    if( !supported )

        {

        User::Leave( KErrNotSupported );

        }

    return new (ELeave) CLocationManagerSession();  

    }   

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

// CLocationManagerServer::AddSession

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

//  

void CLocationManagerServer::AddSession()  

    {

    iSessionCount++;

    }

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

// CLocationManagerServer::RemoveSession

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

//    

void CLocationManagerServer::RemoveSession()

    {

    iSessionCount--;

    if ( !iSessionCount )

        {

        CActiveScheduler::Stop();

        }

    }    

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

// CLocationManagerServer::StartGPSPositioningL

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

//

void CLocationManagerServer::StartGPSPositioningL( RLocationTrail::TTrailCaptureSetting aCaptureSetting )

    {

    LOG( "CLocationManagerServer::StartGPSPositioningL" );

    if ( aCaptureSetting == RLocationTrail::EOff )

    	{

    	return;

    	}

    iCaptureSetting = aCaptureSetting;

    RLocationTrail::TTrailState state;

    GetLocationTrailState( state );

    if ( state != RLocationTrail::ETrailStopped && state != RLocationTrail::ETrailStopping )

        {

        User::Leave( KErrAlreadyExists );

        }

    if ( iTimer )

    	{

    	delete iTimer;

    	iTimer = NULL;

    	}

    iLocationRecord->StartL( aCaptureSetting );

    }

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

// CLocationManagerServer::StopGPSPositioning

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

//    

void CLocationManagerServer::StopGPSPositioningL()

    {

    LOG( "CLocationManagerServer::StopGPSPositioningL()" );

    iCaptureSetting = RLocationTrail::EOff;

    RLocationTrail::TTrailState state;

    GetLocationTrailState( state );

    if( state != RLocationTrail::ETrailStopped && state != RLocationTrail::ETrailStopping )

        {

        if ( error != KErrNone )

            {

            // If timer can't be created we stop the location trail immediately.

            iLocationRecord->Stop();

            StopTrackLogL();

            return;

            }   

        iLocationRecord->SetStateToStopping();

        iTimer->Start( iLocManStopDelay * 1000000, 0, TCallBack( CheckForRemappingCallback, this ) );

    	}

    // Always stop tracklog.

    StopTrackLogL();

    }

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

// CLocationUtilityServer::StopRecording

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

//

void CLocationManagerServer::StopRecording()

	{

	delete iTimer;

	iTimer = NULL;

	}

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

// CLocationUtilityServer::PositioningStopTimeout

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

//

TInt CLocationManagerServer::PositioningStopTimeout( TAny* aAny )

	{

    LOG( "CLocationManagerServer::PositioningStopTimeout" );

	CLocationManagerServer* self = STATIC_CAST( CLocationManagerServer*, aAny );

	self->StopRecording();

	return KErrNone;

	}

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

// CLocationUtilityServer::PositioningStopTimeout

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

//

TInt CLocationManagerServer::CheckForRemappingCallback( TAny* aAny )

    {

    LOG( "CLocationManagerServer::CheckForRemappingCallback" );

    CLocationManagerServer* self = STATIC_CAST( CLocationManagerServer*, aAny );

    self->iTimer->Cancel();    

    if ( self->iLocationRecord->RemappingNeeded() )

        {     

        self->iTimer->Start( self->iLocManStopRemapDelay * 1000000, 0, TCallBack( PositioningStopTimeout, self ) );

        }

    else

        {        

        self->StopRecording();

        }

    return KErrNone;

    }

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

// CLocationManagerServer::GetLocationTrailState

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

//

void CLocationManagerServer::GetLocationTrailState( RLocationTrail::TTrailState& aState )

    {

    iLocationRecord->LocationTrailState( aState );

    }

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

// CLocationManagerServer::AddNotificationRequestL

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

//    

void CLocationManagerServer::AddNotificationRequestL( const RMessage2& aNotifReq )

    {

    LOG( "CLocationManagerServer::AddNotificationRequestL(), begin" );

    iNotifReqs.AppendL( aNotifReq );

    LOG( "CLocationManagerServer::AddNotificationRequestL(), end" );

    }

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

// CLocationManagerServer::AddTrackLogNotificationRequestL

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

//

void CLocationManagerServer::AddTrackLogNotificationRequestL( const RMessage2& aNotifReq )

	{

	iTrackLogNotifyReqs.AppendL( aNotifReq );

	}

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

// CLocationManagerServer::CancelNotificationRequest

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

//    

void CLocationManagerServer::CancelNotificationRequest( const TInt aHandle )

    {

    LOG( "CLocationManagerServer::CancelNotificationRequest(), begin" );

    const TInt count = iNotifReqs.Count();

    for ( TInt i = count; --i >= 0; )

        {

        RMessage2& msg = iNotifReqs[i];

        if( msg.IsNull() )

        	{

        	iNotifReqs.Remove(i);

        	continue;

        	}

        if ( msg.Handle() == aHandle )

            {

           	msg.Complete( KErrCancel );

            iNotifReqs.Remove(i);

            break;

            }

        }

    LOG( "CLocationManagerServer::CancelNotificationRequest(), end" );

    }

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

// CLocationManagerServer::GetLocationByTimeL

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

//   

void CLocationManagerServer::GetLocationByTimeL( const TTime& aTimeStamp, 

												 TLocationData& aLocationData,

    {

    iLocationRecord->GetLocationByTimeL( aTimeStamp,

    									 aLocationData,

                                         aState );

    }

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

// CLocationManagerServer::RequestCurrentLocationL

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

//    

void CLocationManagerServer::RequestCurrentLocationL( const RMessage2& aCurrLocReq )

    {

    iLocationReqs.AppendL( aCurrLocReq );

    iLocationRecord->RequestLocationL();

    }

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

// CLocationManagerServer::CancelLocationRequest

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

//    

void CLocationManagerServer::CancelLocationRequest( const TInt aHandle )

    {

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

    const TInt count = iLocationReqs.Count();

    for ( TInt i = count; --i >= 0; )

        {

        RMessage2& msg = iLocationReqs[i];

        if( msg.IsNull() )

        	{

        	iLocationReqs.Remove(i);

        	continue;

        	}

        if ( msg.Handle() == aHandle )

            {

            msg.Complete( KErrCancel );

            iLocationReqs.Remove(i);