/*

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

#include <commsdattypesv1_1.h>

#include <cdblen.h>

#include <commsdat_partner.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"

#include "clocationgeotagtimerao.h"

#include "nwregistrationstatushandler.h"

using namespace MdeConstants;

using namespace CommsDat;

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

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

                     iASW(NULL),

                     iTimer( NULL ),

			         iSessionReady( EFalse ),

                     iTagId( 0 ),

                     iLocManStopDelay( 0 ),

                     iLocManStopRemapDelay( 0 ),

                     iCaptureSetting( RLocationTrail::EOff ),

                     iRemoveLocation( EFalse ),

                     iWaitForPositioningStopTimeout ( EFalse ),

                     iTelServerIsOpen(EFalse),

                     iPhoneIsOpen(EFalse),

                     iNwRegistrationStatusHandler(NULL),

#ifdef LOC_REVERSEGEOCODE

					 ,iGeoTaggingPendingReqObj(NULL)

					 ,iEcomSession(NULL)

#endif //LOC_REVERSEGEOCODE

    {

    }

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

// CLocationManagerServer::ConstructL

// 2nd phase constructor.

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

//

void CLocationManagerServer::ConstructL()

    {

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

    StartL( KLocServerName );

    RProcess process;

    process.SetPriority( EPriorityBackground );

    process.Close();

    // initialize etel

    InitialisePhoneL();

#ifdef LOC_REVERSEGEOCODE

    iEcomSession = &(REComSession::OpenL());

#endif //LOC_REVERSEGEOCODE

    iASW = new (ELeave) CActiveSchedulerWait();

    iNwRegistrationStatusHandler = CNwRegistrationStatusHandler::NewL(iPhone);

    iMdeSession = CMdESession::NewL( *this );

    iLocationRecord = CLocationRecord::NewL(*this, iPhone);

    iTrackLog = CTrackLog::NewL();

    iASW->Start();

    delete iASW;

    iASW = NULL;

    if(iSessionReady)

        {

        LOG("Session is ready to give service");

        iLocationRecord->SetObserver( this );

        iLocationRecord->SetAddObserver( iTrackLog );

        iTrackLog->AddGpxObserver( this );

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

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

        if ( err != KErrNone )

        	{

            iLocManStopDelay = KLocationTrailShutdownDelay;

        	}

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

        CleanupStack::PopAndDestroy( repository );

        if ( err != KErrNone )

            {

            iLocManStopRemapDelay = KLocationTrailRemapShutdownDelay;

            }

        //Create the instance of the geotagging timer object

        iGeoTagTimer = CLocationGeoTagTimerAO::NewL(*iMdeSession, *this);

        //Schedule a task for geotagging every day at 3.00 AM

        iGeoTagTimer->StartTimer();

        }

    else

        {

        LOG("Unable to open MDE session. Closing..");

        User::Leave(KErrCouldNotConnect);

        }

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

    }

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

// CLocationManagerServer::~CLocationManagerServer()

// C++ destructor.

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

//

CLocationManagerServer::~CLocationManagerServer()

    {

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

#ifdef LOC_REVERSEGEOCODE

    delete iGeoTaggingPendingReqObj;

#endif //LOC_REVERSEGEOCODE

    delete iLocationRecord;    

    delete iTrackLog;    

    delete iTimer;

    delete iASW;

    delete iMdeSession;

    delete iNwRegistrationStatusHandler;

    iTargetObjectIds.Close();

    CancelRequests(iNotifReqs);

    iNotifReqs.Close();

    CancelRequests(iLocationReqs);

    iLocationReqs.Close();

    CancelRequests(iTrackLogNotifyReqs);

    iTrackLogNotifyReqs.Close();

    CancelCopyRequests(iCopyReqs);

    iCopyReqs.Close();

    iSessionCount = 0;

	if(iPhoneIsOpen)

        {   

        iPhoneIsOpen = EFalse; // not required

        iPhone.Close();

        }

    if(iTelServerIsOpen)

        {

        iTelServerIsOpen = EFalse;

        iTelServer.Close();

        }

#ifdef LOC_REVERSEGEOCODE

	if(iEcomSession)

        {

        iEcomSession->Close();

        }

#endif //LOC_REVERSEGEOCODE

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

    }

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

// CLocationManagerServer::GetCommDbTSYnameL

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

//    

void CLocationManagerServer::GetCommDbTSYnameL(TDes& aTsyName)

	{

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

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	CMDBField<TDesC>* globalSettingField = new(ELeave) CMDBField<TDesC>(KCDTIdBearerAvailabilityCheckTSY);

	CleanupStack::PushL(globalSettingField);

	globalSettingField->SetRecordId(1);

	globalSettingField->SetMaxLengthL(KMaxTextLength);

	globalSettingField->LoadL(*db);

	aTsyName = *globalSettingField;

	CleanupStack::PopAndDestroy(globalSettingField);

	CleanupStack::PopAndDestroy(db);

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

	}

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

// CLocationManagerServer::InitialisePhoneL

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

//    

void CLocationManagerServer::InitialisePhoneL()

	{

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

	User::LeaveIfError(iTelServer.Connect());

	iTelServerIsOpen = ETrue;

	TBuf<KCommsDbSvrMaxFieldLength> tsyName;

	GetCommDbTSYnameL(tsyName);

	User::LeaveIfError(iTelServer.LoadPhoneModule(tsyName));

	TInt numPhones;

	User::LeaveIfError(iTelServer.EnumeratePhones(numPhones));

	TInt phoneIndx;

	TInt ret = KErrHardwareNotAvailable;

	for(phoneIndx=0; phoneIndx<numPhones; phoneIndx++)

		{

		RTelServer::TPhoneInfo tInfo;

		ret = iTelServer.GetPhoneInfo(phoneIndx, tInfo);

		if(ret != KErrNone)

			{

			continue;

			}

		ret = iPhone.Open(iTelServer, tInfo.iName);	

		if(ret != KErrNone)

			{

			continue;

			}

		iPhoneIsOpen = ETrue;

		RPhone::TStatus status;

		User::LeaveIfError(iPhone.GetStatus(status));

		if(status.iModemDetected!=RPhone::EDetectedPresent)

			{

			ret = iPhone.Initialise();

			if(ret != KErrNone)

				{

				iPhone.Close();

				iPhoneIsOpen = EFalse;

				continue;

				}

			}

        // we found the correct phone

        break;

		}

	//

	// ret will be KErrNone if a valid phone was found...

	//

    LOG1( "CLocationManagerServer::InitialisePhoneL(), end. Err - %d", ret );

	User::LeaveIfError(ret);

	}

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

// CLocationManagerServer::CancelRequests()

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

//

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

	}

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

// CLocationManagerServer::CancelCopyRequests

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

//

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

	}

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

// CLocationManagerServer::HandleSessionOpened

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

//

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

	{

	LOG ("CLocationManagerServer::HandleSessionOpened() start");

	if ( iASW && iASW->IsStarted() )

		{

		iASW->AsyncStop();

		}

	if ( KErrNone == aError )

		{

		iSessionReady = ETrue;

		TRAP_IGNORE( iTrackLog->StartRecoveryL() );

	    iLocationRecord->SetMdeSession( iMdeSession );

		}

	else

		{

		iSessionReady = EFalse;

		delete iMdeSession;

		iMdeSession = NULL;

		}

	}

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

// CLocationManagerServer::HandleSessionError

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

//

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

	{

	LOG1 ("CLocationManagerServer::HandleSessionError() start, Error - %d", aError);

    ARG_USED(aError);

	iSessionReady = EFalse;

	delete iMdeSession;

	iMdeSession = NULL;

	if ( iASW && iASW->IsStarted() )

		{

		iASW->AsyncStop();

		}	

	}

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

// CLocationManagerServer::IsSessionReady

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

//

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 )

    	{

    	return;

    	}

    iCaptureSetting = aCaptureSetting;

    RLocationTrail::TTrailState state;

    GetLocationTrailState( state );