forked from mirrors/gecko-dev
446 lines
11 KiB
C++
446 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "GpsdLocationProvider.h"
|
|
#include <errno.h>
|
|
#include <gps.h>
|
|
#include "MLSFallback.h"
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
#include "mozilla/LazyIdleThread.h"
|
|
#include "mozilla/dom/GeolocationPositionErrorBinding.h"
|
|
#include "GeolocationPosition.h"
|
|
#include "nsProxyRelease.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "prtime.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
//
|
|
// MLSGeolocationUpdate
|
|
//
|
|
|
|
/**
|
|
* |MLSGeolocationUpdate| provides a fallback if gpsd is not supported.
|
|
*/
|
|
class GpsdLocationProvider::MLSGeolocationUpdate final
|
|
: public nsIGeolocationUpdate {
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIGEOLOCATIONUPDATE
|
|
|
|
explicit MLSGeolocationUpdate(nsIGeolocationUpdate* aCallback);
|
|
|
|
protected:
|
|
~MLSGeolocationUpdate() = default;
|
|
|
|
private:
|
|
nsCOMPtr<nsIGeolocationUpdate> mCallback;
|
|
};
|
|
|
|
GpsdLocationProvider::MLSGeolocationUpdate::MLSGeolocationUpdate(
|
|
nsIGeolocationUpdate* aCallback)
|
|
: mCallback(aCallback) {
|
|
MOZ_ASSERT(mCallback);
|
|
}
|
|
|
|
// nsISupports
|
|
//
|
|
|
|
NS_IMPL_ISUPPORTS(GpsdLocationProvider::MLSGeolocationUpdate,
|
|
nsIGeolocationUpdate);
|
|
|
|
// nsIGeolocationUpdate
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::MLSGeolocationUpdate::Update(
|
|
nsIDOMGeoPosition* aPosition) {
|
|
nsCOMPtr<nsIDOMGeoPositionCoords> coords;
|
|
aPosition->GetCoords(getter_AddRefs(coords));
|
|
if (!coords) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return mCallback->Update(aPosition);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::MLSGeolocationUpdate::NotifyError(uint16_t aError) {
|
|
return mCallback->NotifyError(aError);
|
|
}
|
|
|
|
//
|
|
// UpdateRunnable
|
|
//
|
|
|
|
class GpsdLocationProvider::UpdateRunnable final : public Runnable {
|
|
public:
|
|
UpdateRunnable(
|
|
const nsMainThreadPtrHandle<GpsdLocationProvider>& aLocationProvider,
|
|
nsIDOMGeoPosition* aPosition)
|
|
: Runnable("GpsdU"),
|
|
mLocationProvider(aLocationProvider),
|
|
mPosition(aPosition) {
|
|
MOZ_ASSERT(mLocationProvider);
|
|
MOZ_ASSERT(mPosition);
|
|
}
|
|
|
|
// nsIRunnable
|
|
//
|
|
|
|
NS_IMETHOD Run() override {
|
|
mLocationProvider->Update(mPosition);
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
nsMainThreadPtrHandle<GpsdLocationProvider> mLocationProvider;
|
|
RefPtr<nsIDOMGeoPosition> mPosition;
|
|
};
|
|
|
|
//
|
|
// NotifyErrorRunnable
|
|
//
|
|
|
|
class GpsdLocationProvider::NotifyErrorRunnable final : public Runnable {
|
|
public:
|
|
NotifyErrorRunnable(
|
|
const nsMainThreadPtrHandle<GpsdLocationProvider>& aLocationProvider,
|
|
int aError)
|
|
: Runnable("GpsdNE"),
|
|
mLocationProvider(aLocationProvider),
|
|
mError(aError) {
|
|
MOZ_ASSERT(mLocationProvider);
|
|
}
|
|
|
|
// nsIRunnable
|
|
//
|
|
|
|
NS_IMETHOD Run() override {
|
|
mLocationProvider->NotifyError(mError);
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
nsMainThreadPtrHandle<GpsdLocationProvider> mLocationProvider;
|
|
int mError;
|
|
};
|
|
|
|
//
|
|
// PollRunnable
|
|
//
|
|
|
|
/**
|
|
* |PollRunnable| does the main work of processing GPS data received
|
|
* from gpsd. libgps blocks while polling, so this runnable has to be
|
|
* executed on it's own thread. To cancel the poll runnable, invoke
|
|
* |StopRunning| and |PollRunnable| will stop within a reasonable time
|
|
* frame.
|
|
*/
|
|
class GpsdLocationProvider::PollRunnable final : public Runnable {
|
|
public:
|
|
PollRunnable(
|
|
const nsMainThreadPtrHandle<GpsdLocationProvider>& aLocationProvider)
|
|
: Runnable("GpsdP"),
|
|
mLocationProvider(aLocationProvider),
|
|
mRunning(true) {
|
|
MOZ_ASSERT(mLocationProvider);
|
|
}
|
|
|
|
static bool IsSupported() {
|
|
return GPSD_API_MAJOR_VERSION >= 5 && GPSD_API_MAJOR_VERSION <= 12;
|
|
}
|
|
|
|
bool IsRunning() const { return mRunning; }
|
|
|
|
void StopRunning() { mRunning = false; }
|
|
|
|
// nsIRunnable
|
|
//
|
|
|
|
NS_IMETHOD Run() override {
|
|
int err;
|
|
|
|
switch (GPSD_API_MAJOR_VERSION) {
|
|
case 5 ... 12:
|
|
err = PollLoop5();
|
|
break;
|
|
default:
|
|
err = GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
|
|
break;
|
|
}
|
|
|
|
if (err) {
|
|
NS_DispatchToMainThread(
|
|
MakeAndAddRef<NotifyErrorRunnable>(mLocationProvider, err));
|
|
}
|
|
|
|
mLocationProvider = nullptr;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
protected:
|
|
int PollLoop5() {
|
|
#if GPSD_API_MAJOR_VERSION >= 5 && GPSD_API_MAJOR_VERSION <= 12
|
|
static const int GPSD_WAIT_TIMEOUT_US =
|
|
1000000; /* us to wait for GPS data */
|
|
|
|
struct gps_data_t gpsData;
|
|
|
|
auto res = gps_open(nullptr, nullptr, &gpsData);
|
|
|
|
if (res < 0) {
|
|
return ErrnoToError(errno);
|
|
}
|
|
|
|
gps_stream(&gpsData, WATCH_ENABLE | WATCH_JSON, NULL);
|
|
|
|
int err = 0;
|
|
|
|
// nsGeoPositionCoords will convert NaNs to null for optional properties of
|
|
// the JavaScript Coordinates object.
|
|
double lat = 0;
|
|
double lon = 0;
|
|
double alt = UnspecifiedNaN<double>();
|
|
double hError = 0;
|
|
double vError = UnspecifiedNaN<double>();
|
|
double heading = UnspecifiedNaN<double>();
|
|
double speed = UnspecifiedNaN<double>();
|
|
|
|
while (IsRunning()) {
|
|
errno = 0;
|
|
auto hasGpsData = gps_waiting(&gpsData, GPSD_WAIT_TIMEOUT_US);
|
|
|
|
if (errno) {
|
|
err = ErrnoToError(errno);
|
|
break;
|
|
}
|
|
if (!hasGpsData) {
|
|
continue; /* woke up from timeout */
|
|
}
|
|
|
|
# if GPSD_API_MAJOR_VERSION >= 7
|
|
res = gps_read(&gpsData, nullptr, 0);
|
|
# else
|
|
|
|
res = gps_read(&gpsData);
|
|
# endif
|
|
|
|
if (res < 0) {
|
|
err = ErrnoToError(errno);
|
|
break;
|
|
} else if (!res) {
|
|
continue; /* no data available */
|
|
}
|
|
|
|
# if GPSD_API_MAJOR_VERSION < 10
|
|
if (gpsData.status == STATUS_NO_FIX) {
|
|
continue;
|
|
}
|
|
# endif
|
|
|
|
switch (gpsData.fix.mode) {
|
|
case MODE_3D:
|
|
double galt;
|
|
|
|
# if GPSD_API_MAJOR_VERSION >= 9
|
|
galt = gpsData.fix.altMSL;
|
|
# else
|
|
galt = gpsData.fix.altitude;
|
|
# endif
|
|
if (!std::isnan(galt)) {
|
|
alt = galt;
|
|
}
|
|
[[fallthrough]];
|
|
case MODE_2D:
|
|
if (!std::isnan(gpsData.fix.latitude)) {
|
|
lat = gpsData.fix.latitude;
|
|
}
|
|
if (!std::isnan(gpsData.fix.longitude)) {
|
|
lon = gpsData.fix.longitude;
|
|
}
|
|
if (!std::isnan(gpsData.fix.epx) && !std::isnan(gpsData.fix.epy)) {
|
|
hError = std::max(gpsData.fix.epx, gpsData.fix.epy);
|
|
} else if (!std::isnan(gpsData.fix.epx)) {
|
|
hError = gpsData.fix.epx;
|
|
} else if (!std::isnan(gpsData.fix.epy)) {
|
|
hError = gpsData.fix.epy;
|
|
}
|
|
if (!std::isnan(gpsData.fix.epv)) {
|
|
vError = gpsData.fix.epv;
|
|
}
|
|
if (!std::isnan(gpsData.fix.track)) {
|
|
heading = gpsData.fix.track;
|
|
}
|
|
if (!std::isnan(gpsData.fix.speed)) {
|
|
speed = gpsData.fix.speed;
|
|
}
|
|
break;
|
|
default:
|
|
continue; // There's no useful data in this fix; continue.
|
|
}
|
|
|
|
NS_DispatchToMainThread(MakeAndAddRef<UpdateRunnable>(
|
|
mLocationProvider,
|
|
new nsGeoPosition(lat, lon, alt, hError, vError, heading, speed,
|
|
PR_Now() / PR_USEC_PER_MSEC)));
|
|
}
|
|
|
|
gps_stream(&gpsData, WATCH_DISABLE, NULL);
|
|
gps_close(&gpsData);
|
|
|
|
return err;
|
|
#else
|
|
return GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
|
|
#endif // GPSD_MAJOR_API_VERSION
|
|
}
|
|
|
|
static int ErrnoToError(int aErrno) {
|
|
switch (aErrno) {
|
|
case EACCES:
|
|
[[fallthrough]];
|
|
case EPERM:
|
|
[[fallthrough]];
|
|
case EROFS:
|
|
return GeolocationPositionError_Binding::PERMISSION_DENIED;
|
|
case ETIME:
|
|
[[fallthrough]];
|
|
case ETIMEDOUT:
|
|
return GeolocationPositionError_Binding::TIMEOUT;
|
|
default:
|
|
return GeolocationPositionError_Binding::POSITION_UNAVAILABLE;
|
|
}
|
|
}
|
|
|
|
private:
|
|
nsMainThreadPtrHandle<GpsdLocationProvider> mLocationProvider;
|
|
Atomic<bool> mRunning;
|
|
};
|
|
|
|
//
|
|
// GpsdLocationProvider
|
|
//
|
|
|
|
const uint32_t GpsdLocationProvider::GPSD_POLL_THREAD_TIMEOUT_MS = 5000;
|
|
|
|
GpsdLocationProvider::GpsdLocationProvider() {}
|
|
|
|
GpsdLocationProvider::~GpsdLocationProvider() {}
|
|
|
|
void GpsdLocationProvider::Update(nsIDOMGeoPosition* aPosition) {
|
|
if (!mCallback || !mPollRunnable) {
|
|
return; // not initialized or already shut down
|
|
}
|
|
|
|
if (mMLSProvider) {
|
|
/* We got a location from gpsd, so let's cancel our MLS fallback. */
|
|
mMLSProvider->Shutdown();
|
|
mMLSProvider = nullptr;
|
|
}
|
|
|
|
mCallback->Update(aPosition);
|
|
}
|
|
|
|
void GpsdLocationProvider::NotifyError(int aError) {
|
|
if (!mCallback) {
|
|
return; // not initialized or already shut down
|
|
}
|
|
|
|
if (!mMLSProvider) {
|
|
/* With gpsd failed, we restart MLS. It will be canceled once we
|
|
* get another location from gpsd.
|
|
*/
|
|
mMLSProvider = MakeAndAddRef<MLSFallback>();
|
|
mMLSProvider->Startup(new MLSGeolocationUpdate(mCallback));
|
|
}
|
|
|
|
mCallback->NotifyError(aError);
|
|
}
|
|
|
|
// nsISupports
|
|
//
|
|
|
|
NS_IMPL_ISUPPORTS(GpsdLocationProvider, nsIGeolocationProvider)
|
|
|
|
// nsIGeolocationProvider
|
|
//
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::Startup() {
|
|
if (!PollRunnable::IsSupported()) {
|
|
return NS_OK; // We'll fall back to MLS.
|
|
}
|
|
|
|
if (mPollRunnable) {
|
|
return NS_OK; // already running
|
|
}
|
|
|
|
RefPtr<PollRunnable> pollRunnable =
|
|
MakeAndAddRef<PollRunnable>(nsMainThreadPtrHandle<GpsdLocationProvider>(
|
|
new nsMainThreadPtrHolder<GpsdLocationProvider>("GpsdLP", this)));
|
|
|
|
// Use existing poll thread...
|
|
RefPtr<LazyIdleThread> pollThread = mPollThread;
|
|
|
|
// ... or create a new one.
|
|
if (!pollThread) {
|
|
pollThread = MakeAndAddRef<LazyIdleThread>(GPSD_POLL_THREAD_TIMEOUT_MS,
|
|
"Gpsd poll thread",
|
|
LazyIdleThread::ManualShutdown);
|
|
}
|
|
|
|
auto rv = pollThread->Dispatch(pollRunnable, NS_DISPATCH_NORMAL);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
mPollRunnable = pollRunnable.forget();
|
|
mPollThread = pollThread.forget();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::Watch(nsIGeolocationUpdate* aCallback) {
|
|
mCallback = aCallback;
|
|
|
|
/* The MLS fallback will kick in after a few seconds if gpsd
|
|
* doesn't provide location information within time. Once we
|
|
* see the first message from gpsd, the fallback will be
|
|
* disabled in |Update|.
|
|
*/
|
|
mMLSProvider = MakeAndAddRef<MLSFallback>();
|
|
mMLSProvider->Startup(new MLSGeolocationUpdate(aCallback));
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::Shutdown() {
|
|
if (mMLSProvider) {
|
|
mMLSProvider->Shutdown();
|
|
mMLSProvider = nullptr;
|
|
}
|
|
|
|
if (!mPollRunnable) {
|
|
return NS_OK; // not running
|
|
}
|
|
|
|
mPollRunnable->StopRunning();
|
|
mPollRunnable = nullptr;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
GpsdLocationProvider::SetHighAccuracy(bool aHigh) { return NS_OK; }
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|