/*

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

                     KLocationManagerPolicy, 

                     ESharableSessions ),

                     iTimer( NULL ),

			         iSessionReady( EFalse ),

                     iTagId( 0 ),

                     iLocManStopDelay( 0 ),

                     iLocManStopRemapDelay( 0 ),

                     iCaptureSetting( RLocationTrail::EOff ),

                     iRemoveLocation( EFalse ),

    {

    }

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

// CLocationManagerServer::ConstructL

// 2nd phase constructor.

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

//

void CLocationManagerServer::ConstructL()

    {

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

    StartL( KLocServerName );

    iASW = new (ELeave) CActiveSchedulerWait();

    iTrackLog = CTrackLog::NewL();

    iLocationRecord->SetObserver( this );

    iLocationRecord->SetAddObserver( iTrackLog );

    iTrackLog->AddGpxObserver( this );

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

    if ( err != KErrNone )

        iLocManStopDelay = KLocationTrailShutdownDelay;

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

    CleanupStack::PopAndDestroy( repository );

    if ( err != KErrNone )

        {

        iLocManStopRemapDelay = KLocationTrailRemapShutdownDelay;

        }

        {

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

    }

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

// CLocationManagerServer::~CLocationManagerServer()

// C++ destructor.

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

//

CLocationManagerServer::~CLocationManagerServer()

    {

    delete iLocationRecord;    

    delete iTrackLog;    

    delete iTimer;

    delete iASW;

    delete iMdeSession;

    iTargetObjectIds.Close();

    CancelRequests(iNotifReqs);

    iNotifReqs.Close();

    CancelRequests(iLocationReqs);

    iLocationReqs.Close();

    CancelRequests(iTrackLogNotifyReqs);

    iTrackLogNotifyReqs.Close();

    CancelCopyRequests(iCopyReqs);

    iCopyReqs.Close();

    iSessionCount = 0;

    }

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

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

//

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)

	{

		{

		iASW->AsyncStop();

		}

	if ( KErrNone == aError )

		{

		iSessionReady = ETrue;

		TRAP_IGNORE( iTrackLog->StartRecoveryL() );

	    iLocationRecord->SetMdeSession( iMdeSession );

		}

	else

		{

		iSessionReady = EFalse;

		delete iMdeSession;

		iMdeSession = NULL;

		}

	}

	{

	iSessionReady = EFalse;

	delete iMdeSession;

	iMdeSession = NULL;

		{

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

    }    

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

// CLocationManagerServer::StartGPSPositioningL

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

//

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

    {

    LOG( "CLocationManagerServer::StartGPSPositioningL" );

    iWaitForPositioningStopTimeout = EFalse;

    if ( aCaptureSetting == RLocationTrail::EOff )