Merge lp:~thomas-voss/location-service/enable-assist-now-online into lp:location-service

[Thomas Voß]

Enable AssistNow for ublox 8 receivers.

Support assisted GNSS scenarios and add infrastructure to
query the ublox AssistNow online service.

Enable AssistNow for ublox 8 receivers.

Support assisted GNSS scenarios and add infrastructure to
query the ublox AssistNow online service.

[Simon Fels (morphis)]

review: Needs Fixing

[lp:~thomas-voss/location-service/enable-assist-now-online]

297. By Thomas Voß on 2017-03-23

Document dropping of exceptions in Receiver::process_chunk.

[Simon Fels (morphis)]

LGTM

review: Approve

[lp:~thomas-voss/location-service/enable-assist-now-online]

298. By Thomas Voß on 2017-03-24

Introduce locationd.test to the snap.

299. By Thomas Voß on 2017-03-24

Fix a couple of issues found during testing.

300. By Thomas Voß on 2017-03-29

Make the number of trials in testing configurable via an env variable.

=== modified file 'prebuilt/meta/hooks/configure'
--- prebuilt/meta/hooks/configure	2017-01-09 09:16:58 +0000
+++ prebuilt/meta/hooks/configure	2017-03-29 20:24:25 +0000
@@ -4,3 +4,18 @@
     mkdir -p $SNAP_DATA/ubx/provider
     echo "$path" > $SNAP_DATA/ubx/provider/path
 fi
+
+if enable=$(snapctl get ubx.provider.assistnow.enable); then
+    mkdir -p $SNAP_DATA/ubx/provider/assist_now
+    echo "$enable" > $SNAP_DATA/ubx/provider/assist_now/enable
+fi
+
+if token=$(snapctl get ubx.provider.assistnow.token); then
+    mkdir -p $SNAP_DATA/ubx/provider/assist_now
+    echo "$token" > $SNAP_DATA/ubx/provider/assist_now/token
+fi
+
+if timeout=$(snapctl get ubx.provider.assistnow.acquisition_timeout); then
+    mkdir -p $SNAP_DATA/ubx/provider/assist_now
+    echo "$timeout" > $SNAP_DATA/ubx/provider/assist_now/acquisition_timeout
+fi

=== modified file 'snapcraft.yaml'
--- snapcraft.yaml	2017-03-07 10:01:34 +0000
+++ snapcraft.yaml	2017-03-29 20:24:25 +0000
@@ -12,7 +12,7 @@
     daemon: simple
     command: bin/locationd run --bus=system
     slots: [service-control, service-observe]
-    plugs: [ubx, network-manager]
+    plugs: [ubx, network, network-manager]
   list-providers:
     command: bin/locationd list    
   status:
@@ -23,7 +23,10 @@
     plugs: [client-control, client-observe]
   provide:
     command: bin/locationd provider --bus=system
-    plugs: [client-control]
+    plugs: [client-control, network]
+  test:
+    command: bin/locationd test
+    plugs: [ubx, network]
 
 slots:
     service-observe:

=== modified file 'src/location/cmds/run.cpp'
--- src/location/cmds/run.cpp	2017-03-09 10:07:56 +0000
+++ src/location/cmds/run.cpp	2017-03-29 20:24:25 +0000
@@ -74,6 +74,10 @@
         {
             engine->add_provider(location::providers::ubx::Provider::create_instance(ProviderFactory::Configuration{}));
         }
+        catch (const std::exception& e)
+        {
+            ctxt.cout << "Error adding UBX provider: " << e.what() << std::endl;
+        }
         catch (...)
         {
             ctxt.cout << "Error adding UBX provider." << std::endl;

=== modified file 'src/location/cmds/test.cpp'
--- src/location/cmds/test.cpp	2016-06-30 09:15:49 +0000
+++ src/location/cmds/test.cpp	2017-03-29 20:24:25 +0000
@@ -25,8 +25,16 @@
 location::cmds::Test::Test()
     : CommandWithFlagsAndAction{cli::Name{"test"}, cli::Usage{"test"}, cli::Description{"executes runtime tests against the gps provider."}}
 {
+    flag(cli::make_flag(cli::Name{"test-suite"}, cli::Description{"test-suite that should be executed"}, test_suite));
+
     action([this](const Context& ctxt)
     {
-        return location::execute_runtime_tests(ctxt.cout, ctxt.cout);
+        if (not test_suite)
+        {
+            ctxt.cout << "Missing parameter test-suite." << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        return execute_runtime_tests(*test_suite, ctxt.cout, ctxt.cout);
     });
 }

=== modified file 'src/location/cmds/test.h'
--- src/location/cmds/test.h	2016-08-24 14:12:05 +0000
+++ src/location/cmds/test.h	2017-03-29 20:24:25 +0000
@@ -35,6 +35,9 @@
 public:
     // List initializes a new instance.
     Test();
+
+private:
+    Optional<std::string> test_suite;   // The test suite that should be executed.
 };
 }
 }

=== modified file 'src/location/providers/ubx/CMakeLists.txt'
--- src/location/providers/ubx/CMakeLists.txt	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/CMakeLists.txt	2017-03-29 20:24:25 +0000
@@ -7,6 +7,8 @@
 
   bits.h
 
+  _8/assist_now_online_client.h
+  _8/assist_now_online_client.cpp
   _8/checksum.h
   _8/checksum.cpp
   _8/gnss_id.h
@@ -25,11 +27,12 @@
   _8/ack/ack.cpp
   _8/ack/nak.h
   _8/ack/nak.cpp
-  _8/cfg/cfg.h
   _8/cfg/gnss.h
   _8/cfg/gnss.cpp
   _8/cfg/msg.h
   _8/cfg/msg.cpp
+  _8/cfg/rst.h
+  _8/cfg/rst.cpp
   _8/nav/pvt.h
   _8/nav/pvt.cpp
   _8/nav/sat.h

=== added file 'src/location/providers/ubx/_8/assist_now_online_client.cpp'
--- src/location/providers/ubx/_8/assist_now_online_client.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/assist_now_online_client.cpp	2017-03-29 20:24:25 +0000
@@ -0,0 +1,160 @@
+// Copyright (C) 2017 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/assist_now_online_client.h>
+
+#include <core/net/uri.h>
+#include <core/net/http/response.h>
+
+#include <iostream>
+
+namespace _8 = location::providers::ubx::_8;
+namespace http = core::net::http;
+
+namespace
+{
+
+template<typename T>
+std::string join(const std::set<T>& set)
+{
+    std::stringstream ss; bool first = true;
+
+    for (auto element : set)
+    {
+        if (!first)
+            ss << ",";
+
+        ss << element;
+        first = false;
+    }
+
+    return ss.str();
+}
+
+template<typename T, typename U>
+std::string join(const std::set<std::pair<T, U>>& set)
+{
+    std::stringstream ss; bool first = true;
+
+    for (auto element : set)
+    {
+        if (!first)
+            ss << ",";
+
+        ss << element.first << ":" << element.second;
+        first = false;
+    }
+
+    return ss.str();
+}
+
+}  // namespace
+
+_8::AssistNowOnlineClient::AssistNowOnlineClient(const std::shared_ptr<http::Client>& http_client)
+    : http_client{http_client}, worker{[this]() { _8::AssistNowOnlineClient::http_client->run(); }}
+{
+}
+
+_8::AssistNowOnlineClient::~AssistNowOnlineClient()
+{
+    http_client->stop();
+    if (worker.joinable())
+        worker.join();
+}
+
+void _8::AssistNowOnlineClient::request_assistance_data(const Parameters& parameters, const std::function<void(const Result<std::string>&)>& cb)
+{
+    core::net::Uri::QueryParameters query
+    {
+        {"gnss", join(parameters.gnss)},
+        {"datatype", join(parameters.data_types)}
+    };
+
+    if (parameters.filter_on_pos)
+        query.push_back({"filteronpos", "notstrictlyneeded"});
+
+    if (!parameters.filter_on_svs.empty())
+        query.push_back({"filteronsvs", join(parameters.filter_on_svs)});
+
+    if (parameters.position)
+    {
+        const auto& position = parameters.position.get();
+        query.push_back({"lat", std::to_string(position.latitude().value())});
+        query.push_back({"lon", std::to_string(position.longitude().value())});
+
+        if (position.altitude())
+        {
+            const auto& altitude = position.altitude().get();
+            query.push_back({"alt", std::to_string(altitude.value())});
+        }
+
+        if (position.accuracy().horizontal())
+        {
+            const auto& accuracy = position.accuracy().horizontal().get();
+            query.push_back({"pacc", std::to_string(accuracy.value())});
+        }
+    }
+
+    auto uri = service_url + parameters.token;
+    for (const auto& param : query)
+        uri += (boost::format("&%1%=%2%") % param.first % param.second).str();
+
+    auto request = http_client->get(http::Request::Configuration::from_uri_as_string(uri));
+    http::Request::Handler handler;
+
+    handler.on_response([cb](const http::Response& response)
+    {
+        if (response.status == http::Status::ok)
+            cb(make_result(response.body));
+        else
+            cb(make_error_result<std::string>(
+                std::make_exception_ptr(
+                    std::runtime_error{response.body})));
+    });
+
+    handler.on_error([cb](const core::net::Error& error)
+    {
+        cb(make_error_result<std::string>(std::make_exception_ptr(error)));
+    });
+
+    request->async_execute(handler);
+}
+
+bool _8::operator<(AssistNowOnlineClient::DataType lhs, AssistNowOnlineClient::DataType rhs)
+{
+    using UT = typename std::underlying_type<AssistNowOnlineClient::DataType>::type;
+    return static_cast<UT>(lhs) < static_cast<UT>(rhs);
+}
+
+std::ostream& _8::operator<<(std::ostream& out, AssistNowOnlineClient::DataType rhs)
+{
+    switch (rhs)
+    {
+    case AssistNowOnlineClient::DataType::almanac:
+        out << "alm";
+        break;
+    case AssistNowOnlineClient::DataType::ephemeris:
+        out << "eph";
+        break;
+    case AssistNowOnlineClient::DataType::position:
+        out << "pos";
+        break;
+    case AssistNowOnlineClient::DataType::aux:
+        out << "aux";
+        break;
+    }
+
+    return out;
+}

=== added file 'src/location/providers/ubx/_8/assist_now_online_client.h'
--- src/location/providers/ubx/_8/assist_now_online_client.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/assist_now_online_client.h	2017-03-29 20:24:25 +0000
@@ -0,0 +1,105 @@
+// Copyright (C) 2017 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_ASSIST_NOW_ONLINE_CLIENT_H_
+#define UBX_8_ASSIST_NOW_ONLINE_CLIENT_H_
+
+#include <location/providers/ubx/_8/gnss_id.h>
+
+#include <location/optional.h>
+#include <location/position.h>
+#include <location/result.h>
+
+#include <core/net/http/client.h>
+
+#include <chrono>
+#include <cstdint>
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <thread>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class AssistNowOnlineClient
+{
+public:
+    static constexpr const char* service_url{"http://online-live1.services.u-blox.com/GetOnlineData.ashx?token="};
+
+    enum class DataType
+    {
+        ephemeris = 0,
+        almanac = 1,
+        aux = 2,
+        position = 3
+    };
+
+    struct Parameters
+    {
+        // The authorization token supplied by u-blox when a client registers to
+        // use the service.
+        std::string token;
+        // List of the GNSS for which data should be
+        // returned. Valid GNSS are: GnssId::gps, GnssId::qzss and GnssId::glonass.
+        std::set<GnssId> gnss;
+        // List of data types required by the client.
+        std::set<DataType> data_types;
+        // Approximate user latitude, longitude and altitude in WGS 84 expressed in degrees and
+        // fractional degrees.
+        Optional<Position> position;
+        // The timing accuracy (see time parameters note below).
+        Optional<std::chrono::seconds> time_accuracy;
+        // Typical latency between the time the server receives the request, and
+        // the time when the assistance data arrives at the u-blox receiver. The
+        // server can use this value to correct the time being transmitted to the
+        // client.
+        Optional<std::chrono::seconds> latency;
+        // If set to true, the ephemeris data returned to the client will only contain
+        // data for the satellites which are likely to be visible from the
+        // approximate position provided by the lat, lon, alt and pacc parameters.
+        bool filter_on_pos = false;
+        // List of u-blox gnssId:svId pairs. The ephemeris data
+        // returned to the client will only contain data for the listed satellites.
+        std::set<std::pair<GnssId, std::uint32_t>> filter_on_svs;
+    };
+
+    explicit AssistNowOnlineClient(const std::shared_ptr<core::net::http::Client>& http_client);
+    ~AssistNowOnlineClient();
+
+    // request_asisstance_data reaches out to the AssistNow service via the configured http client
+    // with parameters, reporting the assistance data blob to cb (on success).
+    void request_assistance_data(const Parameters& parameters, const std::function<void(const Result<std::string>&)>& cb);
+
+private:
+    std::shared_ptr<core::net::http::Client> http_client;
+    std::thread worker;
+};
+
+bool operator<(AssistNowOnlineClient::DataType lhs, AssistNowOnlineClient::DataType rhs);
+std::ostream& operator<<(std::ostream& out, AssistNowOnlineClient::DataType rhs);
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namepsace location
+
+#endif  // UBX_8_ASSIST_NOW_ONLINE_CLIENT_H_

=== added file 'src/location/providers/ubx/_8/cfg/rst.cpp'
--- src/location/providers/ubx/_8/cfg/rst.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/rst.cpp	2017-03-29 20:24:25 +0000
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/cfg/rst.h>
+
+#include <location/providers/ubx/bits.h>
+#include <location/providers/ubx/_8/writer.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace cfg = location::providers::ubx::_8::cfg;
+
+std::size_t cfg::Rst::size() const
+{
+    return 4;
+}
+
+void cfg::Rst::write(Writer& writer) const
+{
+    writer.write_unsigned_short(bits);
+    writer.write_unsigned_char(mode);
+    writer.write_unsigned_char(0);
+}
+
+std::ostream& cfg::operator<<(std::ostream& out, const cfg::Rst& rst)
+{
+    return out << "cfg-rst:" << std::endl
+        << "  bits: " << rst.bits << std::endl
+        << "  mode: " << rst.mode << std::endl;
+}

=== added file 'src/location/providers/ubx/_8/cfg/rst.h'
--- src/location/providers/ubx/_8/cfg/rst.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/rst.h	2017-03-29 20:24:25 +0000
@@ -0,0 +1,84 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_CFG_RST_H_
+#define UBX_8_CFG_RST_H_
+
+#include <cstdint>
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Writer;
+
+namespace cfg
+{
+
+struct Rst
+{
+    static constexpr std::uint8_t class_id{0x06};
+    static constexpr std::uint8_t message_id{0x04};
+
+    enum Bits
+    {
+        eph = 1 << 0,
+        alm = 1 << 1,
+        health = 1 << 2,
+        klob = 1 << 3,
+        pos = 1 << 4,
+        clkd = 1 << 5,
+        osc = 1 << 6,
+        utc = 1 << 7,
+        rtc = 1 << 8,
+        aop = 1 << 15,
+
+        hot_start = 0,
+        warm_start = eph,
+        cold_start = eph | alm | health | klob | pos | clkd | osc | utc | rtc | aop
+    };
+
+    enum Mode
+    {
+        hardware_reset = 0x00,
+        controlled_software_reset = 0x01,
+        controlled_software_reset_gnss = 0x02,
+        hardware_reset_after_shutdown = 0x04,
+        controlled_gnss_stop = 0x08,
+        controlled_gnss_start = 0x09
+    };
+
+    std::size_t size() const;
+    void write(Writer& writer) const;
+
+    Bits bits;
+    Mode mode;
+};
+
+std::ostream& operator<<(std::ostream& out, const Rst& rst);
+
+}  // namespace cfg
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_CFG_RST_H_

=== modified file 'src/location/providers/ubx/_8/gnss_id.cpp'
--- src/location/providers/ubx/_8/gnss_id.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/gnss_id.cpp	2017-03-29 20:24:25 +0000
@@ -16,6 +16,7 @@
 #include <location/providers/ubx/_8/gnss_id.h>
 
 #include <iostream>
+#include <type_traits>
 
 namespace _8 = location::providers::ubx::_8;
 
@@ -25,12 +26,18 @@
     {
     case GnssId::gps: out << "gps"; break;
     case GnssId::sbas: out << "sbas"; break;
-    case GnssId::galileo: out << "galileo"; break;
-    case GnssId::beidou: out << "beidou"; break;
+    case GnssId::galileo: out << "gal"; break;
+    case GnssId::beidou: out << "bds"; break;
     case GnssId::imes: out << "imes"; break;
     case GnssId::qzss: out << "qzss"; break;
-    case GnssId::glonass: out << "glonass"; break;
+    case GnssId::glonass: out << "glo"; break;
     }
 
     return out;
 }
+
+bool _8::operator<(GnssId lhs, GnssId rhs)
+{
+    using UT = typename std::underlying_type<GnssId>::type;
+    return static_cast<UT>(lhs) < static_cast<UT>(rhs);
+}

=== modified file 'src/location/providers/ubx/_8/gnss_id.h'
--- src/location/providers/ubx/_8/gnss_id.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/gnss_id.h	2017-03-29 20:24:25 +0000
@@ -41,6 +41,7 @@
 
 };
 
+bool operator<(GnssId lhs, GnssId rhs);
 std::ostream& operator<<(std::ostream& out, GnssId gnss_id);
 
 }  // namespace _8

=== modified file 'src/location/providers/ubx/_8/message.h'
--- src/location/providers/ubx/_8/message.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/message.h	2017-03-29 20:24:25 +0000
@@ -20,6 +20,7 @@
 #include <location/providers/ubx/_8/ack/nak.h>
 #include <location/providers/ubx/_8/cfg/gnss.h>
 #include <location/providers/ubx/_8/cfg/msg.h>
+#include <location/providers/ubx/_8/cfg/rst.h>
 #include <location/providers/ubx/_8/nav/pvt.h>
 #include <location/providers/ubx/_8/nav/sat.h>
 
@@ -39,6 +40,7 @@
     ack::Nak,
     cfg::Gnss,
     cfg::Msg,
+    cfg::Rst,
     nav::Pvt,
     nav::Sat
 >;

=== modified file 'src/location/providers/ubx/_8/nmea/scanner.cpp'
--- src/location/providers/ubx/_8/nmea/scanner.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/nmea/scanner.cpp	2017-03-29 20:24:25 +0000
@@ -23,6 +23,7 @@
   switch (state) {
     case Expect::dollar:
       if (c == '$') {
+        ss = std::stringstream{};
         ss << c;
         state = Expect::more_data;
       }
@@ -58,8 +59,7 @@
   if (state != Expect::nothing_more) throw std::runtime_error{"Incomplete"};
 
   auto result = ss.str();
-  ss.str("");
-  ss.clear();
+  ss = std::stringstream{};
   state = Expect::dollar;
 
   return result;

=== modified file 'src/location/providers/ubx/_8/receiver.cpp'
--- src/location/providers/ubx/_8/receiver.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/receiver.cpp	2017-03-29 20:24:25 +0000
@@ -26,6 +26,11 @@
     {
         return ubx::_8::encode_message(msg);
     }
+
+    std::vector<std::uint8_t> operator()(const ubx::_8::cfg::Rst& rst) const
+    {
+        return ubx::_8::encode_message(rst);
+    }
 };
 
 }  // namespace
@@ -44,11 +49,35 @@
         auto result = ubx_scanner.update(*it);
 
         if (std::get<0>(result) == Scanner::Expect::nothing_more)
-            monitor->on_new_ubx_message(ubx_scanner.finalize());
-        if (!std::get<1>(result))
+        {
+            try
+            {
+                monitor->on_new_ubx_message(ubx_scanner.finalize());
+            }
+            catch (...)
+            {
+                // Dropping the exception as there is hardly any reasonable measure
+                // we can take. Both scanners are designed to recover from issues, and we
+                // we just trap the exception here to guarantee that we keep on consuming the
+                // entire buffer.
+            }
+        }
+        else if (!std::get<1>(result))
         {
             if (nmea::Scanner::Expect::nothing_more == nmea_scanner.update(*it))
-                monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
+            {
+                try
+                {
+                    monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
+                }
+                catch (...)
+                {
+                    // Dropping the exception as there is hardly any reasonable measure
+                    // we can take. Both scanners are designed to recover from issues, and we
+                    // we just trap the exception here to guarantee that we keep on consuming the
+                    // entire buffer.
+                }
+            }
         }
         ++it;
     }

=== modified file 'src/location/providers/ubx/_8/receiver.h'
--- src/location/providers/ubx/_8/receiver.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/receiver.h	2017-03-29 20:24:25 +0000
@@ -38,7 +38,7 @@
 class Receiver
 {
 public:
-    using Buffer = std::array<char, 1024>;
+    using Buffer = std::array<std::uint8_t, 4096>;
 
     /// @brief Monitor provides calling code with means for monitoring
     /// receiver operation.
@@ -66,6 +66,9 @@
     /// @brief send_message encodes and sends 'message' to the receiver.
     void send_message(const Message& message);
 
+    /// @brief send_encoded_message sends out data to the receiver.
+    virtual void send_encoded_message(const std::vector<std::uint8_t> &data) = 0;
+
 protected:
     /// @brief Receiver initializes a new instance with monitor
     ///
@@ -78,9 +81,6 @@
     /// Calls out to a configured monitor instance for announcing results.
     void process_chunk(Buffer::iterator it, Buffer::iterator itE);
 
-    /// @brief send_encoded_message sends out data to the receiver.
-    virtual void send_encoded_message(const std::vector<std::uint8_t>& data) = 0;
-
 private:
     std::shared_ptr<Monitor> monitor;
     ubx::_8::nmea::Scanner nmea_scanner;

=== modified file 'src/location/providers/ubx/_8/scanner.cpp'
--- src/location/providers/ubx/_8/scanner.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/scanner.cpp	2017-03-29 20:24:25 +0000
@@ -65,15 +65,12 @@
 {
     bool consumed = false;
 
-    // TODO(tvoss): This lacks a lot of validiation and verification.
-    // UBX allows us to partially parse while we scan and carry out online
-    // checksum calculation. Ideally, we would have a common class State that
-    // captures behavior and transition logic.
     switch (next)
     {
     case Expect::sync_char_1:
         if (c == sync_char_1)
         {
+            reset();
             next = Expect::sync_char_2;
             consumed = true;
         }
@@ -143,16 +140,27 @@
     if (next != Expect::nothing_more)
         throw std::logic_error{"Not ready for extraction."};
 
+    struct Scope
+    {
+        Scope(Scanner& scanner) : scanner{scanner} {}
+        ~Scope() { scanner.reset(); }
+
+        Scanner& scanner;
+    } scope{*this};
+
     if (ck_a != checksum.ck_a() || ck_b != checksum.ck_b())
-        throw std::runtime_error{"Verification failed."};
+        throw std::runtime_error("Failed to verify ubx protocol message integrity.");
 
     auto it = factories.find(std::make_tuple(class_id, message_id));
 
     if (it == factories.end())
-        throw std::runtime_error{"Could not decode message."};
-
-    auto result = it->second(payload);
-
+        throw std::runtime_error{"Failed to decode ubx protocol message."};
+
+    return it->second(payload);
+}
+
+void _8::Scanner::reset()
+{
     checksum = Checksum{};
     next = Expect::sync_char_1;
     class_id = 0;
@@ -161,6 +169,4 @@
     payload.clear();
     payload_iterator = payload.end();
     ck_a = ck_b = 0;
-
-    return result;
 }

=== modified file 'src/location/providers/ubx/_8/scanner.h'
--- src/location/providers/ubx/_8/scanner.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/scanner.h	2017-03-29 20:24:25 +0000
@@ -58,6 +58,9 @@
     Message finalize();
 
 private:
+
+    void reset();
+
     Expect next;
     Checksum checksum;
     std::uint8_t class_id;

=== modified file 'src/location/providers/ubx/_8/serial_port_receiver.cpp'
--- src/location/providers/ubx/_8/serial_port_receiver.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.cpp	2017-03-29 20:24:25 +0000
@@ -15,51 +15,63 @@
 
 ubx::_8::SerialPortReceiver::SerialPortReceiver(boost::asio::io_service& ios, const boost::filesystem::path& dev,
                                                 const std::shared_ptr<Monitor>& monitor)
-    : Receiver{monitor}, ios{ios}, sp{ios, dev.string().c_str()}
+    : Receiver{monitor}, ios{ios}, serial_port{ios, dev.string().c_str()}
 {
+    serial_port.set_option(boost::asio::serial_port::baud_rate(9600));
 }
 
 void ubx::_8::SerialPortReceiver::send_encoded_message(const std::vector<std::uint8_t>& data)
 {
-    ios.dispatch([this, data]()
+    auto thiz = shared_from_this();
+    std::weak_ptr<SerialPortReceiver> wp{thiz};
+
+    ios.dispatch([this, wp, data]()
     {
-        boost::asio::write(sp, boost::asio::buffer(data), boost::asio::transfer_all());
+        if (auto sp = wp.lock())
+            boost::asio::write(serial_port, boost::asio::buffer(data), boost::asio::transfer_all());
     });
 }
 
 void ubx::_8::SerialPortReceiver::start()
 {
+    ::tcflush(serial_port.lowest_layer().native_handle(), TCIFLUSH);
     start_read();
 }
 
 void ubx::_8::SerialPortReceiver::stop()
 {
-    sp.cancel();
+    serial_port.cancel();
 }
 
 void ubx::_8::SerialPortReceiver::start_read()
 {
     auto thiz = shared_from_this();
-    boost::asio::async_read(sp, boost::asio::buffer(&buffer.front(), buffer.size()),
-                            [thiz, this](const boost::system::error_code& ec, std::size_t transferred) {
+    std::weak_ptr<SerialPortReceiver> wp{thiz};
+
+    boost::asio::async_read(serial_port, boost::asio::buffer(&buffer.front(), buffer.size()),
+                            [this, wp](const boost::system::error_code& ec, std::size_t transferred) {
                                 if (ec == boost::asio::error::operation_aborted)
                                     return;
-                                if (not ec)
+
+                                if (auto sp = wp.lock())
                                 {
-                                    try
-                                    {
-                                        process_chunk(buffer.begin(), buffer.begin() + transferred);
-                                    }
-                                    catch(const std::exception& e)
-                                    {
-                                        LOG(WARNING) << "Error processing NMEA chunk: " << e.what();
-                                    }
-                                    catch(...)
-                                    {
-                                        LOG(WARNING) << "Error processing NMEA chunk.";
-                                    }
+                                    if (not ec)
+                                    {
+                                        try
+                                        {
+                                            process_chunk(buffer.begin(), buffer.begin() + transferred);
+                                        }
+                                        catch(const std::exception& e)
+                                        {
+                                            LOG(WARNING) << "Error processing data chunk: " << e.what();
+                                        }
+                                        catch(...)
+                                        {
+                                            LOG(WARNING) << "Error processing data chunk.";
+                                        }
 
-                                    start_read();
+                                        start_read();
+                                    }
                                 }
                             });
 }

=== modified file 'src/location/providers/ubx/_8/serial_port_receiver.h'
--- src/location/providers/ubx/_8/serial_port_receiver.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.h	2017-03-29 20:24:25 +0000
@@ -21,6 +21,7 @@
 #include <boost/filesystem.hpp>
 
 #include <array>
+#include <atomic>
 
 namespace location
 {
@@ -44,10 +45,15 @@
     void start();
     void stop();
 
-protected:
     void send_encoded_message(const std::vector<std::uint8_t>& data) override;
 
 private:
+    enum class State
+    {
+        running,
+        stopped
+    };
+
     /// @brief Receiver initializes a new instance opening the serial port
     /// located at path.
     ///
@@ -65,7 +71,7 @@
 
     Receiver::Buffer buffer;
     boost::asio::io_service& ios;
-    boost::asio::serial_port sp;
+    boost::asio::serial_port serial_port;
 };
 }
 }

=== modified file 'src/location/providers/ubx/provider.cpp'
--- src/location/providers/ubx/provider.cpp	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/provider.cpp	2017-03-29 20:24:25 +0000
@@ -20,6 +20,7 @@
 
 #include <location/logging.h>
 #include <location/runtime.h>
+#include <location/events/reference_position_updated.h>
 #include <location/glib/runtime.h>
 
 #include <location/providers/ubx/_8/cfg/gnss.h>
@@ -27,8 +28,11 @@
 #include <location/providers/ubx/_8/nav/pvt.h>
 #include <location/providers/ubx/_8/nav/sat.h>
 
+#include <core/net/http/client.h>
 #include <core/posix/this_process.h>
 
+#include <boost/lexical_cast.hpp>
+
 #include <fstream>
 #include <iostream>
 #include <iterator>
@@ -37,31 +41,54 @@
 namespace env = core::posix::this_process::env;
 namespace ubx = location::providers::ubx;
 
+namespace
+{
+
+struct SettingsHelper
+{
+    template<typename T>
+    static T get_value(std::string key, T&& default_value)
+    {
+        static const std::string snap_path = env::get("SNAP_DATA");
+
+        boost::filesystem::path path{snap_path};
+        std::replace(key.begin(), key.end(), '.', '/');
+        path /= key;
+
+        LOG(INFO) << "Reading setting from " << path.string();
+
+        std::ifstream in{path.string().c_str()};
+        T value{default_value}; in >> value;
+
+        return value;
+    }
+};
+
+}
+
 std::string ubx::Provider::class_name()
 {
     return "ubx::Provider";
 }
 
-ubx::Provider::Monitor::Monitor(Provider* provider) : provider{provider}
-{
-}
-
 void ubx::Provider::Monitor::on_new_ubx_message(const _8::Message& message)
 {
     VLOG(1) << message;
-    if (provider->protocol == Provider::Protocol::ubx)
-        boost::apply_visitor(*this, message);
+    if (auto sp = provider.lock())
+        if (sp->configuration.protocol == Provider::Protocol::ubx)
+            boost::apply_visitor(*this, message);
 }
 
 
 void ubx::Provider::Monitor::on_new_nmea_sentence(const _8::nmea::Sentence& sentence)
 {
     VLOG(1) << sentence;
-    if (provider->protocol == Provider::Protocol::nmea)
-        boost::apply_visitor(*this, sentence);
+    if (auto sp = provider.lock())
+        if (sp->configuration.protocol == Provider::Protocol::nmea)
+            boost::apply_visitor(*this, sentence);
 }
 
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gga& gga) const
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gga& gga)
 {   
     if (gga.latitude && gga.longitude)
     {
@@ -82,14 +109,19 @@
         if (gga.hdop)
             position.accuracy().horizontal(gga.hdop.get() * 3. * units::meters);
 
-        glib::Runtime::instance()->dispatch([this, position]()
+        auto thiz = shared_from_this();
+        std::weak_ptr<ubx::Provider::Monitor> wp{thiz};
+
+        glib::Runtime::instance()->dispatch([position, wp]()
         {
-            provider->updates.position(location::Update<location::Position>{position});
+            if (auto sp = wp.lock())
+                if (auto spp = sp->provider.lock())
+                    spp->updates.position(location::Update<location::Position>{position});
         });
     }
 }
 
-void ubx::Provider::Monitor::operator()(const _8::nav::Pvt& pvt) const
+void ubx::Provider::Monitor::operator()(const _8::nav::Pvt& pvt)
 {
     if (pvt.fix_type == _8::nav::Pvt::FixType::no_fix)
         return;
@@ -110,72 +142,218 @@
     units::Degrees heading = pvt.heading.vehicle * units::degrees;
     units::MetersPerSecond speed = pvt.speed_over_ground * 1e-3 * units::meters_per_second;
 
-    glib::Runtime::instance()->dispatch([this, position, heading, speed]()
+    auto thiz = shared_from_this();
+    std::weak_ptr<ubx::Provider::Monitor> wp{thiz};
+
+    glib::Runtime::instance()->dispatch([position, heading, speed, wp]()
     {
-        provider->updates.position(location::Update<location::Position>{position});
-        provider->updates.heading(location::Update<units::Degrees>{heading});
-        provider->updates.velocity(location::Update<units::MetersPerSecond>{speed});
+        if (auto sp = wp.lock())
+        {
+            if (auto spp = sp->provider.lock())
+            {
+                spp->updates.position(location::Update<location::Position>{position});
+                spp->updates.heading(location::Update<units::Degrees>{heading});
+                spp->updates.velocity(location::Update<units::MetersPerSecond>{speed});
+            }
+        }
     });
 }
 
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gsa&) const
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gll&) const
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gsv&) const
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Rmc&) const
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Txt&) const
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Vtg& vtg) const
-{
-    glib::Runtime::instance()->dispatch([this, vtg]()
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gsa&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gll&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gsv&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Rmc&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Txt&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Vtg& vtg)
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<ubx::Provider::Monitor> wp{thiz};
+
+    glib::Runtime::instance()->dispatch([vtg, wp]()
     {
-        if (vtg.cog_true)
-            provider->updates.heading(
-                        Update<units::Degrees>(
-                            vtg.cog_true.get() * units::degrees));
-        if (vtg.sog_kmh)
-            provider->updates.velocity(
-                        Update<units::MetersPerSecond>(
-                            vtg.sog_kmh.get() * 1000./3600. * units::meters_per_second));
+        if (auto sp = wp.lock())
+        {
+            if (vtg.cog_true)
+                if (auto spp = sp->provider.lock())
+                    spp->updates.heading(
+                                Update<units::Degrees>(
+                                    vtg.cog_true.get() * units::degrees));
+            if (vtg.sog_kmh)
+                if (auto spp = sp->provider.lock())
+                    spp->updates.velocity(
+                                Update<units::MetersPerSecond>(
+                                    vtg.sog_kmh.get() * 1000./3600. * units::meters_per_second));
+        }
     });
 }
 
 location::Provider::Ptr ubx::Provider::create_instance(const location::ProviderFactory::Configuration& config)
 {
-    std::string device_path = "/dev/ttyACM0";
-    std::ifstream in(env::get("SNAP_DATA") + "/ubx/provider/path");
-    in >> device_path;
-
-    return location::Provider::Ptr{new ubx::Provider{
-            Protocol::ubx, config.get<std::string>("device", device_path)}};
-}
-
-ubx::Provider::Provider(Protocol protocol, const boost::filesystem::path& device)
-    : protocol{protocol},
+    Configuration configuration
+    {
+        Protocol::ubx,
+        config.get<std::string>(
+            "device", SettingsHelper::get_value<std::string>(
+                    "ubx.provider.path",
+                    "/dev/ttyACM1"
+            )
+        ),
+        {
+            SettingsHelper::get_value<std::string>(
+                "ubx.provider.assist_now.enable",
+                "false"
+            ) == "true",
+            SettingsHelper::get_value<std::string>(
+                "ubx.provider.assist_now.token",
+                ""
+            ),
+            boost::posix_time::seconds(
+                boost::lexical_cast<std::uint64_t>(
+                    SettingsHelper::get_value<std::string>(
+                        "ubx.provider.assist_now.acquisition_timeout",
+                        "5"
+                    )
+                )
+            )
+        }
+    };
+
+    return ubx::Provider::create(configuration);
+}
+
+// Create a new instance with configuration.
+std::shared_ptr<ubx::Provider> ubx::Provider::create(const Configuration& configuration)
+{
+    auto sp = std::shared_ptr<Provider>{new Provider{configuration}};
+    return sp->finalize_construction();
+}
+
+
+ubx::Provider::Provider(const Configuration& configuration)
+    : configuration{configuration},
       runtime{location::Runtime::create(1)},
-      monitor{std::make_shared<Monitor>(this)},
-      receiver{_8::SerialPortReceiver::create(runtime->service(), device, monitor)}
-{   
+      monitor{std::make_shared<Monitor>()},
+      receiver{_8::SerialPortReceiver::create(runtime->service(), configuration.device, monitor)},
+      assist_now_online_client{std::make_shared<_8::AssistNowOnlineClient>(core::net::http::make_client())},
+      acquisition_timer{runtime->service()}
+{
     runtime->start();
 
+    configure_gnss();
+    configure_protocol();
+}
+
+ubx::Provider::~Provider() noexcept
+{
+    deactivate();
+    runtime->stop();
+}
+
+void ubx::Provider::reset()
+{
+    receiver->send_message(_8::cfg::Rst{_8::cfg::Rst::Bits::cold_start, _8::cfg::Rst::Mode::controlled_software_reset_gnss});
+}
+
+void ubx::Provider::on_new_event(const Event&)
+{
+    // TODO(tvoss): Use incoming reference position updates
+    // to query assistance data.
+}
+
+location::Provider::Requirements ubx::Provider::requirements() const
+{
+    return Requirements::none;
+}
+
+bool ubx::Provider::satisfies(const location::Criteria&)
+{
+    return true;
+}
+
+void ubx::Provider::enable()
+{
+}
+
+void ubx::Provider::disable()
+{
+}
+
+void ubx::Provider::activate()
+{
+    receiver->start();
+
+    if (configuration.assist_now.enable)
+    {
+        auto thiz = shared_from_this();
+        std::weak_ptr<Provider> wp{thiz};
+
+        acquisition_timer.expires_from_now(configuration.assist_now.acquisition_timeout);
+        acquisition_timer.async_wait([this, wp](boost::system::error_code ec)
+        {
+            if (auto sp = wp.lock())
+                if (!ec) request_assist_now_online_data(Optional<Position>{});
+        });
+    }
+}
+
+void ubx::Provider::deactivate()
+{
+    receiver->stop();
+    acquisition_timer.cancel();
+}
+
+const core::Signal<location::Update<location::Position>>& ubx::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::units::Degrees>>& ubx::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::units::MetersPerSecond>>& ubx::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}
+
+std::shared_ptr<ubx::Provider> ubx::Provider::finalize_construction()
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<ubx::Provider> wp{thiz};
+
+    updates.position.connect([wp](const Update<Position>&)
+    {
+        if (auto sp = wp.lock())
+            sp->acquisition_timer.cancel();
+    });
+
+    monitor->provider = wp;
+    return thiz;
+}
+
+void ubx::Provider::configure_gnss()
+{
     _8::cfg::Gnss::Gps gps;
     gps.l1ca = true;
     gps.enable = true;
@@ -207,8 +385,11 @@
     gnss.sbas = sbas;
 
     receiver->send_message(gnss);
+}
 
-    if (protocol == Protocol::ubx)
+void ubx::Provider::configure_protocol()
+{
+    if (configuration.protocol == Protocol::ubx)
     {
         _8::cfg::Msg cfg_msg{ubx::_8::nav::Pvt::class_id, ubx::_8::nav::Pvt::message_id, { 0 }};
         cfg_msg.rate[_8::cfg::Msg::Port::usb] = 1;
@@ -221,55 +402,47 @@
     }
 }
 
-ubx::Provider::~Provider() noexcept
-{
-    deactivate();
-    runtime->stop();
-}
-
-void ubx::Provider::on_new_event(const Event&)
-{
-}
-
-location::Provider::Requirements ubx::Provider::requirements() const
-{
-    return Requirements::none;
-}
-
-bool ubx::Provider::satisfies(const location::Criteria&)
-{
-    return true;
-}
-
-void ubx::Provider::enable()
-{
-}
-
-void ubx::Provider::disable()
-{
-}
-
-void ubx::Provider::activate()
-{
-    receiver->start();
-}
-
-void ubx::Provider::deactivate()
-{
-    receiver->stop();
-}
-
-const core::Signal<location::Update<location::Position>>& ubx::Provider::position_updates() const
-{
-    return updates.position;
-}
-
-const core::Signal<location::Update<location::units::Degrees>>& ubx::Provider::heading_updates() const
-{
-    return updates.heading;
-}
-
-const core::Signal<location::Update<location::units::MetersPerSecond>>& ubx::Provider::velocity_updates() const
-{
-    return updates.velocity;
+void ubx::Provider::request_assist_now_online_data(const Optional<Position>& position)
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<Provider> wp{thiz};
+
+    _8::AssistNowOnlineClient::Parameters params;
+    params.token = configuration.assist_now.token;
+    params.gnss = {_8::GnssId::gps, _8::GnssId::glonass, _8::GnssId::galileo};
+    params.data_types =
+    {
+        _8::AssistNowOnlineClient::DataType::almanac,
+        _8::AssistNowOnlineClient::DataType::ephemeris
+    };
+    params.position = position;
+
+    assist_now_online_client->request_assistance_data(params, [this, wp](const Result<std::string>& result)
+    {
+        if (result)
+        {
+            if (auto sp = wp.lock())
+            {
+                LOG(INFO) << "Successfully queried assistance data, injecting into chipset now.";
+                receiver->send_encoded_message(
+                        std::vector<std::uint8_t>(
+                            result.value().begin(), result.value().end()));
+            }
+        }
+        else
+        {
+            try
+            {
+                result.rethrow();
+            }
+            catch (const std::exception& e)
+            {
+                LOG(WARNING) << "Failed to query AssistNow for aiding data: " << e.what() << std::endl;
+            }
+            catch (...)
+            {
+                LOG(WARNING) << "Failed to query AssistNow for aiding data." << std::endl;
+            }
+        }
+    });
 }

=== modified file 'src/location/providers/ubx/provider.h'
--- src/location/providers/ubx/provider.h	2017-03-29 20:24:25 +0000
+++ src/location/providers/ubx/provider.h	2017-03-29 20:24:25 +0000
@@ -22,6 +22,7 @@
 #include <location/provider_factory.h>
 #include <location/runtime.h>
 
+#include <location/providers/ubx/_8/assist_now_online_client.h>
 #include <location/providers/ubx/_8/serial_port_receiver.h>
 
 #include <boost/filesystem.hpp>
@@ -43,9 +44,28 @@
 //
 // Configuration parameters:
 //   - device[=/dev/ttyUSB1] serial device connecting to the receiver.
-class Provider : public location::Provider
+class Provider : public location::Provider, public std::enable_shared_from_this<Provider>
 {
 public:
+    enum class Protocol
+    {
+        ubx,  // Rely on ubx.
+        nmea  // Rely on nmea.
+    };
+
+    // Configuration bundles all construction time parameters.
+    struct Configuration
+    {
+        Protocol protocol;                                  // The protocol used for communicating with the receiver.
+        boost::filesystem::path device;                     // Serial device used for communicating with the receiver.
+        struct
+        {
+            bool enable;                                    // Whether or not the provider should use AssistNow.
+            std::string token;                              // Token for validating requests to the AssistNow service.
+            boost::posix_time::seconds acquisition_timeout; // Query assistance data after this many seconds.
+        } assist_now;                                       // All parameters for configuring AssistNow go here.
+    };
+
     // For integration with the Provider factory.
     static std::string class_name();
     // Instantiates a new provider instance, populating the configuration object
@@ -53,17 +73,16 @@
     // for the list of known options.
     static Provider::Ptr create_instance(const ProviderFactory::Configuration&);
 
-    enum class Protocol
-    {
-        ubx,  // Rely on ubx.
-        nmea  // Rely on nmea.
-    };
+    // Create a new instance with configuration.
+    static std::shared_ptr<Provider> create(const Configuration& configuration);
 
-    // Creates a new provider instance talking via device to the ubx chipset.
-    Provider(Protocol protocol, const boost::filesystem::path& device);
     // Cleans up all resources and stops the updates.
     ~Provider() noexcept;
 
+    // Resets the chipset and drops all cached data.
+    // The next positioning request will be a cold start.
+    void reset();
+
     // From Provider
     void on_new_event(const Event& event) override;
 
@@ -80,10 +99,8 @@
 
 private:
     // Relays incoming sentences to a provider instance.
-    struct Monitor : public _8::Receiver::Monitor, public boost::static_visitor<>
+    struct Monitor : public std::enable_shared_from_this<ubx::Provider::Monitor>, public _8::Receiver::Monitor, public boost::static_visitor<>
     {
-        explicit Monitor(Provider* provider);
-
         // From Receiver::Monitor
         void on_new_ubx_message(const _8::Message& message) override;
         void on_new_nmea_sentence(const _8::nmea::Sentence& sentence) override;
@@ -91,23 +108,36 @@
         template<typename T>
         void operator()(const T&) const {}
 
-        void operator()(const _8::nav::Pvt& pvt) const;
-
-        void operator()(const _8::nmea::Gga& gga) const;
-        void operator()(const _8::nmea::Gsa& gsa) const;
-        void operator()(const _8::nmea::Gll& gll) const;
-        void operator()(const _8::nmea::Gsv& gsv) const;
-        void operator()(const _8::nmea::Rmc& rmc) const;
-        void operator()(const _8::nmea::Txt& txt) const;
-        void operator()(const _8::nmea::Vtg& vtg) const;
-
-        Provider* provider;
+        void operator()(const _8::nav::Pvt& pvt);
+
+        void operator()(const _8::nmea::Gga& gga);
+        void operator()(const _8::nmea::Gsa& gsa);
+        void operator()(const _8::nmea::Gll& gll);
+        void operator()(const _8::nmea::Gsv& gsv);
+        void operator()(const _8::nmea::Rmc& rmc);
+        void operator()(const _8::nmea::Txt& txt);
+        void operator()(const _8::nmea::Vtg& vtg);
+
+        std::weak_ptr<Provider> provider;
     };
 
-    Protocol protocol;
+    // Creates a new provider instance talking via device to the ubx chipset.
+    Provider(const Configuration& configuration);
+
+    std::shared_ptr<Provider> finalize_construction();
+
+    void configure_gnss();
+    void configure_protocol();
+
+    void request_assist_now_online_data(const Optional<Position>& position);
+
+    Configuration configuration;
     std::shared_ptr<location::Runtime> runtime;
     std::shared_ptr<Monitor> monitor;
     std::shared_ptr<_8::SerialPortReceiver> receiver;
+    std::shared_ptr<_8::AssistNowOnlineClient> assist_now_online_client;
+    boost::asio::deadline_timer acquisition_timer;
+
     struct
     {
         core::Signal<Update<Position>> position;

=== modified file 'src/location/runtime_tests.cpp'
--- src/location/runtime_tests.cpp	2016-08-24 14:12:05 +0000
+++ src/location/runtime_tests.cpp	2017-03-29 20:24:25 +0000
@@ -20,12 +20,17 @@
 #include <location/runtime_tests.h>
 
 #include <location/clock.h>
+#include <location/glib/runtime.h>
 #include <location/providers/gps/hardware_abstraction_layer.h>
+#include <location/providers/ubx/provider.h>
+
+#include <core/posix/this_process.h>
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/mean.hpp>
 #include <boost/accumulators/statistics/variance.hpp>
+#include <boost/lexical_cast.hpp>
 
 #include <cstdlib>
 
@@ -35,6 +40,7 @@
 #include <mutex>
 #include <thread>
 
+namespace env = core::posix::this_process::env;
 namespace gps = location::providers::gps;
 
 namespace
@@ -172,14 +178,125 @@
     return 0;
 }
 #else
-int snr_and_ttff(std::ostream&, std::ostream&) { return 0; }
+int snr_and_ttff(const std::string& test_suite, std::ostream&, std::ostream&) { return 0; }
 #endif // LOCATION_PROVIDERS_GPS
+
+int ubx(std::ostream& cout, std::ostream& cerr)
+{
+    typedef boost::accumulators::accumulator_set<
+        double,
+        boost::accumulators::stats<
+            boost::accumulators::tag::mean,
+            boost::accumulators::tag::variance
+        >
+    > Statistics;
+
+    using boost::accumulators::mean;
+    using boost::accumulators::variance;
+
+    const unsigned int trials = boost::lexical_cast<unsigned int>(env::get("UBX_PROVIDER_TEST_TRIALS", "15"));
+
+    Statistics stats;
+    location::providers::ubx::Provider::Configuration configuration
+    {
+        location::providers::ubx::Provider::Protocol::ubx,
+        env::get_or_throw("UBX_PROVIDER_TEST_DEVICE"),
+        {
+            env::get("UBX_PROVIDER_TEST_ASSIST_NOW_ENABLE", "false") == "true",
+            env::get_or_throw("UBX_PROVIDER_TEST_ASSIST_NOW_TOKEN"),
+            boost::posix_time::seconds(
+                boost::lexical_cast<std::uint64_t>(
+                    env::get("UBX_PROVIDER_TEST_ASSIST_NOW_ACQUISITION_TIMEOUT", "5")))
+        }
+    };
+    auto provider = location::providers::ubx::Provider::create(configuration);
+
+    struct State
+    {
+        State() : worker{[this]() { runtime.run(); }}, fix_received(false)
+        {
+        }
+
+        ~State()
+        {
+            runtime.stop();
+            if (worker.joinable())
+                worker.join();
+        }
+
+        bool wait_for_fix_for(const std::chrono::seconds& seconds)
+        {
+            std::unique_lock<std::mutex> ul(guard);
+            return wait_condition.wait_for(
+                        ul,
+                        seconds,
+                        [this]() {return fix_received == true;});
+        }
+
+        void on_position_updated(const location::Position&)
+        {
+            fix_received = true;
+            wait_condition.notify_all();
+        }
+
+        void reset()
+        {
+            fix_received = false;
+        }
+
+        location::glib::Runtime runtime;
+        std::thread worker;
+        std::mutex guard;
+        std::condition_variable wait_condition;
+        bool fix_received;
+    } state;
+
+    provider->position_updates().connect([&state](const location::Update<location::Position>& update)
+    {
+        state.on_position_updated(update.value);
+    });
+
+    for (unsigned int i = 0; i < trials; i++)
+    {
+        provider->reset();
+
+        state.reset();
+        auto start = std::chrono::duration_cast<std::chrono::microseconds>(location::Clock::now().time_since_epoch());
+        {
+            provider->activate();
+
+            // We expect a maximum cold start time of 15 minutes. The theoretical
+            // limit is 12.5 minutes, and we add up some grace period to make the
+            // test more robust (see http://en.wikipedia.org/wiki/Time_to_first_fix).
+            expect<true, std::runtime_error>(state.wait_for_fix_for(std::chrono::seconds{15 * 60}), "Wait for fix timed out.");
+            provider->deactivate();
+        }
+        auto stop = std::chrono::duration_cast<std::chrono::microseconds>(location::Clock::now().time_since_epoch());
+
+        stats((stop - start).count());
+    }
+
+    cout << "Mean time to first fix in [ms]: "
+              << std::chrono::duration_cast<std::chrono::milliseconds>(
+                     std::chrono::microseconds(
+                         static_cast<std::uint64_t>(mean(stats)))).count()
+              << std::endl;
+    cout << "Std.dev. in time to first fix in [ms]: "
+              << std::chrono::duration_cast<std::chrono::milliseconds>(
+                     std::chrono::microseconds(
+                         static_cast<std::uint64_t>(std::sqrt(variance(stats))))).count()
+              << std::endl;
+
+    return 0;
 }
 
-int location::execute_runtime_tests(std::ostream& cout, std::ostream& cerr)
+}  // namespace
+
+int location::execute_runtime_tests(const std::string& test_suite, std::ostream& cout, std::ostream& cerr)
 {
-    Fixture fixture; // This throws in case of issues.
-    auto rc = snr_and_ttff(cout, cerr); if (rc != 0) return rc;
-    // Other runtime tests go here;
-    return rc;
+    if (test_suite == "android-gps")
+        return snr_and_ttff(cout, cerr);
+    else if (test_suite == "ubx")
+        return ubx(cout, cerr);
+    return 0;
 }

=== modified file 'src/location/runtime_tests.h'
--- src/location/runtime_tests.h	2016-06-30 09:13:21 +0000
+++ src/location/runtime_tests.h	2017-03-29 20:24:25 +0000
@@ -19,12 +19,13 @@
 #define LOCATION_RUNTIME_TESTS_H_
 
 #include <iosfwd>
+#include <string>
 
 namespace location
 {
 // execute_runtime_tests runs all configured runtime tests.
 // Returns 0 if successful.
-int execute_runtime_tests(std::ostream& cout, std::ostream& cerr);
+int execute_runtime_tests(const std::string& test_suite, std::ostream& cout, std::ostream& cerr);
 }
 
 #endif // LOCATION_RUNTIME_TESTS_H_