/*

* Copyright (c) 2002-2005 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: 

*     This file contains the methods which interface with Location Acquisition 

*     API for getting location information 

*

*/

// INCLUDE FILES

#include <evtmgmteditorui.rsg>

#include <f32file.h>

#include <sysutil.h>

#include <lbs/epos_cposmoduleidlist.h>

#include <lbs/epos_cposmodules.h>

#include <aknnotewrappers.h> 

#include <eikenv.h>

#include <StringLoader.h>

#include <centralrepository.h>

#include "locnotprefplugindomaincrkeys.h"

#include "evtmgmtuilocationserviceadapter.h"

#include "evteditorconsts.h"

#include "evtdebug.h"

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

// CEvtMgmtUiLocationServiceAdapter::NewL

// Two-phased constructor.

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

CEvtMgmtUiLocationServiceAdapter* CEvtMgmtUiLocationServiceAdapter::NewL( MEvtMgmtUiLocationServiceObserver& aObserver )

	{

	CEvtMgmtUiLocationServiceAdapter* self = new ( ELeave ) CEvtMgmtUiLocationServiceAdapter( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CEvtMgmtUiLocationServiceAdapter::~CEvtMgmtUiLocationServiceAdapter

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

CEvtMgmtUiLocationServiceAdapter::~CEvtMgmtUiLocationServiceAdapter()

    {

    EVTUIDEBUG("+ CEvtMgmtUiLocationServiceAdapter::~CEvtMgmtUiLocationServiceAdapter()" );

    Cancel();

    iPositioner.Close();

    iServer.Close();

    EVTUIDEBUG("- CEvtMgmtUiLocationServiceAdapter::~CEvtMgmtUiLocationServiceAdapter()" );

    }

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

// CEvtMgmtUiLocationServiceAdapter::ConstructL

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

void CEvtMgmtUiLocationServiceAdapter::ConstructL()

	{

	//conect to position server

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

	//create subsesion with server

	User::LeaveIfError(iPositioner.Open( iServer ));

	//set timeout value

	TPositionUpdateOptions updateOptions;        

	updateOptions.SetUpdateTimeOut( TTimeIntervalMicroSeconds(KLocAcqTimeOut));

	User::LeaveIfError( iPositioner.SetUpdateOptions(updateOptions) );

	//set requestor

    _LIT(KRequestorName, "LocationSerivce");    

	User::LeaveIfError( iPositioner.SetRequestor( 

	                    CRequestor::ERequestorService,

	                    CRequestor::EFormatApplication,

	                    KRequestorName )); 

	//add to active scheduler for asychrnous operation

	 CActiveScheduler::Add( this );

	}

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

// CLmkLocationService::CLmkLocationService

// C++ default constructor can NOT contain any code, that

// might leave.

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

CEvtMgmtUiLocationServiceAdapter::CEvtMgmtUiLocationServiceAdapter( MEvtMgmtUiLocationServiceObserver& aObserver ) 

: CActive(EPriorityStandard), iObserver( aObserver )

    {   

    }

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

// CEvtMgmtUiLocationServiceAdapter::LocationRequestL

// It is used to request current location

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

 void CEvtMgmtUiLocationServiceAdapter::LocationRequestL()

	{    

	EVTUIDEBUG("+ CEvtMgmtUiLocationServiceAdapter::LocationRequestL()" );

	if ( IsActive() )

        {

        User::Leave( KErrInUse );            

        }

    SetActive();

    iStatus = KRequestPending;

	iPositioner.NotifyPositionUpdate( iPositionInfo, iStatus );  

	EVTUIDEBUG("- CEvtMgmtUiLocationServiceAdapter::LocationRequestL()" );      	

	}

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

// CEvtMgmtUiLocationServiceAdapter::CurrentPosition

// It is used to retrieve current location

// @ret Recently retrieved current location 

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

TPosition& CEvtMgmtUiLocationServiceAdapter::CurrentPosition()

	{

	return iPosition;

	}

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

// CEvtMgmtUiLocationServiceAdapter::AllPositionMethodsDisabled

// Check if all positioning methods are disabled.

// @ret true if disabled else false

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

//

TBool CEvtMgmtUiLocationServiceAdapter::AllPositionMethodsDisabledL()

    {

    CPosModules* moduleDb = CPosModules::OpenL();

    CleanupStack::PushL(moduleDb);

    CPosModuleIdList* psyList = moduleDb->ModuleIdListL();

    CleanupStack::PushL(psyList);

    TBool allDisabled =ETrue;

    TPositionModuleInfo moduleInfo;

     for(TInt index=0; index< psyList->Count(); index++)

         {

        TPositionModuleId moduleId = psyList->At( index );

        TRAPD(error, moduleDb->GetModuleInfoL( moduleId, moduleInfo););

        if(error == KErrNone ) 

            {

            if( moduleInfo.IsAvailable() )

                {

                allDisabled = EFalse;

                break;

                }

            }        

         }

    CleanupStack::PopAndDestroy(2); // psyList, moduleDb

    return allDisabled;

    }

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

// CEvtMgmtUiLocationServiceAdapter::CancelRequest

// It is used to cancel recently issued location request

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

void CEvtMgmtUiLocationServiceAdapter::CancelRequest()

	{

	Cancel();

	TRAP_IGNORE( iObserver.HandleLocationServiceErrorL( KErrCancel ) );

	}

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

// CEvtMgmtUiLocationServiceAdapter::RunL

// Derived from CActive

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

void CEvtMgmtUiLocationServiceAdapter::RunL()

	{

    EVTUIDEBUG1("+ CEvtMgmtUiLocationServiceAdapter::RunL() - %d", iStatus.Int() );

   //TInt err = KErrTimedOut;

   //switch ( err )

   switch ( iStatus.Int() )

		{

		case KErrNone:

		case KPositionPartialUpdate:        

			{

			//retrieve current location information

			iPositionInfo.GetPosition( iPosition );

			TReal32 altitude = iPosition.Altitude();

			if ( Math::IsNaN( altitude ) )

				{

				TRealX nan;

				nan.SetNaN();

				iPosition.SetVerticalAccuracy( nan );	

				}	

			//notify observer about successful completion of operation

			iObserver.HandleLocationServiceResponseL( iStatus.Int() );

			break;

			}

		case KErrAccessDenied:			

		case KPositionQualityLoss:

		case KErrTimedOut:

		case KErrNotFound: // No PSY selected.

		case KErrUnknown:

		case KErrCancel:

		case KErrArgument:

		default:

			{		

		    TRAP_IGNORE( iObserver.HandleLocationServiceErrorL( iStatus.Int() ) );

			break;

			}

		}

	}	

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

// CEvtMgmtUiLocationServiceAdapter::RunError

// Derived from CActive

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

//

TInt CEvtMgmtUiLocationServiceAdapter::RunError(TInt aError)

    {

    TRAP_IGNORE( iObserver.HandleLocationServiceErrorL( aError ) );

    return KErrNone;

    }

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

// CEvtMgmtUiLocationServiceAdapter::DoCancel

// Derived from CActive

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

//

void CEvtMgmtUiLocationServiceAdapter::DoCancel()

    {

    EVTUIDEBUG("+ CEvtMgmtUiLocationServiceAdapter::DoCancel()" );

    iPositioner.CancelRequest( EPositionerNotifyPositionUpdate );

    EVTUIDEBUG("- CEvtMgmtUiLocationServiceAdapter::DoCancel()" );

    }

// End of File