/*

* Copyright (c) 2008 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:  Handles LocationProvider operations

 *

*/

// INCLUDE FILES

#include <e32std.h>

#include <f32file.h>

#include "clocationprovider.h"

#include "cpositioner.h"

#include "ctrackingpositioner.h"

#include "cdelaystatechangetimer.h"

#include "javax_microedition_location_LocationProvider.h"

#include "javax_microedition_location_Location.h"

#include "com_nokia_mj_impl_location_LocationProviderImpl.h"

#include "locationfunctionserver.h"

#include "fs_methodcall.h"

#include "logger.h"

using namespace java::location;

// CONSTANTS

const TInt KAvailable =

    com_nokia_mj_impl_location_LocationProviderImpl_AVAILABLE;

const TInt KTemporarilyUnavailable =

    com_nokia_mj_impl_location_LocationProviderImpl_TEMPORARILY_UNAVAILABLE;

const TInt KOutOfService =

    com_nokia_mj_impl_location_LocationProviderImpl_OUT_OF_SERVICE;

const TInt KAddressInfo =

    com_nokia_mj_impl_location_LocationProviderImpl_ADDRESS_REQUIRED;

const TInt KCostAllowed =

    com_nokia_mj_impl_location_LocationProviderImpl_COST_ALLOWED;

const TInt KAltitude =

    com_nokia_mj_impl_location_LocationProviderImpl_ALTITUDE_REQUIRED;

const TInt KSpeedAndCourse =

    com_nokia_mj_impl_location_LocationProviderImpl_SPEED_AND_COURSE_REQUIRED;

const TInt KMteSatellite = javax_microedition_location_Location_MTE_SATELLITE;

const TInt KMtyTerminalbased =

    javax_microedition_location_Location_MTY_TERMINALBASED;

const TInt KMtyNetworkbased =

    javax_microedition_location_Location_MTY_NETWORKBASED;

const TInt KMtaAssisted = javax_microedition_location_Location_MTA_ASSISTED;

const TInt KMtaUnassisted = javax_microedition_location_Location_MTA_UNASSISTED;

const TInt KAvailableToTempUnavailableDelay = 5000000; // 5 seconds

const TInt KTempUnavailableToAvailableDelay = 2000000; // 2 seconds

// ============================ MEMBER FUNCTIONS ===============================

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

// CLocationProvider::CLocationProvider

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

// might leave.

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

//

CLocationProvider::CLocationProvider(LocationFunctionServer* aFunctionSource) :

        CActive(EPriorityNormal), mFunctionServer(aFunctionSource), iStatusEvent(

            TPositionModuleStatusEvent::EEventAll), iState(KAvailable)

{

}

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

// CLocationProvider::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLocationProvider::ConstructL()

{

    CActiveScheduler::Add(this);

    JELOG2(EJavaLocation);

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

    iStateTimer = CDelayStateChangeTimer::NewL(this);

}

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

// CLocationProvider::NewL

// Two-phased constructor.

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

//

void CLocationProvider::NewL(LocationFunctionServer* aFunctionSource,

                             TInt* aHandle)

{

    JELOG2(EJavaLocation);

    CLocationProvider* self = new(ELeave) CLocationProvider(aFunctionSource);

    CleanupStack::PushL(self);

    CallMethodL(self, &CLocationProvider::ConstructL, self->mFunctionServer);

    CleanupStack::Pop(self);

    *aHandle = reinterpret_cast<TInt>(self);

}

// Destructor

CLocationProvider::~CLocationProvider()

{

    JELOG2(EJavaLocation);

    Cancel();

    delete iStateTimer;

    delete iTrackingPositioner;

    iPositionServer.Close();

}

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

// CLocationProvider::StaticCreatePositionerL

// (other items were commented in a header).

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

//

void CLocationProvider::StaticCreatePositionerL(JNIEnv* aJni,

        jobject aJavaPositioner, CLocationProvider* aSelf, TInt* aHandle,

        LocationFunctionServer* aFunctionSource)

{

    JELOG2(EJavaLocation);

    CPositioner* positioner = NULL;

    TRAPD(error, CallMethodL(positioner, aSelf,

                             &CLocationProvider::CreatePositionerL, aFunctionSource));

    if ((error != KErrNone) || (positioner == NULL))

    {

        ELOG1(EJavaLocation, "StaticCreatePositionerL - error=%d", error);

        *aHandle = error;

        return;

    }

    // Positioner takes ownership of the event since it is reusable

    positioner->SetCallBackData(aJavaPositioner, aJni);

    *aHandle = reinterpret_cast<TInt>(positioner);

}

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

// CLocationProvider::RunL

// (other items were commented in a header).

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

//

void CLocationProvider::RunL()

{

    JELOG2(EJavaLocation);

    if (iStatus == KErrNone)

    {

        iStateTimer->Cancel();

        TPositionModuleStatus moduleStatus;

        iStatusEvent.GetModuleStatus(moduleStatus);

        TInt newState = StatusToState(moduleStatus);

        if (newState == KTemporarilyUnavailable && iState == KAvailable)

        {

            iStateTimer->ChangeStateAfter(KAvailableToTempUnavailableDelay,

                                          newState);

        }

        else if (newState == KAvailable && iState == KTemporarilyUnavailable)

        {

            iStateTimer->ChangeStateAfter(KTempUnavailableToAvailableDelay,

                                          newState);

        }

        else

        {

            ChangeState(newState);

        }

    }

    RequestModuleStatus();

}

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

// CLocationProvider::DoCancel

// (other items were commented in a header).

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

//

void CLocationProvider::DoCancel()

{

    JELOG2(EJavaLocation);

    iStateTimer->Cancel();

    iPositionServer.CancelRequest(EPositionServerNotifyModuleStatusEvent);

}

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

// CLocationProvider::CreatePositionerL

// (other items were commented in a header).

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

//

CPositioner* CLocationProvider::CreatePositionerL()

{

    JELOG2(EJavaLocation);

    CPositioner* positioner = CPositioner::NewL(mFunctionServer,

                              iPositionServer, iModuleId, iCapabilities);

    return positioner;

}

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

// CLocationProvider::SelectModuleL

//

// Selects a positioning module. Prefers modules in AVAILABLE state.

//   Leaves with KErrNotSupported if no module match the requirements.

//   Leaves with KErrNotFound if no modules are available.

// (other items were commented in a header).

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

//

void CLocationProvider::SelectModuleL(TInt aHacc, TInt aVacc, TInt aRespTime,

                                      TInt aPower, TInt aRequiredFlags, TInt* aMethodTimeout)

{

    JELOG2(EJavaLocation);

    mJni = mFunctionServer->getValidJniEnv();

    mPeer = mFunctionServer->getPeer();

    jclass peerClass = (*mJni).GetObjectClass(mPeer);

    //Get Method ID of Azimuth Data Callback

    mStateChangMethod = mJni->GetMethodID(peerClass, "stateChange", "(I)V");

    if (AllLocationRequestsDeniedL())

    {

        User::Leave(KErrNotFound); // Location is off, no modules can be used

    }

    TBool allModulesOutOfService(ETrue);

    TPositionModuleInfo modInfo;

    // Check if requirements are met for available modules

    TUint numModules(0);

    User::LeaveIfError(iPositionServer.GetNumModules(numModules));

    for (TUint i = 0; i < numModules; ++i)

    {

        User::LeaveIfError(iPositionServer.GetModuleInfoByIndex(i, modInfo));

        if (modInfo.IsAvailable())

        {

            TPositionQuality moduleQuality;

            modInfo.GetPositionQuality(moduleQuality);

            if (CheckRequirements(moduleQuality, modInfo.Capabilities(), aHacc,

                                  aVacc, aRespTime, aPower, aRequiredFlags))

            {

                iModuleId = modInfo.ModuleId();

                break;

            }

            allModulesOutOfService = EFalse;

        }

    }

    if (iModuleId == KPositionNullModuleId) // No module found

    {

        User::Leave(allModulesOutOfService ? KErrNotFound : KErrNotSupported);

    }

    RequestModuleStatus();

    iCapabilities = modInfo.Capabilities();

    iTrackingPositioner = CTrackingPositioner::NewL(mFunctionServer,

                          iPositionServer, iModuleId, iCapabilities);

    TInt locationMethod = (iCapabilities

                           & TPositionModuleInfo::ECapabilitySatellite) ? KMteSatellite : 0;

    TInt tech = modInfo.TechnologyType();

    TBool networkBased = EFalse;

    if (tech & TPositionModuleInfo::ETechnologyTerminal)

    {

        locationMethod |= KMtyTerminalbased;

    }

    if (tech & TPositionModuleInfo::ETechnologyNetwork)

    {

        locationMethod |= KMtyNetworkbased;

        networkBased = ETrue;

    }

    TPositionQuality quality;

    modInfo.GetPositionQuality(quality);

    iTrackingPositioner->SetDefaultValues(quality.TimeToNextFix(), networkBased);

    locationMethod

    |= (tech & TPositionModuleInfo::ETechnologyAssisted) ? KMtaAssisted

       : KMtaUnassisted;

    aMethodTimeout[0] = locationMethod;

    // Default timeout is set to TTFF * 2

    aMethodTimeout[1] = (I64INT(quality.TimeToFirstFix().Int64()) * 2)

                        / 1000000;

}

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

// CLocationProvider::CheckRequirements

//

// Returns ETrue if requirements are met, EFalse otherwise.

// (other items were commented in a header).

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

//

TBool CLocationProvider::CheckRequirements(const TPositionQuality& aQuality,

        TPositionModuleInfo::TCapabilities aCaps, TInt aHacc, TInt aVacc,

        TInt aRespTime, TInt aPower, TInt aRequiredFlags)

{

    JELOG2(EJavaLocation);

    if ((aRequiredFlags & KAddressInfo) && !(aCaps

            & (TPositionModuleInfo::ECapabilityAddress

               | TPositionModuleInfo::ECapabilityBuilding

               | TPositionModuleInfo::ECapabilityMedia)))

    {

        return EFalse;

    }

    if ((aRequiredFlags & KAltitude) && !(aCaps

                                          & TPositionModuleInfo::ECapabilityVertical))

    {

        return EFalse;

    }

    if ((aRequiredFlags & KSpeedAndCourse) && !((aCaps

            & TPositionModuleInfo::ECapabilitySpeed) && (aCaps

                    & TPositionModuleInfo::ECapabilityDirection)))

    {

        return EFalse;

    }

    if (!(aRequiredFlags & KCostAllowed) && aQuality.CostIndicator()

            != TPositionQuality::ECostZero)

    {

        return EFalse;

    }

    if (aHacc != 0 && aQuality.HorizontalAccuracy() > aHacc)

    {

        return EFalse;

    }

    if (aVacc != 0 && aQuality.VerticalAccuracy() > aVacc)

    {

        return EFalse;

    }

    if (aRespTime != 0 && (aQuality.TimeToNextFix().Int64() / 1000) > aRespTime)

    {

        return EFalse;

    }

    if (aPower > 0 && aPower < 3) // LOW or MEDIUM

    {

        switch (aQuality.PowerConsumption())

        {

        case TPositionQuality::EPowerHigh: // Fall through

        case TPositionQuality::EPowerUnknown:

            return EFalse;

        case TPositionQuality::EPowerMedium:

            if (aPower == 1)

            {

                return EFalse;

            }

        default:

            break;

        }

    }

    return ETrue;

}

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

// CLocationProvider::RequestModuleStatus

// (other items were commented in a header).

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

//

void CLocationProvider::RequestModuleStatus()

{

    JELOG2(EJavaLocation);

    iPositionServer.NotifyModuleStatusEvent(iStatusEvent, iStatus, iModuleId);

    SetActive();

}

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

// CLocationProvider::StatusToState

// (other items were commented in a header).

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

//

TInt CLocationProvider::StatusToState(TPositionModuleStatus& aStatus)

{

    JELOG2(EJavaLocation);

    switch (aStatus.DeviceStatus())

    {

    case TPositionModuleStatus::EDeviceUnknown: // Illegal state => Out of service

    case TPositionModuleStatus::EDeviceError:

    case TPositionModuleStatus::EDeviceDisabled:

        return KOutOfService;

    case TPositionModuleStatus::EDeviceInactive:

    case TPositionModuleStatus::EDeviceInitialising:

        return KAvailable;

    case TPositionModuleStatus::EDeviceStandBy:

    case TPositionModuleStatus::EDeviceReady:

    case TPositionModuleStatus::EDeviceActive:

        if (aStatus.DataQualityStatus()

                == TPositionModuleStatus::EDataQualityLoss)

        {

            return KTemporarilyUnavailable;

        }

        else

        {

            return KAvailable;

        }

    default:

        return KOutOfService;

    }

}

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

// CLocationProvider::ChangeState

// (other items were commented in a header).

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

//

void CLocationProvider::ChangeState(TInt aState)

{

    if (aState != iState)

    {

        mJni = mFunctionServer->getValidJniEnv();

        mPeer = mFunctionServer->getPeer();

        (*mJni).CallVoidMethod(mPeer, mStateChangMethod, aState);

        iState = aState;

    }

}

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

// CLocationProvider::AllLocationRequestsDeniedL

// (other items were commented in a header).

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

//

TBool CLocationProvider::AllLocationRequestsDeniedL()

{

    // Global privacy not used anymore

    return EFalse;

}