Merge lp:~thomas-voss/location-service/simplify-provider-interface into lp:location-service

[Thomas Voß]

Simplify the location::Provider interface.

Move all state-machine semantics into the implementation and
only expose a pure virtual interface for providers to implement.
Remove specific event-handlers and instead go fo an extensible location::Event
with location::Provider extending on location::Event::Receiver. With that, we
can easily extend events going forward in an ABI compatible way.

Simplify the location::Provider interface.

Move all state-machine semantics into the implementation and
only expose a pure virtual interface for providers to implement.
Remove specific event-handlers and instead go fo an extensible location::Event
with location::Provider extending on location::Event::Receiver. With that, we
can easily extend events going forward in an ABI compatible way.

[Simon Fels (morphis)]

LGTM

review: Approve

=== modified file 'include/location/criteria.h'
--- include/location/criteria.h	2016-06-26 21:17:03 +0000
+++ include/location/criteria.h	2016-08-12 12:03:50 +0000
@@ -18,6 +18,7 @@
 #ifndef LOCATION_CRITERIA_H_
 #define LOCATION_CRITERIA_H_
 
+#include <location/features.h>
 #include <location/optional.h>
 #include <location/units/units.h>
 
@@ -29,34 +30,16 @@
  */
 struct Criteria
 {
-    /**
-     * @brief satisfies checks whether this instance also satisfies another criteria instance.
-     * @param rhs The other criteria instance
-     * @return true iff this instance also satisfies the other instance, else false.
-     */
-    bool satisfies(const Criteria& rhs) const;
-
-    struct Requires
-    {
-        bool position = true; ///< The client needs position measurements.
-        bool altitude = false; ///< The client needs altitude measurements.
-        bool velocity = false; ///< The client needs velocity measurments.
-        bool heading = false; ///< The client needs heading measurements.
-    } requires = Requires{};
+    Features requirements; ///< These features are required.
 
     struct Accuracy
     {
-        units::Quantity<units::Length> horizontal = 3000 * units::Meters; ///< The client requires measurements of at least this horizontal accuracy.
-        Optional<units::Quantity<units::Length>> vertical; ///< The client requires measurements of at least this vertical accuracy.
-        Optional<units::Quantity<units::Velocity>> velocity; ///< The client requires measurements of at least this velocity accuracy.
-        Optional<units::Quantity<units::PlaneAngle>> heading; ///< The client requires measurements of at least this heading accuracy.
+        Optional<units::Quantity<units::Length>> horizontal;    ///< The client requires measurements of at least this horizontal accuracy.
+        Optional<units::Quantity<units::Length>> vertical;      ///< The client requires measurements of at least this vertical accuracy.
+        Optional<units::Quantity<units::Velocity>> velocity;    ///< The client requires measurements of at least this velocity accuracy.
+        Optional<units::Quantity<units::PlaneAngle>> heading;   ///< The client requires measurements of at least this heading accuracy.
     } accuracy = Accuracy{};
 };
-
-/**
- * @brief operator + merges lhs and rhs such that satisfying the new criteria satisfies lhs and rhs.
- */
-Criteria operator+(const Criteria& lhs, const Criteria& rhs);
 }
 
 #endif // LOCATION_CRITERIA_H_

=== added file 'include/location/event.h'
--- include/location/event.h	1970-01-01 00:00:00 +0000
+++ include/location/event.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_EVENT_H_
+#define LOCATION_EVENT_H_
+
+#include <memory>
+
+namespace location
+{
+/// @brief Event models the base of an event hierarchy used to pass
+/// system- and session-wide events to providers and sessions.
+class Event
+{
+public:
+    // Safe us some typing
+    typedef std::shared_ptr<Event> Ptr;
+
+    /// @brief Receiver models handling of incoming messages.
+    class Receiver
+    {
+    public:
+        // Safe us some typing.
+        typedef std::shared_ptr<Receiver> Ptr;
+
+        /// @cond
+        virtual ~Receiver() = default;
+        Receiver(const Receiver&) = delete;
+        Receiver(Receiver&&) = delete;
+        Receiver& operator=(const Receiver&) = delete;
+        Receiver& operator=(Receiver&&) = delete;
+        /// @endcond
+
+        /// on_new_event is invoked for every new event.
+        virtual void on_new_event(const Event& event) = 0;
+
+    protected:
+        Receiver() = default;
+    };
+
+    /// @brief Type enumerates all known types.
+    ///
+    /// Not an enum class on purpose.
+    enum Type
+    {
+        first_user_defined_type = 1024
+    };
+
+    /// @brief next_user_defined_type returns the next available slot for a user-defined type.
+    static Type next_user_defined_type(const std::string& name);
+
+    /// @brief register_type makes T known to the bus and assigns it a unique Type.
+    template<typename T>
+    static Type register_type(const std::string& name);
+
+    /// @cond
+    virtual ~Event() = default;
+
+    Event(const Event&) = delete;
+    Event(Event&&) = delete;
+    Event& operator=(const Event&) = delete;
+    Event& operator=(Event&&) = delete;
+    /// @endcond
+
+    /// @brief type returns the Type of the message.
+    virtual Type type() const = 0;
+
+    /// @cond
+    Event() = default;
+    /// @endcond
+};
+
+/// @brief TypeOf enables calling code to check for a specific event type.
+template<typename T>
+struct TypeOf
+{
+    /// @brief Query returns the Event::Type registered for T.
+    ///
+    /// Left unimplemented on purpose, to provoke linker errors.
+    /// in the non-specialized case.
+    static Event::Type query();
+};
+
+template<typename T>
+Event::Type Event::register_type(const std::string& name)
+{
+    static Event::Type type{Event::next_user_defined_type(name)};
+    return type;
+}
+}
+
+#endif // LOCATION_EVENT_H_

=== added directory 'include/location/events'
=== added file 'include/location/events/reference_position_updated.h'
--- include/location/events/reference_position_updated.h	1970-01-01 00:00:00 +0000
+++ include/location/events/reference_position_updated.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef LOCATION_EVENTS_REFERENCE_POSITION_UPDATED_H_
+#define LOCATION_EVENTS_REFERENCE_POSITION_UPDATED_H_
+
+#include <location/event.h>
+
+#include <location/position.h>
+#include <location/update.h>
+
+namespace location
+{
+namespace events
+{
+/// @brief ReferencePositionUpdated is sent if the reference position has been updated.
+class ReferencePositionUpdated : public Event
+{
+public:
+    /// @brief ReferencePositionUpdated initializes a new instance with update.
+    ReferencePositionUpdated(const Update<Position>& update);
+    /// @brief ReferencePositionUpdated initializes a new instance from rhs.
+    ReferencePositionUpdated(const ReferencePositionUpdated& rhs);
+    /// @brief operator= assigns rhs to this instance.
+    ReferencePositionUpdated& operator=(const ReferencePositionUpdated& rhs);
+
+    /// @brief update returns the contained update.
+    const Update<Position>& update() const;
+
+    // From Bus::Message
+    Type type() const override;
+
+private:
+    Update<Position> update_;
+};
+}
+template<>
+struct TypeOf<events::ReferencePositionUpdated>
+{
+    static Event::Type query();
+};
+}
+
+#endif // LOCATION_EVENTS_REFERENCE_POSITION_UPDATED_H_

=== added file 'include/location/events/wifi_and_cell_id_reporting_state_changed.h'
--- include/location/events/wifi_and_cell_id_reporting_state_changed.h	1970-01-01 00:00:00 +0000
+++ include/location/events/wifi_and_cell_id_reporting_state_changed.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef LOCATION_EVENTS_WIFI_AND_CELL_ID_REPORTING_STATE_CHANGED_H_
+#define LOCATION_EVENTS_WIFI_AND_CELL_ID_REPORTING_STATE_CHANGED_H_
+
+#include <location/event.h>
+
+#include <location/wifi_and_cell_reporting_state.h>
+
+namespace location
+{
+namespace events
+{
+/// @brief WifiAndCellIdReportingStateChanged is sent if the WifiAndCellIdReportingState changed.
+class WifiAndCellIdReportingStateChanged : public Event
+{
+public:
+    /// @brief WifiAndCellIdReportingStateChanged initializes a new instance with new_state.
+    WifiAndCellIdReportingStateChanged(WifiAndCellIdReportingState new_state);
+    /// @brief WifiAndCellIdReportingStateChanged initializes a new instance from rhs.
+    WifiAndCellIdReportingStateChanged(const WifiAndCellIdReportingStateChanged& rhs);
+    /// @brief operator= assigns rhs to this instance.
+    WifiAndCellIdReportingStateChanged& operator=(const WifiAndCellIdReportingStateChanged& rhs);
+
+    /// @brief new_state returns the new state.
+    WifiAndCellIdReportingState new_state() const;
+
+    // From Bus::Message
+    Type type() const override;
+
+private:
+    WifiAndCellIdReportingState new_state_;
+};
+}
+template<>
+struct TypeOf<events::WifiAndCellIdReportingStateChanged>
+{
+    static Event::Type query();
+};
+}
+
+#endif // LOCATION_EVENTS_WIFI_AND_CELL_ID_REPORTING_STATE_CHANGED_H_

=== added file 'include/location/features.h'
--- include/location/features.h	1970-01-01 00:00:00 +0000
+++ include/location/features.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef LOCATION_FEATURES_H_
+#define LOCATION_FEATURES_H_
+
+#include <iosfwd>
+
+namespace location
+{
+/**
+ * @brief Enumerates the known features that can be supported by providers.
+ */
+enum class Features : std::size_t
+{
+    none        = 0,        ///< The provider does not support any feature.
+    position    = 1 << 0,   ///< The provider features position updates.
+    velocity    = 1 << 1,   ///< The provider features velocity updates.
+    heading     = 1 << 2    ///< The provider features heading updates.
+};
+
+/** @brief operator| returns the bitwise or of lhs and rhs. */
+Features operator|(Features lhs, Features rhs);
+/** @brief operator& returns the bitwise and of lhs and rhs. */
+Features operator&(Features lhs, Features rhs);
+
+/** @brief operator<< inserts features into out. */
+std::ostream& operator<<(std::ostream& out, Features features);
+
+/** @brief operator>> extracts features from in. */
+std::istream& operator>>(std::istream& in, Features& features);
+}
+
+#endif // LOCATION_FEATURES_H_

=== modified file 'include/location/provider.h'
--- include/location/provider.h	2016-06-26 21:17:03 +0000
+++ include/location/provider.h	2016-08-12 12:03:50 +0000
@@ -18,7 +18,9 @@
 #ifndef LOCATION_PROVIDER_H_
 #define LOCATION_PROVIDER_H_
 
+#include <location/configuration.h>
 #include <location/criteria.h>
+#include <location/event.h>
 #include <location/heading.h>
 #include <location/position.h>
 #include <location/space_vehicle.h>
@@ -35,251 +37,67 @@
 
 namespace location
 {
-/**
- * @brief The Provider class is the abstract base of all positioning providers.
- */
-class Provider
+/// @brief The Provider class is the abstract base of all positioning providers.
+class Provider : public Event::Receiver
 {
 public:
-    typedef std::shared_ptr<Provider> Ptr;
-
-    /**
-     * @brief Enumerates the known features that can be supported by providers.
-     */
-    enum class Features : std::size_t
-    {
-        none = 0, ///< The provider does not support any feature.
-        position = 1 << 0, ///< The provider features position updates.
-        velocity = 1 << 1, ///< The provider features velocity updates.
-        heading = 1 << 2 ///< The provider features heading updates.
-    };    
-
-    /**
-     * @brief Enumerates the requirements of a provider implementation.
-     */
+    typedef std::shared_ptr<Provider> Ptr;    
+
+    /// @brief Enumerates the requirements of a provider implementation.
     enum class Requirements : std::size_t
     {
-        none = 0, ///< The provider does not require anything.
-        satellites = 1 << 0, ///< The provider requires satellites to be visible.
-        cell_network = 1 << 1, ///< The provider requires a cell-network to work correctly.
-        data_network = 1 << 2, ///< The provider requires a data-network to work correctly.
-        monetary_spending = 1 << 3 ///< Using the provider results in monetary cost.
-    };
-
-    /**
-     * @brief Facade for controlling the state of position/heading/velocity updates.
-     *
-     * Multiple observers can request state changes for updates. This class ensures
-     * that the specific updates are started and stopped if at least one observer
-     * requests them and stopped when the last observer issues a stop request.
-     */
-    class Controller
-    {
-    public:
-        typedef std::shared_ptr<Controller> Ptr; 
-
-        virtual ~Controller() = default;
-        Controller(const Controller&) = delete;
-        Controller& operator=(const Controller&) = delete;        
-
-        /**
-         * @brief disable switches the provider to a disabled state, such that subsequent
-         * calls to start* methods fail.
-         */
-        void disable();
-
-        /**
-         * @brief enable switches the provider to an enabled state, such that subsequent
-         * calls to start* methods succeed.
-         */
-        void enable();
-
-        /**
-         * @brief Request to start position updates if not already running.
-         */
-        virtual void start_position_updates();
-
-        /**
-         * @brief Request to stop position updates. Only stops the provider when the last observer calls this function.
-         */
-        virtual void stop_position_updates();
-
-        /**
-         * @brief Checks if position updates are currently running.
-         * @return true iff position updates are currently running.
-         */
-        bool are_position_updates_running() const;
-
-        /**
-         * @brief Request to start heading updates if not already running.
-         */
-        virtual void start_heading_updates();
-
-        /**
-         * @brief Request to stop heading updates. Only stops the provider when the last observer calls this function.
-         */
-        virtual void stop_heading_updates();
-
-        /**
-         * @brief Checks if position updates are currently running.
-         * @return true iff position updates are currently running.
-         */
-        bool are_heading_updates_running() const;
-
-        /**
-         * @brief Request to start velocity updates if not already running.
-         */
-        virtual void start_velocity_updates();
-
-        /**
-         * @brief Request to stop velocity updates. Only stops the provider when the last observer calls this function.
-         */
-        virtual void stop_velocity_updates();
-
-        /**
-         * @brief Checks if velocity updates are currently running.
-         * @return true iff velocity updates are currently running.
-         */
-        bool are_velocity_updates_running() const;
-
-    protected:
-        friend class Provider;
-        explicit Controller(Provider& instance);
-
-    private:
-        Provider& instance;
-        std::atomic<int> position_updates_counter;
-        std::atomic<int> heading_updates_counter;
-        std::atomic<int> velocity_updates_counter;
-    };
-
-    /**
-     * @brief Wraps all updates that can be delivered by a provider.
-     */
-    struct Updates
-    {
-        /** Position updates. */
-        core::Signal<Update<Position>> position;
-        /** Heading updates. */
-        core::Signal<Update<Heading>> heading;
-        /** Velocity updates. */
-        core::Signal<Update<Velocity>> velocity;
-        /** Space vehicle visibility updates. */
-        core::Signal<Update<std::set<SpaceVehicle>>> svs;
-    };
-
+        none = 0,                   ///< The provider does not require anything.
+        satellites = 1 << 0,        ///< The provider requires satellites to be visible.
+        cell_network = 1 << 1,      ///< The provider requires a cell-network to work correctly.
+        data_network = 1 << 2,      ///< The provider requires a data-network to work correctly.
+        monetary_spending = 1 << 3  ///< Using the provider results in monetary cost.
+    };
+
+    /// @cond
     virtual ~Provider() = default;
 
     Provider(const Provider&) = delete;
+    Provider(Provider&&) = delete;
     Provider& operator=(const Provider&) = delete;
-
-    /**
-     * @brief Provides non-mutable access to this provider's updates.
-     * @return A non-mutable reference to the updates.
-     */
-    virtual const Updates& updates() const;
-
-    /**
-     * @brief Access to the controller facade of this provider instance.
-     */
-    virtual const Controller::Ptr& state_controller() const;
-
-    /**
-     * @brief Checks if the provider supports a specific feature.
-     * @param f Feature to test for
-     * @return true iff the provider supports the feature.
-     */
-    virtual bool supports(const Features& f) const;
-
-    /**
-     * @brief Checks if the provider has got a specific requirement.
-     * @param r Requirement to test for.
-     * @return true iff the provider has the specific requirement.
-     */
-    virtual bool requires(const Requirements& r) const;
-
-    /**
-     * @brief Checks if a provider satisfies a set of accuracy criteria.
-     * @param [in] criteria The criteria to check.
-     * @return true iff the provider satisfies the given criteria.
-     */
-    virtual bool matches_criteria(const Criteria& criteria);
-
-    /**
-     * @brief Called by the engine whenever the wifi and cell ID reporting state changes.
-     * @param state The new state.
-     */
-    virtual void on_wifi_and_cell_reporting_state_changed(WifiAndCellIdReportingState state);
-
-    /**
-     * @brief Called by the engine whenever the reference location changed.
-     * @param position The new reference location.
-     */
-    virtual void on_reference_location_updated(const Update<Position>& position);
-
-    /**
-     * @brief Called by the engine whenever the reference velocity changed.
-     * @param velocity The new reference velocity.
-     */
-    virtual void on_reference_velocity_updated(const Update<Velocity>& velocity);
-
-    /**
-     * @brief Called by the engine whenever the reference heading changed.
-     * @param heading The new reference heading.
-     */
-    virtual void on_reference_heading_updated(const Update<Heading>& heading);
+    Provider& operator=(Provider&&) = delete;
+    /// @endcond
+
+    /// @brief enable enables the provider, throws in case of issues.
+    virtual void enable() = 0;
+
+    /// @brief start disables the provider, throws in case of issues.
+    virtual void disable() = 0;
+
+    /// @brief activate triggers a state transition from enabled to active.
+    virtual void activate() = 0;
+
+    /// @brief deactivate triggers a state transition from active to enabled.
+    virtual void deactivate() = 0;
+
+    /// @brief requirements returns the requirements of the provider.
+    virtual Requirements requirements() const = 0;
+
+    /// @brief Checks if a provider satisfies criteria.
+    /// @param [in] criteria The criteria to check.
+    /// @return true iff the provider satisfies the given criteria.
+    virtual bool satisfies(const Criteria& criteria) = 0;
+
+    /// @brief position_updates returns a signal delivering position updates.
+    virtual const core::Signal<Update<Position>>& position_updates() const = 0;
+
+    /// @brief heading_updates returns a signal delivering heading updates.
+    virtual const core::Signal<Update<Heading>>& heading_updates() const = 0;
+
+    /// @brief velocity_updates returns a signal delivering velocity updates.
+    virtual const core::Signal<Update<Velocity>>& velocity_updates() const = 0;
 
 protected:
-    explicit Provider(
-        const Features& features = Features::none,
-        const Requirements& requirements = Requirements::none);
-
-    virtual Updates& mutable_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void start_position_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void stop_position_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void start_heading_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void stop_heading_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void start_velocity_updates();
-
-    /**
-     * @brief Implementation-specific, empty by default.
-     */
-    virtual void stop_velocity_updates();
-
-private:
-    struct
-    {
-        Features features = Features::none;
-        Requirements requirements = Requirements::none;
-        Updates updates;
-        Controller::Ptr controller = Controller::Ptr{};
-    } d;
+    Provider() = default;
 };
 
-Provider::Features operator|(Provider::Features lhs, Provider::Features rhs);
-Provider::Features operator&(Provider::Features lhs, Provider::Features rhs);
-
+/// @brief operator| returns the bitwise or of lhs and rhs.
 Provider::Requirements operator|(Provider::Requirements lhs, Provider::Requirements rhs);
+/// @brief operator& returns the bitwise and of lhs and rhs.
 Provider::Requirements operator&(Provider::Requirements lhs, Provider::Requirements rhs);
 }
 

=== modified file 'src/location/CMakeLists.txt'
--- src/location/CMakeLists.txt	2016-08-12 12:03:49 +0000
+++ src/location/CMakeLists.txt	2016-08-12 12:03:50 +0000
@@ -15,20 +15,16 @@
 
   ${UBUNTU_LOCATION_SERVICE_PUBLIC_HEADERS}
 
-  default_provider_selection_policy.cpp
   fusion_provider_selection_policy.cpp
   non_selecting_provider_selection_policy.cpp
 
-  criteria.cpp
   engine.cpp
-  fusion_provider.cpp
+  event.cpp
   position.cpp
   provider.cpp
   provider_factory.cpp
-  proxy_provider.cpp
   satellite_based_positioning_state.cpp
   settings.cpp
-  state_tracking_provider.h
   time_based_update_policy.cpp
   set_name_for_thread.cpp
   time_since_boot.cpp
@@ -40,14 +36,13 @@
   daemon.cpp
   service.cpp
 
-  dummy_service.h
-  dummy_service.cpp
-
   permission_manager.h
   runtime.h
   runtime.cpp
   runtime_tests.h
   runtime_tests.cpp
+  serializing_bus.h
+  serializing_bus.cpp
   service_with_engine.h
   service_with_engine.cpp
   session_with_provider.h
@@ -85,11 +80,23 @@
   dbus/stub/session.h
   dbus/stub/session.cpp
 
+  events/all.h
+  events/registry.h
+  events/registry.cpp
+  events/reference_position_updated.cpp
+  events/wifi_and_cell_id_reporting_state_changed.cpp
+
   providers/config.cpp
 
+  providers/fusion/provider.h
+  providers/fusion/provider.cpp
   providers/remote/provider.cpp
   providers/remote/skeleton.cpp
   providers/remote/stub.cpp
+  providers/proxy.h
+  providers/proxy.cpp
+  providers/state_tracking_provider.h
+  providers/state_tracking_provider.cpp
 )
 
 add_library(

=== added file 'src/location/bus.h'
--- src/location/bus.h	1970-01-01 00:00:00 +0000
+++ src/location/bus.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_BUS_H_
+#define LOCATION_BUS_H_
+
+#include <location/event.h>
+
+#include <memory>
+
+namespace location
+{
+/// @brief Bus provides a simple way for distributing events to multiple listeners.
+class Bus
+{
+public:
+    // Safe us some typing
+    typedef std::shared_ptr<Bus> Ptr;
+
+    /// @brief subscribe makes receiver known to the bus.
+    virtual void subscribe(const Event::Receiver::Ptr& receiver) = 0;
+
+    /// @brief unsubscribe removes receiver from the bus.
+    virtual void unsubscribe(const Event::Receiver::Ptr& receiver) = 0;
+
+    /// @brief dispatch takes eventand hands it to all subscribed receivers.
+    virtual void dispatch(const Event::Ptr& event) = 0;
+};
+}
+
+#endif // LOCATION_BUS_H_

=== modified file 'src/location/cmds/provider.cpp'
--- src/location/cmds/provider.cpp	2016-08-12 12:03:49 +0000
+++ src/location/cmds/provider.cpp	2016-08-12 12:03:50 +0000
@@ -51,7 +51,7 @@
         die_if(not id, ctxt.cout, "name of actual provider implementation is missing");
 
         // We exit cleanly for SIGINT and SIGTERM.
-        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_int, core::posix::Signal::sig_term});
+        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_term});
         trap->signal_raised().connect([trap](core::posix::Signal)
         {
             trap->stop();

=== modified file 'src/location/cmds/run.cpp'
--- src/location/cmds/run.cpp	2016-08-12 12:03:49 +0000
+++ src/location/cmds/run.cpp	2016-08-12 12:03:50 +0000
@@ -22,6 +22,7 @@
 #include <location/boost_ptree_settings.h>
 #include <location/fusion_provider_selection_policy.h>
 #include <location/runtime.h>
+#include <location/serializing_bus.h>
 #include <location/service_with_engine.h>
 #include <location/settings.h>
 #include <location/trust_store_permission_manager.h>
@@ -51,17 +52,21 @@
         account_for_lp1447110();
 
         // We exit cleanly for SIGINT and SIGTERM.
-        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_int, core::posix::Signal::sig_term});
+        auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_term});
         trap->signal_raised().connect([trap](core::posix::Signal)
         {
             trap->stop();
         });        
 
+        auto rt = location::Runtime::create();
+
         // The engine instance is the core piece of functionality.
         auto engine = std::make_shared<location::Engine>(
             // We default to a fusion provider selection policy, providing
             // fusioned and filtered updates to sessions.
             std::make_shared<location::FusionProviderSelectionPolicy>(),
+            // We serialize all messages passed through our internal bus via a specific strand on the runtime.
+            location::SerializingBus::create(rt),
             // We default to a location::Settings implementation that reads state from
             // an ini file, immediately syncing back changes to the underlying file whenever
             // parameters change.
@@ -72,9 +77,7 @@
         {
             ctxt.cout << "Running under testing..." << std::endl;
             engine->add_provider(std::make_shared<location::providers::dummy::Provider>());
-        }
-
-        auto rt = location::Runtime::create();
+        }        
 
         auto incoming = std::make_shared<core::dbus::Bus>(bus);
         auto outgoing = std::make_shared<core::dbus::Bus>(bus);

=== removed file 'src/location/criteria.cpp'
--- src/location/criteria.cpp	2016-06-26 21:17:03 +0000
+++ src/location/criteria.cpp	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-/*
- * Copyright © 2012-2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-
-#include <location/criteria.h>
-
-bool location::Criteria::satisfies(const location::Criteria& rhs) const
-{
-    bool result = false;
-
-    if (rhs.requires.position)
-        result &= requires.position;
-
-    if (rhs.requires.altitude)
-        result &= requires.altitude;
-
-    if (rhs.requires.heading)
-        result &= requires.heading;
-
-    if (rhs.requires.velocity)
-        result &= requires.velocity;
-
-    result &= accuracy.horizontal <= rhs.accuracy.horizontal;
-
-    if (rhs.accuracy.vertical)
-        result &= accuracy.vertical && accuracy.vertical <= rhs.accuracy.vertical;
-
-    if (rhs.accuracy.heading)
-        result &= accuracy.heading && accuracy.heading <= rhs.accuracy.heading;
-
-    if (rhs.accuracy.velocity)
-        result &= accuracy.velocity && accuracy.velocity <= rhs.accuracy.velocity;
-
-    return result;
-}
-
-location::Criteria location::operator+(
-        const location::Criteria& lhs,
-        const location::Criteria& rhs)
-{
-    Criteria result{lhs};
-
-    result.requires.position |= rhs.requires.position;
-    result.requires.velocity |= rhs.requires.velocity;
-    result.requires.heading |= rhs.requires.heading;
-    result.requires.altitude |= rhs.requires.altitude;
-
-    if (rhs.accuracy.horizontal < result.accuracy.horizontal)
-        result.accuracy.horizontal = rhs.accuracy.horizontal;
-
-    if (result.accuracy.vertical)
-    {
-        if (rhs.accuracy.vertical && rhs.accuracy.vertical < result.accuracy.vertical)
-        {
-            result.accuracy.vertical = rhs.accuracy.vertical;
-        }
-    } else
-    {
-        result.accuracy.vertical = rhs.accuracy.vertical;
-    }
-
-    if (result.accuracy.velocity)
-    {
-        if (rhs.accuracy.velocity && rhs.accuracy.velocity < result.accuracy.velocity)
-        {
-            result.accuracy.velocity = rhs.accuracy.velocity;
-        }
-    } else
-    {
-        result.accuracy.velocity = rhs.accuracy.velocity;
-    }
-
-    if (result.accuracy.heading)
-    {
-        if (rhs.accuracy.heading && rhs.accuracy.heading < result.accuracy.heading)
-        {
-            result.accuracy.heading = rhs.accuracy.heading;
-        }
-    } else
-    {
-        result.accuracy.heading = rhs.accuracy.heading;
-    }
-
-    return result;
-}

=== modified file 'src/location/dbus/codec.h'
--- src/location/dbus/codec.h	2016-08-12 12:03:49 +0000
+++ src/location/dbus/codec.h	2016-08-12 12:03:50 +0000
@@ -19,6 +19,7 @@
 #define LOCATION_CODEC_H_
 
 #include <location/criteria.h>
+#include <location/features.h>
 #include <location/heading.h>
 #include <location/position.h>
 #include <location/provider.h>
@@ -26,6 +27,10 @@
 #include <location/update.h>
 #include <location/velocity.h>
 #include <location/service.h>
+#include <location/events/all.h>
+#include <location/events/registry.h>
+#include <location/events/reference_position_updated.h>
+#include <location/events/wifi_and_cell_id_reporting_state_changed.h>
 #include <location/units/units.h>
 #include <location/wgs84/altitude.h>
 #include <location/wgs84/latitude.h>
@@ -107,6 +112,31 @@
         return s;
     }
 };
+
+template<typename T>
+struct TypeMapper<location::Optional<T>>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::structure;
+    }
+
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+
+    constexpr static bool requires_signature()
+    {
+        return true;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = DBUS_STRUCT_BEGIN_CHAR_AS_STRING + TypeMapper<bool>::signature() + DBUS_TYPE_VARIANT_AS_STRING + DBUS_STRUCT_END_CHAR_AS_STRING;
+        return s;
+    }
+};
 }
 
 template<typename T>
@@ -114,24 +144,43 @@
 {
     static void encode_argument(Message::Writer& writer, const location::Optional<T>& in)
     {
-        bool has_value{in};
-        Codec<bool>::encode_argument(writer, has_value);
-        if (has_value)
-            Codec<typename location::Optional<T>::value_type>::encode_argument(writer, *in);
+        auto sw = writer.open_structure();
+        {
+            bool has_value{in};
+            Codec<bool>::encode_argument(sw, has_value);
+
+            if (has_value)
+            {
+                auto vw = sw.open_variant(types::Signature{helper::TypeMapper<T>::signature()});
+                Codec<T>::encode_argument(vw, *in);
+                sw.close_variant(std::move(vw));
+            }
+            else
+            {
+                auto vw = sw.open_variant(types::Signature{helper::TypeMapper<bool>::signature()});
+                Codec<bool>::encode_argument(vw, false);
+                sw.close_variant(std::move(vw));
+            }
+        }
+        writer.close_structure(std::move(sw));
     }
 
     static void decode_argument(Message::Reader& reader, location::Optional<T>& in)
     {
-        bool has_value{false};
-        Codec<bool>::decode_argument(reader, has_value);
-        if (has_value)
-        {
-            typename location::Optional<T>::value_type value;
-            Codec<typename location::Optional<T>::value_type>::decode_argument(reader, value);
-            in = value;
-        } else
-        {
-            in.reset();
+        auto sr = reader.pop_structure();
+        {
+            bool has_value{false};
+            Codec<bool>::decode_argument(sr, has_value);
+            auto vr = sr.pop_variant();
+            if (has_value)
+            {
+                T value;
+                Codec<T>::decode_argument(vr, value);
+                in = value;
+            } else
+            {
+                in.reset();
+            }
         }
     }
 };
@@ -152,6 +201,33 @@
     }
 };
 
+namespace helper
+{
+template<typename T, typename U>
+struct TypeMapper<location::wgs84::Coordinate<T, U>>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return TypeMapper<location::units::Quantity<U>>::type_value();
+    }
+
+    constexpr static bool is_basic_type()
+    {
+        return true;
+    }
+    constexpr static bool requires_signature()
+    {
+        return true;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<location::units::Quantity<U>>::signature();
+        return s;
+    }
+};
+}
+
 template<typename T, typename U>
 struct Codec<location::wgs84::Coordinate<T,U>>
 {
@@ -166,6 +242,40 @@
     }
 };
 
+namespace helper
+{
+template<>
+struct TypeMapper<location::Position>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::structure;
+    }
+
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return true;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s =
+                DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
+                TypeMapper<location::wgs84::Latitude>::signature() +
+                TypeMapper<location::wgs84::Longitude>::signature() +
+                TypeMapper<location::Optional<location::wgs84::Altitude>>::signature() +
+                TypeMapper<location::Optional<location::Position::Accuracy::Horizontal>>::signature() +
+                TypeMapper<location::Optional<location::Position::Accuracy::Vertical>>::signature() +
+                DBUS_STRUCT_END_CHAR_AS_STRING;
+        return s;
+    }
+};
+}
+
 template<>
 struct Codec<location::Position>
 {
@@ -174,22 +284,29 @@
 
     static void encode_argument(Message::Writer& writer, const location::Position& in)
     {
-        Codec<location::wgs84::Latitude>::encode_argument(writer, in.latitude);
-        Codec<location::wgs84::Longitude>::encode_argument(writer, in.longitude);
-        Codec<location::Optional<location::wgs84::Altitude>>::encode_argument(writer, in.altitude);
+        auto vw = writer.open_structure();
+        {
+            Codec<location::wgs84::Latitude>::encode_argument(vw, in.latitude);
+            Codec<location::wgs84::Longitude>::encode_argument(vw, in.longitude);
+            Codec<location::Optional<location::wgs84::Altitude>>::encode_argument(vw, in.altitude);
 
-        Codec<location::Optional<HorizontalAccuracy>>::encode_argument(writer, in.accuracy.horizontal);
-        Codec<location::Optional<VerticalAccuracy>>::encode_argument(writer, in.accuracy.vertical);
+            Codec<location::Optional<HorizontalAccuracy>>::encode_argument(vw, in.accuracy.horizontal);
+            Codec<location::Optional<VerticalAccuracy>>::encode_argument(vw, in.accuracy.vertical);
+        }
+        writer.close_structure(std::move(vw));
     }
 
     static void decode_argument(Message::Reader& reader, location::Position& in)
     {
-        Codec<location::wgs84::Latitude>::decode_argument(reader, in.latitude);
-        Codec<location::wgs84::Longitude>::decode_argument(reader, in.longitude);
-        Codec<location::Optional<location::wgs84::Altitude>>::decode_argument(reader, in.altitude);
+        auto vr = reader.pop_structure();
+        {
+            Codec<location::wgs84::Latitude>::decode_argument(vr, in.latitude);
+            Codec<location::wgs84::Longitude>::decode_argument(vr, in.longitude);
+            Codec<location::Optional<location::wgs84::Altitude>>::decode_argument(vr, in.altitude);
 
-        Codec<location::Optional<HorizontalAccuracy>>::decode_argument(reader, in.accuracy.horizontal);
-        Codec<location::Optional<VerticalAccuracy>>::decode_argument(reader, in.accuracy.vertical);
+            Codec<location::Optional<HorizontalAccuracy>>::decode_argument(vr, in.accuracy.horizontal);
+            Codec<location::Optional<VerticalAccuracy>>::decode_argument(vr, in.accuracy.vertical);
+        }
     }
 };
 
@@ -355,6 +472,53 @@
 };
 
 template<>
+struct Codec<location::Features>
+{
+    static void encode_argument(Message::Writer& writer, const location::Features& in)
+    {
+        writer.push_int32(static_cast<std::int32_t>(in));
+    }
+
+    static void decode_argument(Message::Reader& reader, location::Features& in)
+    {
+        in = static_cast<location::Features>(reader.pop_int32());
+    }
+};
+
+namespace helper
+{
+template<>
+struct TypeMapper<location::Criteria>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::structure;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return true;
+    }
+
+    inline static std::string signature()
+    {
+        std::string s =
+            DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
+                TypeMapper<std::int32_t>::signature() +
+                TypeMapper<location::Optional<location::Position::Accuracy::Horizontal>>::signature() +
+                TypeMapper<location::Optional<location::Position::Accuracy::Vertical>>::signature() +
+                TypeMapper<location::Optional<location::units::Quantity<location::units::Velocity>>>::signature() +
+                TypeMapper<location::Optional<location::units::Quantity<location::units::PlaneAngle>>>::signature() +
+            DBUS_STRUCT_END_CHAR_AS_STRING;
+        return s;
+    }
+};
+}
+
+template<>
 struct Codec<location::Criteria>
 {
     typedef location::units::Quantity<location::units::Length> HorizontalAccuracy;
@@ -364,12 +528,9 @@
 
     static void encode_argument(Message::Writer& writer, const location::Criteria& in)
     {
-        Codec<bool>::encode_argument(writer, in.requires.position);
-        Codec<bool>::encode_argument(writer, in.requires.altitude);
-        Codec<bool>::encode_argument(writer, in.requires.heading);
-        Codec<bool>::encode_argument(writer, in.requires.velocity);
+        Codec<location::Features>::encode_argument(writer, in.requirements);
 
-        Codec<HorizontalAccuracy>::encode_argument(writer, in.accuracy.horizontal);
+        Codec<location::Optional<HorizontalAccuracy>>::encode_argument(writer, in.accuracy.horizontal);
         Codec<location::Optional<VerticalAccuracy>>::encode_argument(writer, in.accuracy.vertical);
         Codec<location::Optional<VelocityAccuracy>>::encode_argument(writer, in.accuracy.velocity);
         Codec<location::Optional<HeadingAccuracy>>::encode_argument(writer, in.accuracy.heading);
@@ -377,12 +538,9 @@
 
     static void decode_argument(Message::Reader& reader, location::Criteria& in)
     {
-        Codec<bool>::decode_argument(reader, in.requires.position);
-        Codec<bool>::decode_argument(reader, in.requires.altitude);
-        Codec<bool>::decode_argument(reader, in.requires.heading);
-        Codec<bool>::decode_argument(reader, in.requires.velocity);
+        Codec<location::Features>::decode_argument(reader, in.requirements);
 
-        Codec<HorizontalAccuracy>::decode_argument(reader, in.accuracy.horizontal);
+        Codec<location::Optional<HorizontalAccuracy>>::decode_argument(reader, in.accuracy.horizontal);
         Codec<location::Optional<VerticalAccuracy>>::decode_argument(reader, in.accuracy.vertical);
         Codec<location::Optional<VelocityAccuracy>>::decode_argument(reader, in.accuracy.velocity);
         Codec<location::Optional<HeadingAccuracy>>::decode_argument(reader, in.accuracy.heading);
@@ -390,20 +548,6 @@
 };
 
 template<>
-struct Codec<location::Provider::Features>
-{
-    static void encode_argument(Message::Writer& writer, const location::Provider::Features& in)
-    {
-        writer.push_int32(static_cast<std::int32_t>(in));
-    }
-
-    static void decode_argument(Message::Reader& reader, location::Provider::Features& in)
-    {
-        in = static_cast<location::Provider::Features>(reader.pop_int32());
-    }
-};
-
-template<>
 struct Codec<location::Provider::Requirements>
 {
     static void encode_argument(Message::Writer& writer, const location::Provider::Requirements& in)
@@ -417,6 +561,33 @@
     }
 };
 
+namespace helper
+{
+template<>
+struct TypeMapper<location::WifiAndCellIdReportingState>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::int32;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return true;
+    }
+
+    constexpr static bool requires_signature()
+    {
+        return true;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = helper::TypeMapper<std::int32_t>::signature();
+        return s;
+    }
+};
+}
+
 template<>
 struct Codec<location::WifiAndCellIdReportingState>
 {
@@ -452,8 +623,10 @@
     static std::string signature()
     {
         static const std::string s =
+                DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
                 helper::TypeMapper<T>::signature() +
-                helper::TypeMapper<uint64_t>::signature();
+                helper::TypeMapper<int64_t>::signature() +
+                DBUS_STRUCT_END_CHAR_AS_STRING;
         return s;
     }
 };
@@ -464,16 +637,110 @@
 {
     static void encode_argument(Message::Writer& writer, const location::Update<T>& in)
     {
-        Codec<T>::encode_argument(writer, in.value);
-        Codec<int64_t>::encode_argument(writer, in.when.time_since_epoch().count());
+        auto sw = writer.open_structure();
+        {
+            Codec<T>::encode_argument(sw, in.value);
+            Codec<int64_t>::encode_argument(sw, in.when.time_since_epoch().count());
+        }
+        writer.close_structure(std::move(sw));
     }
 
     static void decode_argument(Message::Reader& reader, location::Update<T>& in)
     {
-        Codec<T>::decode_argument(reader, in.value);
-        in.when = location::Clock::Timestamp(location::Clock::Duration(reader.pop_int64()));
+        auto sr = reader.pop_structure();
+        Codec<T>::decode_argument(sr, in.value);
+        in.when = location::Clock::Timestamp(location::Clock::Duration(sr.pop_int64()));
     }    
 };
+
+template<>
+struct Codec<location::events::ReferencePositionUpdated>
+{
+    static void encode_argument(Message::Writer& out, const location::events::ReferencePositionUpdated& event)
+    {
+        Codec<location::Update<location::Position>>::encode_argument(out, event.update());
+    }
+
+    static void decode_argument(Message::Reader& in, location::events::ReferencePositionUpdated& event)
+    {
+        location::Update<location::Position> update;
+        Codec<location::Update<location::Position>>::decode_argument(in, update);
+        event = location::events::ReferencePositionUpdated{update};
+    }
+};
+
+template<>
+struct Codec<location::events::WifiAndCellIdReportingStateChanged>
+{
+    static void encode_argument(Message::Writer& out, const location::events::WifiAndCellIdReportingStateChanged& event)
+    {
+        Codec<location::WifiAndCellIdReportingState>::encode_argument(out, event.new_state());
+    }
+
+    static void decode_argument(Message::Reader& in, location::events::WifiAndCellIdReportingStateChanged& event)
+    {
+        location::WifiAndCellIdReportingState new_state;
+        Codec<location::WifiAndCellIdReportingState>::decode_argument(in, new_state);
+        event = location::events::WifiAndCellIdReportingStateChanged{new_state};
+    }
+};
+
+template<>
+struct Codec<location::events::All>
+{
+    static void encode_argument(Message::Writer& out, const location::events::All& event)
+    {
+        switch (event.which())
+        {
+        case 1:
+        {
+            const auto& ev = boost::get<location::events::ReferencePositionUpdated>(event);
+            auto name = location::events::Registry::instance().find(ev.type());
+            out.push_stringn(name.c_str(), name.size());
+            auto vw = out.open_variant(types::Signature{helper::TypeMapper<location::Update<location::Position>>::signature()});
+            {
+                Codec<location::events::ReferencePositionUpdated>::encode_argument(vw, ev);
+            }
+            out.close_variant(std::move(vw));
+            break;
+        }
+        case 2:
+        {
+            const auto& ev = boost::get<location::events::WifiAndCellIdReportingStateChanged>(event);
+            auto name = location::events::Registry::instance().find(ev.type());
+            out.push_stringn(name.c_str(), name.size());
+            auto vw = out.open_variant(types::Signature{helper::TypeMapper<location::WifiAndCellIdReportingState>::signature()});
+            {
+                Codec<location::events::WifiAndCellIdReportingStateChanged>::encode_argument(vw, ev);
+            }
+            out.close_variant(std::move(vw));
+            break;
+        }
+        }
+    }
+
+    static void decode_argument(Message::Reader& in, location::events::All& event)
+    {
+        std::string name{in.pop_string()};
+
+        auto type = location::events::Registry::instance().find(name);
+
+        if (type == location::TypeOf<location::events::ReferencePositionUpdated>::query())
+        {
+            location::events::ReferencePositionUpdated ev{location::Update<location::Position>{}};
+            auto vr = in.pop_variant();
+            Codec<location::events::ReferencePositionUpdated>::decode_argument(vr, ev);
+            event = ev;
+        }
+        else if (type == location::TypeOf<location::events::WifiAndCellIdReportingStateChanged>::query())
+        {
+            location::events::WifiAndCellIdReportingStateChanged ev{location::WifiAndCellIdReportingState::off};
+            auto vr = in.pop_variant();
+            Codec<location::events::WifiAndCellIdReportingStateChanged>::decode_argument(vr, ev);
+            event = ev;
+        }
+    }
+};
 }
 }
 

=== modified file 'src/location/dbus/skeleton/service.cpp'
--- src/location/dbus/skeleton/service.cpp	2016-08-12 12:03:49 +0000
+++ src/location/dbus/skeleton/service.cpp	2016-08-12 12:03:50 +0000
@@ -150,13 +150,22 @@
 
     try
     {
+        auto thiz = shared_from_this(); std::weak_ptr<Service> wp{thiz};
+
         std::string sender = msg->sender();
         core::dbus::types::ObjectPath path; msg->reader() >> path;
-        auto service = core::dbus::Service::use_service(configuration.outgoing, sender);
+        auto service = core::dbus::Service::use_service(configuration.incoming, sender);
         auto object = service->object_for_path(path);
 
-        add_provider(location::providers::remote::stub::create_with_configuration({object}));
-        configuration.outgoing->send(core::dbus::Message::make_method_return(msg));
+        location::providers::remote::stub::create_with_configuration({configuration.outgoing, service, object}, [wp, msg](const Provider::Ptr& provider)
+        {
+            if (auto sp = wp.lock())
+            {
+                sp->add_provider(provider);
+                sp->configuration.outgoing->send(core::dbus::Message::make_method_return(msg));
+            }
+        });
+
     }
     catch(...)
     {
@@ -215,6 +224,7 @@
         auto watcher = daemon.make_service_watcher(sender);
         watcher->owner_changed().connect([thiz, path](const std::string&, const std::string&)
         {
+            LOG(INFO) << "Purging session for path: " << path.as_string();
             thiz->remove_from_session_store_for_path(path);
         });
 

=== modified file 'src/location/dbus/skeleton/session.cpp'
--- src/location/dbus/skeleton/session.cpp	2016-08-12 12:03:49 +0000
+++ src/location/dbus/skeleton/session.cpp	2016-08-12 12:03:50 +0000
@@ -269,10 +269,10 @@
 // Invoked whenever the actual session impl. for the session reports a position update.
 void location::dbus::skeleton::Session::on_position_changed(const location::Update<location::Position>& position)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
     try
     {
-        configuration.remote.object->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdatePosition, void>([](const core::dbus::Result<void>& result)
+        auto sp = configuration.remote.object;
+        configuration.remote.object->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdatePosition, void>([sp](const core::dbus::Result<void>& result)
         {
             if (result.is_error())
             {
@@ -292,10 +292,10 @@
 // Invoked whenever the actual session impl. reports a heading update.
 void location::dbus::skeleton::Session::on_heading_changed(const location::Update<location::Heading>& heading)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
     try
     {
-        configuration.remote.object->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdateHeading, void>([](const core::dbus::Result<void>& result)
+        auto sp = configuration.remote.object;
+        configuration.remote.object->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdateHeading, void>([sp](const core::dbus::Result<void>& result)
         {
             if (result.is_error())
             {
@@ -315,10 +315,10 @@
 // Invoked whenever the actual session impl. reports a velocity update.
 void location::dbus::skeleton::Session::on_velocity_changed(const location::Update<location::Velocity>& velocity)
 {
-    VLOG(10) << __PRETTY_FUNCTION__;
     try
     {
-        configuration.remote.object->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdateVelocity, void>([](const core::dbus::Result<void>& result)
+        auto sp = configuration.remote.object;
+        sp->invoke_method_asynchronously_with_callback<location::dbus::Session::UpdateVelocity, void>([sp](const core::dbus::Result<void>& result)
         {
             if (result.is_error())
             {

=== modified file 'src/location/dbus/skeleton/session.h'
--- src/location/dbus/skeleton/session.h	2016-06-28 11:53:34 +0000
+++ src/location/dbus/skeleton/session.h	2016-08-12 12:03:50 +0000
@@ -100,6 +100,7 @@
 
     // Stores all attributes passed at creation time.
     Configuration configuration;
+
     // Scoped connections for automatically disconnecting on destruction
     struct
     {

=== modified file 'src/location/dbus/stub/service.cpp'
--- src/location/dbus/stub/service.cpp	2016-08-12 12:03:49 +0000
+++ src/location/dbus/stub/service.cpp	2016-08-12 12:03:50 +0000
@@ -22,6 +22,7 @@
 #include <location/dbus/codec.h>
 #include <location/dbus/service.h>
 
+#include <location/providers/remote/interface.h>
 #include <location/providers/remote/skeleton.h>
 
 #include <location/logging.h>

=== removed file 'src/location/default_provider_selection_policy.cpp'
--- src/location/default_provider_selection_policy.cpp	2016-06-26 21:17:03 +0000
+++ src/location/default_provider_selection_policy.cpp	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-/*
- * Copyright © 2012-2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-#include <location/default_provider_selection_policy.h>
-
-#include <location/engine.h>
-
-namespace
-{
-struct NullProvider : public location::Provider
-{
-    NullProvider() = default;
-};
-
-std::shared_ptr<location::Provider> null_provider_instance
-{
-    new NullProvider{}
-};
-}
-
-const location::Provider::Ptr& location::ProviderSelectionPolicy::null_provider()
-{
-    return null_provider_instance;
-}
-
-location::DefaultProviderSelectionPolicy::DefaultProviderSelectionPolicy()
-{
-}
-
-location::DefaultProviderSelectionPolicy::~DefaultProviderSelectionPolicy() noexcept
-{
-}
-
-location::ProviderSelection
-location::DefaultProviderSelectionPolicy::determine_provider_selection_for_criteria(
-    const location::Criteria& criteria,
-    const location::ProviderEnumerator& enumerator)
-{
-    ProviderSelection selection
-    {
-        determine_position_updates_provider(criteria, enumerator),
-        determine_heading_updates_provider(criteria, enumerator),
-        determine_velocity_updates_provider(criteria, enumerator)
-    };
-    
-    return selection;
-}
-
-location::Provider::Ptr
-location::DefaultProviderSelectionPolicy::determine_position_updates_provider(
-    const location::Criteria& criteria,
-    const location::ProviderEnumerator& enumerator)
-{
-    auto less = 
-            [](const Provider::Ptr& lhs, const Provider::Ptr& rhs)
-            {
-                return
-                lhs->state_controller()->are_position_updates_running() && !rhs->state_controller()->are_position_updates_running();
-            };
-
-    std::set<
-        Provider::Ptr,
-        std::function<bool(const Provider::Ptr&, const Provider::Ptr&)>> matching_providers(less);
-
-    enumerator.for_each_provider(
-        [&](const Provider::Ptr& provider)
-        {
-            if (provider->matches_criteria(criteria))
-                matching_providers.insert(provider);
-        });
-
-    return matching_providers.empty() ? null_provider() : *matching_providers.begin();
-}
-
-location::Provider::Ptr location::DefaultProviderSelectionPolicy::determine_heading_updates_provider(
-    const location::Criteria& criteria,
-    const location::ProviderEnumerator& enumerator)
-{
-    auto less = 
-            [](const Provider::Ptr& lhs, const Provider::Ptr& rhs)
-            {
-                return lhs->state_controller()->are_heading_updates_running() && !rhs->state_controller()->are_heading_updates_running();
-            };
-    
-    std::set<
-        Provider::Ptr, 
-        std::function<bool(const Provider::Ptr&, const Provider::Ptr&)>> matching_providers(less);
-
-    enumerator.for_each_provider(
-        [&](const Provider::Ptr& provider)
-        {
-            if (provider->matches_criteria(criteria))
-                matching_providers.insert(provider);
-        });
-
-    return matching_providers.empty() ? null_provider() : *matching_providers.begin();
-}
-
-location::Provider::Ptr location::DefaultProviderSelectionPolicy::determine_velocity_updates_provider(
-    const location::Criteria& criteria,
-    const location::ProviderEnumerator& enumerator)
-{
-    auto less = 
-            [](const Provider::Ptr& lhs, const Provider::Ptr& rhs)
-            {
-                return lhs->state_controller()->are_velocity_updates_running() && !rhs->state_controller()->are_velocity_updates_running();
-            };
-    
-    std::set<
-        Provider::Ptr, 
-        std::function<bool(const Provider::Ptr&, const Provider::Ptr&)>> matching_providers(less);
-
-    enumerator.for_each_provider(
-        [&](const Provider::Ptr& provider)
-        {
-            if (provider->matches_criteria(criteria))
-                matching_providers.insert(provider);
-        });
-
-    return matching_providers.empty() ? null_provider() : *matching_providers.begin();
-}

=== removed file 'src/location/default_provider_selection_policy.h'
--- src/location/default_provider_selection_policy.h	2016-06-28 11:53:34 +0000
+++ src/location/default_provider_selection_policy.h	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-/*
- * Copyright © 2012-2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-#ifndef DEFAULT_PROVIDER_SELECTION_POLICY_H_
-#define DEFAULT_PROVIDER_SELECTION_POLICY_H_
-
-#include <location/provider_selection_policy.h>
-
-namespace location
-{
-class DefaultProviderSelectionPolicy : public ProviderSelectionPolicy
-{
-public:
-    DefaultProviderSelectionPolicy();
-    ~DefaultProviderSelectionPolicy() noexcept;
-    
-    ProviderSelection determine_provider_selection_for_criteria(
-        const Criteria& criteria,
-        const ProviderEnumerator& enumerator);
-
-    Provider::Ptr determine_position_updates_provider(
-        const Criteria& criteria,
-        const ProviderEnumerator& enumerator);
-
-    Provider::Ptr determine_heading_updates_provider(
-        const Criteria& criteria,
-        const ProviderEnumerator& enumerator);
-
-    Provider::Ptr determine_velocity_updates_provider(
-        const Criteria& criteria,
-        const ProviderEnumerator& enumerator);
-};
-}
-
-#endif // DEFAULT_PROVIDER_SELECTION_POLICY_H_

=== removed file 'src/location/dummy_service.cpp'
--- src/location/dummy_service.cpp	2016-06-30 09:13:21 +0000
+++ src/location/dummy_service.cpp	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program 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; version 3.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *
- */
-
-#include <location/dummy_service.h>
-
-location::Service::Session::Updates& location::DummyService::Session::updates()
-{
-    return updates_;
-}
-
-const core::Property<location::Service::State>& location::DummyService::state() const
-{
-    return state_;
-}
-
-core::Property<bool>& location::DummyService::does_satellite_based_positioning()
-{
-    return does_satellite_based_positioning_;
-}
-
-core::Property<bool>& location::DummyService::is_online()
-{
-    return is_online_;
-}
-
-core::Property<bool>& location::DummyService::does_report_cell_and_wifi_ids()
-{
-    return does_report_cell_and_wifi_ids_;
-}
-
-core::Property<std::map<location::SpaceVehicle::Key, location::SpaceVehicle>>& location::DummyService::visible_space_vehicles()
-{
-    return visible_space_vehicles_;
-}
-
-location::Service::Session::Ptr location::DummyService::create_session_for_criteria(const Criteria&)
-{
-    return std::make_shared<DummyService::Session>();
-}

=== removed file 'src/location/dummy_service.h'
--- src/location/dummy_service.h	2016-06-30 09:13:21 +0000
+++ src/location/dummy_service.h	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program 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; version 3.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *
- */
-
-#ifndef LOCATION_DUMMY_SERVICE_H_
-#define LOCATION_DUMMY_SERVICE_H_
-
-#include <location/service.h>
-
-namespace location
-{
-class DummyService : public Service
-{
-public:
-    class Session : public Service::Session
-    {
-    public:
-        Updates& updates() override;
-
-    private:
-        Updates updates_;
-    };
-
-    const core::Property<State>& state() const override;
-    core::Property<bool>& does_satellite_based_positioning() override;
-    core::Property<bool>& is_online() override;
-    core::Property<bool>& does_report_cell_and_wifi_ids() override;
-    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() override;
-    Session::Ptr create_session_for_criteria(const Criteria& criteria) override;
-
-private:
-    core::Property<State> state_;
-    core::Property<bool> does_satellite_based_positioning_;
-    core::Property<bool> is_online_;
-    core::Property<bool> does_report_cell_and_wifi_ids_;
-    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>> visible_space_vehicles_;
-};
-}
-
-#endif // LOCATION_DUMMY_SERVICE_H_

=== modified file 'src/location/engine.cpp'
--- src/location/engine.cpp	2016-06-26 21:17:03 +0000
+++ src/location/engine.cpp	2016-08-12 12:03:50 +0000
@@ -19,7 +19,12 @@
 
 #include <location/logging.h>
 #include <location/provider_selection_policy.h>
-#include <location/state_tracking_provider.h>
+
+#include <location/events/reference_position_updated.h>
+#include <location/events/wifi_and_cell_id_reporting_state_changed.h>
+#include <location/providers/state_tracking_provider.h>
+
+#include <location/util/flags.h>
 
 #include <iostream>
 #include <stdexcept>
@@ -32,8 +37,10 @@
 const location::Engine::Status location::Engine::Configuration::Defaults::engine_state;
 
 location::Engine::Engine(const location::ProviderSelectionPolicy::Ptr& provider_selection_policy,
-                    const location::Settings::Ptr& settings)
+                         const location::Bus::Ptr& bus,
+                         const location::Settings::Ptr& settings)
           : provider_selection_policy(provider_selection_policy),
+            bus(bus),
             settings(settings),
             update_policy(std::make_shared<location::TimeBasedUpdatePolicy>())
 {
@@ -52,17 +59,17 @@
     {
         for_each_provider([this, state](const Provider::Ptr& provider)
         {
-            if (provider->requires(location::Provider::Requirements::satellites))
+            if (util::flags::has(provider->requirements(), Provider::Requirements::satellites))
             {
                 switch (state)
                 {
                 case SatelliteBasedPositioningState::on:
                     // We only enable a provider if the overall engine is enabled.
                     if (configuration.engine_state == Engine::Status::on)
-                        provider->state_controller()->enable();
+                        provider->enable();
                     break;
                 case SatelliteBasedPositioningState::off:
-                    provider->state_controller()->disable();
+                    provider->disable();
                     break;
                 }
             }
@@ -77,13 +84,14 @@
             {
             case Engine::Status::on:
                 // We only enable providers that require satellites if the respective engine option is set to on.
-                if (provider->requires(location::Provider::Requirements::satellites) && configuration.satellite_based_positioning_state == SatelliteBasedPositioningState::off)
+                if (util::flags::has(provider->requirements(), Provider::Requirements::satellites) &&
+                    configuration.satellite_based_positioning_state == SatelliteBasedPositioningState::off)
                     return;
 
-                provider->state_controller()->enable();
+                provider->enable();
                 break;
             case Engine::Status::off:
-                provider->state_controller()->disable();
+                provider->disable();
                 break;
             default:
                 break;
@@ -111,6 +119,12 @@
     configuration.wifi_and_cell_id_reporting_state.changed().connect([this](WifiAndCellIdReportingState state)
     {
         Engine::settings->set_enum_for_key<WifiAndCellIdReportingState>(Configuration::Keys::wifi_and_cell_id_reporting_state, state);
+        Engine::bus->dispatch(std::make_shared<events::WifiAndCellIdReportingStateChanged>(state));
+    });
+
+    updates.last_known_location.changed().connect([this](const Optional<Update<Position>>& update)
+    {
+        Engine::bus->dispatch(std::make_shared<events::ReferencePositionUpdated>(*update));
     });
 }
 
@@ -126,9 +140,7 @@
 
     for_each_provider([](const Provider::Ptr& provider)
     {
-        provider->state_controller()->stop_position_updates();
-        provider->state_controller()->stop_heading_updates();
-        provider->state_controller()->stop_velocity_updates();
+        provider->disable();
     });
 }
 
@@ -142,80 +154,36 @@
     if (!impl)
         throw std::runtime_error("Cannot add null provider");
 
-    auto provider = std::make_shared<StateTrackingProvider>(impl);
+    auto provider = std::make_shared<providers::StateTrackingProvider>(impl);
 
     // We synchronize to the engine state.
-    if (provider->requires(Provider::Requirements::satellites) && configuration.satellite_based_positioning_state == SatelliteBasedPositioningState::off)
-        provider->state_controller()->disable();
+    if (util::flags::has(provider->requirements(), Provider::Requirements::satellites) && configuration.satellite_based_positioning_state == SatelliteBasedPositioningState::off)
+        provider->disable();
 
     if (configuration.engine_state == Engine::Status::off)
-        provider->state_controller()->disable();
-
-    // We wire up changes in the engine's configuration to the respective slots
-    // of the provider.
-    auto cp = updates.last_known_location.changed().connect([provider](const location::Optional<location::Update<location::Position>>& pos)
-    {
-        if (pos)
-        {
-            provider->on_reference_location_updated(pos.get());
-        }
-    });
-
-    auto cv = updates.last_known_velocity.changed().connect([provider](const location::Optional<location::Update<location::Velocity>>& velocity)
-    {
-        if (velocity)
-        {
-            provider->on_reference_velocity_updated(velocity.get());
-        }
-    });
-
-    auto ch = updates.last_known_heading.changed().connect([provider](const location::Optional<location::Update<location::Heading>>& heading)
-    {
-        if (heading)
-        {
-            provider->on_reference_heading_updated(heading.get());
-        }
-    });
-
-    auto cr = configuration.wifi_and_cell_id_reporting_state.changed().connect([provider](location::WifiAndCellIdReportingState state)
-    {
-        provider->on_wifi_and_cell_reporting_state_changed(state);
-    });
-
-    // And do the reverse: Satellite visibility updates are funneled via the engine's configuration.
-    auto cs = provider->updates().svs.connect([this](const location::Update<std::set<location::SpaceVehicle>>& src)
-    {
-        updates.visible_space_vehicles.update([src](std::map<location::SpaceVehicle::Key, location::SpaceVehicle>& dest)
-        {
-            for(auto& sv : src.value)
-            {
-                dest[sv.key] = sv;
-            }
-
-            return true;
-        });
-    });
+        provider->disable();
 
     // We are a bit dumb and just take any position update as new reference.
     // We should come up with a better heuristic here.
-    auto cpr = provider->updates().position.connect([this](const location::Update<location::Position>& src)
+    auto cpr = provider->position_updates().connect([this](const location::Update<location::Position>& src)
     {
         updates.last_known_location = update_policy->verify_update(src);
     });
 
-    auto cps = provider->state().changed().connect([this](const StateTrackingProvider::State&)
+    auto cps = provider->state().changed().connect([this](const providers::StateTrackingProvider::State&)
     {
         bool is_any_active = false;
 
         std::lock_guard<std::recursive_mutex> lg(guard);
         for (const auto& pair : providers)
-            is_any_active = pair.first->state() == StateTrackingProvider::State::active;
+            is_any_active = pair.first->state() == providers::StateTrackingProvider::State::active;
 
         configuration.engine_state = is_any_active ? Engine::Status::active : Engine::Status::on;
     });
 
     std::lock_guard<std::recursive_mutex> lg(guard);
-    providers.emplace(provider, std::move(ProviderConnections{cp, ch, cv, cr, cs, cpr, cps}));
+    bus->subscribe(provider);
+    providers.emplace(provider, std::move(ProviderConnections{cpr, cps}));
 }
 
 void location::Engine::for_each_provider(const std::function<void(const Provider::Ptr&)>& enumerator) const noexcept

=== modified file 'src/location/engine.h'
--- src/location/engine.h	2016-06-27 06:44:50 +0000
+++ src/location/engine.h	2016-08-12 12:03:50 +0000
@@ -18,15 +18,17 @@
 #ifndef LOCATION_ENGINE_H_
 #define LOCATION_ENGINE_H_
 
+#include <location/bus.h>
 #include <location/provider.h>
 #include <location/provider_enumerator.h>
 #include <location/provider_selection.h>
 #include <location/provider_selection_policy.h>
 #include <location/satellite_based_positioning_state.h>
 #include <location/space_vehicle.h>
-#include <location/state_tracking_provider.h>
 #include <location/wifi_and_cell_reporting_state.h>
 
+#include <location/providers/state_tracking_provider.h>
+
 #include <location/settings.h>
 
 #include <core/property.h>
@@ -134,6 +136,7 @@
     };
 
     Engine(const ProviderSelectionPolicy::Ptr& provider_selection_policy,
+           const Bus::Ptr& bus,
            const Settings::Ptr& settings);
 
     Engine(const Engine&) = delete;
@@ -168,18 +171,14 @@
 private:
     struct ProviderConnections
     {
-        core::ScopedConnection reference_location_updates;
-        core::ScopedConnection reference_velocity_updates;
-        core::ScopedConnection reference_heading_updates;
-        core::ScopedConnection wifi_and_cell_id_reporting_state_updates;
-        core::ScopedConnection space_vehicle_visibility_updates;
         core::ScopedConnection provider_position_updates;
         core::ScopedConnection provider_state_updates;
     };
 
     mutable std::recursive_mutex guard;
-    std::map<StateTrackingProvider::Ptr, ProviderConnections> providers;
+    std::map<providers::StateTrackingProvider::Ptr, ProviderConnections> providers;
     ProviderSelectionPolicy::Ptr provider_selection_policy;
+    Bus::Ptr bus;
     Settings::Ptr settings;
     UpdatePolicy::Ptr update_policy;
 };

=== added file 'src/location/event.cpp'
--- src/location/event.cpp	1970-01-01 00:00:00 +0000
+++ src/location/event.cpp	2016-08-12 12:03:50 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <location/event.h>
+
+#include <location/events/registry.h>
+
+location::Event::Type location::Event::next_user_defined_type(const std::string& name)
+{
+    return events::Registry::instance().insert(name);
+}

=== added directory 'src/location/events'
=== added file 'src/location/events/all.h'
--- src/location/events/all.h	1970-01-01 00:00:00 +0000
+++ src/location/events/all.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_EVENTS_ALL_H_
+#define LOCATION_EVENTS_ALL_H_
+
+#include <location/events/reference_position_updated.h>
+#include <location/events/wifi_and_cell_id_reporting_state_changed.h>
+
+#include <boost/variant.hpp>
+
+namespace location
+{
+namespace events
+{
+/// @brief Undefined tags the unknown event and allows us to
+/// escape the "no default ctor" issue.
+struct Undefined{};
+
+/// @brief All captures all known events and allows us to serialize/transport
+/// them easily without the need to extend location::Event with specific serialization
+/// functionality.
+typedef boost::variant
+<
+    Undefined,
+    ReferencePositionUpdated,
+    WifiAndCellIdReportingStateChanged
+> All;
+}
+}
+
+#endif // LOCATION_EVENTS_ALL_H_

=== added file 'src/location/events/reference_position_updated.cpp'
--- src/location/events/reference_position_updated.cpp	1970-01-01 00:00:00 +0000
+++ src/location/events/reference_position_updated.cpp	2016-08-12 12:03:50 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <location/events/reference_position_updated.h>
+
+namespace
+{
+const location::Event::Type id = location::Event::register_type<location::events::ReferencePositionUpdated>("location::events::ReferencePositionUpdated");
+}
+
+location::events::ReferencePositionUpdated::ReferencePositionUpdated(const Update<Position>& update)
+    : update_{update}
+{
+}
+
+location::events::ReferencePositionUpdated::ReferencePositionUpdated(const ReferencePositionUpdated& rhs)
+    : Event{}, update_{rhs.update_}
+{
+}
+
+location::events::ReferencePositionUpdated& location::events::ReferencePositionUpdated::operator=(const ReferencePositionUpdated& rhs)
+{
+    update_ = rhs.update_;
+    return *this;
+}
+
+const location::Update<location::Position>& location::events::ReferencePositionUpdated::update() const
+{
+    return update_;
+}
+
+location::Event::Type location::events::ReferencePositionUpdated::type() const
+{
+    return id;
+}
+
+location::Event::Type location::TypeOf<location::events::ReferencePositionUpdated>::query()
+{
+    return id;
+}

=== added file 'src/location/events/registry.cpp'
--- src/location/events/registry.cpp	1970-01-01 00:00:00 +0000
+++ src/location/events/registry.cpp	2016-08-12 12:03:50 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <location/events/registry.h>
+
+namespace
+{
+location::Event::Type increment(location::Event::Type type, std::size_t value)
+{
+    return static_cast<location::Event::Type>(static_cast<std::size_t>(type) + value);
+}
+}
+
+location::events::Registry& location::events::Registry::instance()
+{
+    static Registry registry;
+    return registry;
+}
+
+std::string location::events::Registry::find(location::Event::Type type) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    return type_name_lut.at(type);
+}
+
+location::Event::Type location::events::Registry::find(const std::string& name) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    return name_type_lut.at(name);
+}
+
+location::Event::Type location::events::Registry::insert(const std::string& name)
+{
+    std::lock_guard<std::mutex> lg{guard};
+
+    auto it = name_type_lut.find(name);
+    if (it == name_type_lut.end())
+    {
+        std::tie(it, std::ignore) = name_type_lut.insert(
+                    std::make_pair(
+                        name,
+                        increment(location::Event::Type::first_user_defined_type, counter++)));
+
+        type_name_lut[it->second] = name;
+
+        return it->second;
+    }
+
+    throw std::runtime_error{"Event " + name + " is already known to the registry."};
+}

=== added file 'src/location/events/registry.h'
--- src/location/events/registry.h	1970-01-01 00:00:00 +0000
+++ src/location/events/registry.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_EVENTS_REGISTRY_H_
+#define LOCATION_EVENTS_REGISTRY_H_
+
+#include <location/event.h>
+
+#include <map>
+#include <mutex>
+#include <string>
+
+namespace location
+{
+namespace events
+{
+class Registry
+{
+public:
+    // instance returns the singleton instance of Registry.
+    static Registry& instance();
+
+    // find returns the name assigned to type or throws std::out_of_range.
+    std::string find(location::Event::Type type) const;
+
+    // find returns the type assigned to name or throws std::out_of_range.
+    location::Event::Type find(const std::string& name) const;
+
+    // insert makes name known and assigns it a unique type in the scope of
+    // the process.
+    location::Event::Type insert(const std::string& name);
+
+private:
+    // Boilerplate to prevent the outside from creating/deleting/copying/moving
+    // Registry instances.
+    Registry() = default;
+    Registry(const Registry&) = delete;
+    Registry(Registry&&) = delete;
+    ~Registry() = default;
+    Registry& operator=(const Registry&) = delete;
+    Registry& operator=(Registry&&) = delete;
+
+    mutable std::mutex guard;
+    std::size_t counter{0};
+    std::map<location::Event::Type, std::string> type_name_lut;
+    std::map<std::string, location::Event::Type> name_type_lut;
+};
+}
+}
+
+#endif // LOCATION_EVENTS_REGISTRY_H_

=== added file 'src/location/events/wifi_and_cell_id_reporting_state_changed.cpp'
--- src/location/events/wifi_and_cell_id_reporting_state_changed.cpp	1970-01-01 00:00:00 +0000
+++ src/location/events/wifi_and_cell_id_reporting_state_changed.cpp	2016-08-12 12:03:50 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <location/events/wifi_and_cell_id_reporting_state_changed.h>
+
+namespace
+{
+const location::Event::Type id = location::Event::register_type<location::events::WifiAndCellIdReportingStateChanged>("location::events::WifiAndCellIdReportingStateChanged");
+}
+
+location::events::WifiAndCellIdReportingStateChanged::WifiAndCellIdReportingStateChanged(WifiAndCellIdReportingState new_state)
+    : new_state_{new_state}
+{
+}
+
+location::events::WifiAndCellIdReportingStateChanged::WifiAndCellIdReportingStateChanged(const WifiAndCellIdReportingStateChanged& rhs)
+    : Event{}, new_state_{rhs.new_state_}
+{
+}
+
+location::events::WifiAndCellIdReportingStateChanged& location::events::WifiAndCellIdReportingStateChanged::operator=(const WifiAndCellIdReportingStateChanged& rhs)
+{
+    new_state_ = rhs.new_state_;
+    return *this;
+}
+
+location::WifiAndCellIdReportingState location::events::WifiAndCellIdReportingStateChanged::new_state() const
+{
+    return new_state_;
+}
+
+location::Event::Type location::events::WifiAndCellIdReportingStateChanged::type() const
+{
+    return id;
+}
+
+location::Event::Type location::TypeOf<location::events::WifiAndCellIdReportingStateChanged>::query()
+{
+    return id;
+}

=== modified file 'src/location/fusion_provider_selection_policy.cpp'
--- src/location/fusion_provider_selection_policy.cpp	2016-06-26 21:17:03 +0000
+++ src/location/fusion_provider_selection_policy.cpp	2016-08-12 12:03:50 +0000
@@ -1,6 +1,9 @@
-#include <location/fusion_provider.h>
+#include <location/providers/fusion/provider.h>
+#include <location/providers/fusion/newer_or_more_accurate_update_selector.h>
+
 #include <location/fusion_provider_selection_policy.h>
-#include <location/newer_or_more_accurate_update_selector.h>
+
+namespace fusion = location::providers::fusion;
 
 location::ProviderSelection location::FusionProviderSelectionPolicy::determine_provider_selection_for_criteria(
         const location::Criteria&,
@@ -13,7 +16,7 @@
         bag.insert(provider);
     });
 
-    auto fusion_providers = std::make_shared<location::FusionProvider>(bag, std::make_shared<location::NewerOrMoreAccurateUpdateSelector>());
+    auto fusion_providers = fusion::Provider::create(bag, std::make_shared<fusion::NewerOrMoreAccurateUpdateSelector>());
 
     return location::ProviderSelection
     {

=== modified file 'src/location/non_selecting_provider_selection_policy.cpp'
--- src/location/non_selecting_provider_selection_policy.cpp	2016-06-26 21:17:03 +0000
+++ src/location/non_selecting_provider_selection_policy.cpp	2016-08-12 12:03:50 +0000
@@ -17,8 +17,7 @@
  */
 
 #include <location/non_selecting_provider_selection_policy.h>
-#include <location/fusion_provider.h>
-#include <location/newer_update_selector.h>
+#include <location/providers/proxy.h>
 
 #include <set>
 
@@ -33,13 +32,13 @@
         bag.insert(provider);
     });
 
-    auto bag_of_providers = std::make_shared<FusionProvider>(bag, std::make_shared<NewerUpdateSelector>());
+    auto proxy = std::make_shared<providers::Proxy>(bag);
 
     // Our bag of providers is responsible for delivering position/heading/velocity updates.
     return location::ProviderSelection
     {
-        bag_of_providers, // position
-        bag_of_providers, // heading
-        bag_of_providers  // velocity
+        proxy, // position
+        proxy, // heading
+        proxy  // velocity
     };
 }

=== modified file 'src/location/provider.cpp'
--- src/location/provider.cpp	2016-06-26 21:17:03 +0000
+++ src/location/provider.cpp	2016-08-12 12:03:50 +0000
@@ -17,197 +17,6 @@
  */
 #include <location/provider.h>
 
-#include <atomic>
-#include <bitset>
-#include <memory>
-
-namespace
-{
-static const int our_magic_disabling_value = -1;
-}
-
-void location::Provider::Controller::enable()
-{
-    position_updates_counter = 0;
-    heading_updates_counter = 0;
-    velocity_updates_counter = 0;
-}
-
-void location::Provider::Controller::disable()
-{    
-    if (position_updates_counter > 0)
-        instance.stop_position_updates();
-    if (heading_updates_counter > 0)
-        instance.stop_heading_updates();
-    if (velocity_updates_counter > 0)
-        instance.stop_velocity_updates();
-
-    position_updates_counter = our_magic_disabling_value;
-    heading_updates_counter = our_magic_disabling_value;
-    velocity_updates_counter = our_magic_disabling_value;
-}
-
-void location::Provider::Controller::start_position_updates()
-{
-    if (position_updates_counter < 0)
-        return;
-
-    if (++position_updates_counter == 1)
-    {
-        instance.start_position_updates();
-    }
-}
-
-void location::Provider::Controller::stop_position_updates()
-{
-    if (position_updates_counter < 0)
-        return;
-
-    if (--position_updates_counter == 0)
-    {
-        instance.stop_position_updates();
-    }
-}
-
-bool location::Provider::Controller::are_position_updates_running() const
-{
-    return position_updates_counter > 0;
-}
-
-void location::Provider::Controller::start_heading_updates()
-{
-    if (heading_updates_counter < 0)
-        return;
-
-    if (++heading_updates_counter == 1)
-    {
-        instance.start_heading_updates();
-    }
-}
-
-void location::Provider::Controller::stop_heading_updates()
-{
-    if (heading_updates_counter < 0)
-        return;
-
-    if (--heading_updates_counter == 0)
-    {
-        instance.stop_heading_updates();
-    }
-}
-
-bool location::Provider::Controller::are_heading_updates_running() const
-{
-    return heading_updates_counter > 0;
-}
-
-void location::Provider::Controller::start_velocity_updates()
-{
-    if (velocity_updates_counter < 0)
-        return;
-
-    if (++velocity_updates_counter == 1)
-    {
-        instance.start_velocity_updates();
-    }
-}
-
-void location::Provider::Controller::stop_velocity_updates()
-{
-    if (velocity_updates_counter < 0)
-        return;
-
-    if (--velocity_updates_counter == 0)
-    {
-        instance.stop_velocity_updates();
-    }
-}
-
-bool location::Provider::Controller::are_velocity_updates_running() const
-{
-    return velocity_updates_counter > 0;
-}
-
-location::Provider::Controller::Controller(location::Provider& instance)
-    : instance(instance),
-      position_updates_counter(0),
-      heading_updates_counter(0),
-      velocity_updates_counter(0)
-{  
-}
-
-const location::Provider::Controller::Ptr& location::Provider::state_controller() const
-{
-    return d.controller;
-}
-
-bool location::Provider::supports(const location::Provider::Features& f) const
-{
-    return (d.features & f) != Features::none;
-}
-
-bool location::Provider::requires(const location::Provider::Requirements& r) const
-{
-    return (d.requirements & r) != Requirements::none;
-}
-
-bool location::Provider::matches_criteria(const location::Criteria&)
-{
-    return false;
-}
-
-const location::Provider::Updates& location::Provider::updates() const
-{
-    return d.updates;
-}
-
-location::Provider::Provider(
-    const location::Provider::Features& features,
-    const location::Provider::Requirements& requirements)
-{
-    d.features = features;
-    d.requirements = requirements;
-    d.controller = std::shared_ptr<Provider::Controller>(new Provider::Controller(*this));
-}
-
-location::Provider::Updates& location::Provider::mutable_updates()
-{
-    return d.updates;
-}
-
-void location::Provider::on_wifi_and_cell_reporting_state_changed(location::WifiAndCellIdReportingState)
-{
-}
-
-void location::Provider::on_reference_location_updated(const location::Update<location::Position>&)
-{
-}
-
-void location::Provider::on_reference_velocity_updated(const location::Update<location::Velocity>&)
-{
-}
-
-void location::Provider::on_reference_heading_updated(const location::Update<location::Heading>&)
-{
-}
-
-void location::Provider::start_position_updates() {}
-void location::Provider::stop_position_updates() {}
-void location::Provider::start_heading_updates() {}
-void location::Provider::stop_heading_updates() {}
-void location::Provider::start_velocity_updates() {}
-void location::Provider::stop_velocity_updates() {}
-
-location::Provider::Features location::operator|(location::Provider::Features lhs, location::Provider::Features rhs)
-{
-    return static_cast<location::Provider::Features>(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
-}
-
-location::Provider::Features location::operator&(location::Provider::Features lhs, location::Provider::Features rhs)
-{
-    return static_cast<location::Provider::Features>(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
-}
-
 location::Provider::Requirements location::operator|(location::Provider::Requirements lhs, location::Provider::Requirements rhs)
 {
     return static_cast<location::Provider::Requirements>(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));

=== modified file 'src/location/provider_selection.h'
--- src/location/provider_selection.h	2016-06-28 11:53:34 +0000
+++ src/location/provider_selection.h	2016-08-12 12:03:50 +0000
@@ -26,20 +26,6 @@
 {
 struct ProviderSelection
 {
-    inline Provider::Features to_feature_flags() const
-    {
-        Provider::Features flags = Provider::Features::none;
-
-        if (position_updates_provider)
-            flags = flags | Provider::Features::position;
-        if (heading_updates_provider)
-            flags = flags | Provider::Features::heading;
-        if(velocity_updates_provider)
-            flags = flags | Provider::Features::velocity;
-
-        return flags;
-    }
-
     std::shared_ptr<Provider> position_updates_provider;
     std::shared_ptr<Provider> heading_updates_provider;
     std::shared_ptr<Provider> velocity_updates_provider;

=== modified file 'src/location/providers/CMakeLists.txt'
--- src/location/providers/CMakeLists.txt	2014-08-22 11:16:27 +0000
+++ src/location/providers/CMakeLists.txt	2016-08-12 12:03:50 +0000
@@ -1,8 +1,7 @@
 add_subdirectory(dummy)
+add_subdirectory(fusion)
 add_subdirectory(remote)
-add_subdirectory(geoclue)
 add_subdirectory(gps)
-add_subdirectory(skyhook)
 
 set(
   ENABLED_PROVIDER_TARGETS

=== modified file 'src/location/providers/config.cpp'
--- src/location/providers/config.cpp	2016-08-12 12:03:49 +0000
+++ src/location/providers/config.cpp	2016-08-12 12:03:50 +0000
@@ -39,22 +39,6 @@
     location::providers::dummy::Provider::create_instance
 };
 
-#include <location/providers/remote/provider.h>
-static FactoryInjector remote_injector
-{
-    "remote::Provider",
-    location::providers::remote::Provider::Stub::create_instance
-};
-
-#if defined(LOCATION_PROVIDERS_GEOCLUE)
-#include <location/providers/geoclue/provider.h>
-static FactoryInjector geoclue_injector
-{
-    "geoclue::Provider", 
-    location::providers::geoclue::Provider::create_instance
-};
-#endif // LOCATION_PROVIDERS_GEOCLUE
-
 #if defined(LOCATION_PROVIDERS_GPS)
 #include <location/providers/gps/provider.h>
 static FactoryInjector gps_injector
@@ -63,12 +47,3 @@
     location::providers::gps::Provider::create_instance
 };
 #endif // LOCATION_PROVIDERS_GPS
-
-#if defined(LOCATION_PROVIDERS_SKYHOOK)
-#include <location/providers/skyhook/provider.h>
-static FactoryInjector skyhook_injector
-{
-    "skyhook::Provider", 
-    location::providers::skyhook::Provider::create_instance
-};
-#endif // LOCATION_PROVIDERS_SKYHOOK

=== modified file 'src/location/providers/dummy/provider.cpp'
--- src/location/providers/dummy/provider.cpp	2016-08-12 12:03:49 +0000
+++ src/location/providers/dummy/provider.cpp	2016-08-12 12:03:50 +0000
@@ -24,27 +24,6 @@
 
 namespace dummy = location::providers::dummy;
 
-struct dummy::Provider::Private
-{
-    enum class State
-    {
-        started,
-        stopping,
-        stopped
-    };
-
-    Private(const dummy::Configuration& configuration)
-        : configuration(configuration),
-          state(State::stopped)
-    {
-    }
-
-    dummy::Configuration configuration;
-    std::atomic<State> state;
-    bool stop_requested;
-    std::thread worker{};
-};
-
 std::string dummy::Provider::class_name()
 {
     return "dummy::Provider";
@@ -93,87 +72,104 @@
     return location::Provider::Ptr{new dummy::Provider{provider_config}};
 }
 
-dummy::Provider::Provider(const dummy::Configuration& config)
-    : location::Provider(
-          location::Provider::Features::position | location::Provider::Features::velocity | location::Provider::Features::heading,
-          location::Provider::Requirements::none),
-      d(new Private{config})
+dummy::Provider::Provider(const dummy::Configuration&)
 {
 }
 
 dummy::Provider::~Provider() noexcept
 {
-    stop_position_updates();
-
-    if (d->worker.joinable())
-        d->worker.join();
-}
-
-bool dummy::Provider::matches_criteria(const location::Criteria&)
+    deactivate();
+
+    if (worker.joinable())
+        worker.join();
+}
+
+void dummy::Provider::on_new_event(const Event&)
+{
+}
+
+location::Provider::Requirements dummy::Provider::requirements() const
+{
+    return Requirements::none;
+}
+
+bool dummy::Provider::satisfies(const location::Criteria&)
 {
     return true;
 }
 
-void dummy::Provider::start_position_updates()
-{
-    if (d->state.load() != Private::State::stopped)
-        return;
-
-    d->stop_requested = false;
-
-    d->worker = std::move(std::thread([this]()
+void dummy::Provider::enable()
+{
+}
+
+void dummy::Provider::disable()
+{
+}
+
+void dummy::Provider::activate()
+{
+    stop_requested = false;
+
+    worker = std::move(std::thread([this]()
     {
-        d->state.store(Private::State::started);
         VLOG(1) << __PRETTY_FUNCTION__ << ": started";
 
         location::Update<location::Position> position_update
         {
-            d->configuration.reference_position,
+            configuration.reference_position,
             location::Clock::now()
         };
 
         location::Update<location::Heading> heading_update
         {
-            d->configuration.reference_heading,
+            configuration.reference_heading,
             location::Clock::now()
         };
 
         location::Update<location::Velocity> velocity_update
         {
-            d->configuration.reference_velocity,
+            configuration.reference_velocity,
             location::Clock::now()
         };
 
-        while (!d->stop_requested)
+        while (!stop_requested)
         {
-            VLOG(10) << position_update;
-
             position_update.when = location::Clock::now();
             heading_update.when = location::Clock::now();
             velocity_update.when = location::Clock::now();
 
-            mutable_updates().position(position_update);
-            mutable_updates().heading(heading_update);
-            mutable_updates().velocity(velocity_update);           
+            updates.position(position_update);
+            updates.heading(heading_update);
+            updates.velocity(velocity_update);
 
-            std::this_thread::sleep_for(d->configuration.update_period);
+            std::this_thread::sleep_for(configuration.update_period);
         }
-
-        d->state.store(Private::State::stopped);
     }));
 }
 
-void dummy::Provider::stop_position_updates()
-{
-    if (d->state.load() != Private::State::started)
-        return;
-
-    d->state.store(Private::State::stopping);
-    VLOG(1) << __PRETTY_FUNCTION__ << ": stopping";
-
-    d->stop_requested = true;
-
-    if (d->worker.joinable())
-        d->worker.join();
-}
-
+void dummy::Provider::deactivate()
+{
+    VLOG(1) << __PRETTY_FUNCTION__ << ": stopping";
+
+    stop_requested = true;
+
+    if (worker.joinable())
+        worker.join();
+
+    VLOG(1) << __PRETTY_FUNCTION__ << ": stopping";
+}
+
+const core::Signal<location::Update<location::Position>>& dummy::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::Heading>>& dummy::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::Velocity>>& dummy::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}

=== modified file 'src/location/providers/dummy/provider.h'
--- src/location/providers/dummy/provider.h	2016-06-27 06:44:50 +0000
+++ src/location/providers/dummy/provider.h	2016-08-12 12:03:50 +0000
@@ -21,6 +21,8 @@
 #include <location/provider.h>
 #include <location/provider_factory.h>
 
+#include <thread>
+
 namespace location
 {
 namespace providers
@@ -68,7 +70,7 @@
     };
 
     // Updates are delivered every update_period milliseconds.
-    std::chrono::milliseconds update_period{500};
+    std::chrono::milliseconds update_period{10};
 
     // The reference position that is delivered in every upate cycle.
     Position reference_position
@@ -115,17 +117,34 @@
     // Cleans up all resources and stops the updates.
     ~Provider() noexcept;
 
-    // Always returns true.
-    bool matches_criteria(const Criteria&);
-
-    // Starts up the updater thread and delivers position updates
-    void start_position_updates();
-    // Stops the updater thread.
-    void stop_position_updates();
+    void on_new_event(const Event& event) override;
+
+    void enable() override;
+    void disable() override;
+    void activate() override;
+    void deactivate() override;
+
+    Requirements requirements() const override;
+    bool satisfies(const Criteria& criteria) override;
+    const core::Signal<Update<Position>>& position_updates() const override;
+    const core::Signal<Update<Heading>>& heading_updates() const override;
+    const core::Signal<Update<Velocity>>& velocity_updates() const override;
+    void on_wifi_and_cell_reporting_state_changed(WifiAndCellIdReportingState state);
+    void on_reference_location_updated(const Update<Position>& position);
+    void on_reference_velocity_updated(const Update<Velocity>& velocity);
+    void on_reference_heading_updated(const Update<Heading>& heading);
 
   private:
-    struct Private;
-    std::unique_ptr<Private> d;
+    dummy::Configuration configuration;
+    std::atomic<bool> stop_requested{false};
+    std::thread worker{};
+
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<Heading>> heading;
+        core::Signal<Update<Velocity>> velocity;
+    } updates;
 };
 }
 }

=== added directory 'src/location/providers/fusion'
=== added file 'src/location/providers/fusion/CMakeLists.txt'
--- src/location/providers/fusion/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/location/providers/fusion/CMakeLists.txt	2016-08-12 12:03:50 +0000
@@ -0,0 +1,4 @@
+add_library(
+    fusion
+    provider.h provider.cpp
+)

=== renamed file 'src/location/newer_or_more_accurate_update_selector.h' => 'src/location/providers/fusion/newer_or_more_accurate_update_selector.h'
--- src/location/newer_or_more_accurate_update_selector.h	2016-06-28 11:53:34 +0000
+++ src/location/providers/fusion/newer_or_more_accurate_update_selector.h	2016-08-12 12:03:50 +0000
@@ -15,13 +15,17 @@
  *
  * Authored by: Scott Sweeny <[e-mail]
  */
-#ifndef LOCATION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
-#define LOCATION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
+#ifndef LOCATION_PROVIDERS_FUSION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
+#define LOCATION_PROVIDERS_FUSION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
 
-#include <location/update_selector.h>
+#include <location/providers/fusion/update_selector.h>
 
 namespace location
 {
+namespace providers
+{
+namespace fusion
+{
 class NewerOrMoreAccurateUpdateSelector : public UpdateSelector
 {
 public:
@@ -34,7 +38,7 @@
         static const std::chrono::seconds cutoff(11);
 
         // If the new position is from the same source as the old one then just use it
-        if (newer.source == older.source) {
+        if (newer.source.lock() == older.source.lock()) {
             return newer;
         }
 
@@ -55,6 +59,8 @@
     }
 };
 }
+}
+}
 
-#endif // LOCATION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
+#endif // LOCATION_PROVIDERS_FUSION_NEWER_OR_MORE_ACCURATE_UPDATE_SELECTOR_H
 

=== renamed file 'src/location/newer_update_selector.h' => 'src/location/providers/fusion/newer_update_selector.h'
--- src/location/newer_update_selector.h	2016-06-28 11:53:34 +0000
+++ src/location/providers/fusion/newer_update_selector.h	2016-08-12 12:03:50 +0000
@@ -27,7 +27,7 @@
 public:
     typedef std::shared_ptr<NewerUpdateSelector> Ptr;
 
-    virtual WithSource<Update<Position>> select(const WithSource<Update<Position>>& older,
+    virtual WithSource<Update<Position>> select(const WithSource<Update<Position>>&,
                                                 const WithSource<Update<Position>>& newer) override
     {
         return newer;

=== renamed file 'src/location/fusion_provider.cpp' => 'src/location/providers/fusion/provider.cpp'
--- src/location/fusion_provider.cpp	2016-06-26 21:17:03 +0000
+++ src/location/providers/fusion/provider.cpp	2016-08-12 12:03:50 +0000
@@ -15,125 +15,117 @@
  *
  * Authored by: Scott Sweeny <[e-mail]
  */
- #include <location/fusion_provider.h>
- #include <location/logging.h>
- #include <location/update.h>
-
-location::Provider::Features all_features()
-{
-    return location::Provider::Features::position |
-           location::Provider::Features::heading |
-           location::Provider::Features::velocity;
-}
-
-location::Provider::Requirements all_requirements()
-{
-    return location::Provider::Requirements::cell_network |
-           location::Provider::Requirements::data_network |
-           location::Provider::Requirements::monetary_spending |
-           location::Provider::Requirements::satellites;
-}
-
-location::FusionProvider::FusionProvider(const std::set<location::Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector)
-    : Provider{all_features(), all_requirements()},
-      providers{providers}
-{
+
+#include <location/providers/fusion/provider.h>
+
+#include <location/logging.h>
+#include <location/update.h>
+
+namespace fusion = location::providers::fusion;
+
+fusion::Provider::Provider(const std::set<location::Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector)
+      : providers{providers}
+{
+}
+
+void fusion::Provider::on_new_event(const Event& event)
+{
+    for (auto provider : providers) provider->on_new_event(event);
+}
+
+void fusion::Provider::enable()
+{
+    for (auto provider : providers) provider->enable();
+}
+
+void fusion::Provider::disable()
+{
+    for (auto provider : providers) provider->disable();
+}
+
+void fusion::Provider::activate()
+{
+    for (auto provider : providers) provider->activate();
+}
+
+void fusion::Provider::deactivate()
+{
+    for (auto provider : providers) provider->deactivate();
+}
+
+location::Provider::Requirements fusion::Provider::requirements() const
+{
+    location::Provider::Requirements reqs{location::Provider::Requirements::none};
+    for (auto provider : providers) reqs = reqs | provider->requirements();
+    return reqs;
+}
+
+bool fusion::Provider::satisfies(const Criteria& criteria)
+{
+    bool result{true};
+    for (auto provider : providers) result &= provider->satisfies(criteria);
+    return result;
+}
+
+const core::Signal<location::Update<location::Position>>& fusion::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::Heading>>& fusion::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::Velocity>>& fusion::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}
+
+fusion::Provider::Ptr fusion::Provider::finalize(const UpdateSelector::Ptr& update_selector)
+{
+    auto sp = shared_from_this(); std::weak_ptr<fusion::Provider> wp{sp};
 
     for (auto provider : providers)
     {
-        connections.push_back(provider->updates().position.connect(
-              [this, provider, update_selector](const location::Update<location::Position>& u)
+        provider->position_updates().connect(
+              [wp, provider, update_selector](const location::Update<location::Position>& u)
               {
-                  // if this is the first update, use it
-                  if (!last_position) {
-                      mutable_updates().position((*(last_position = WithSource<Update<Position>>{provider, u})).value);
-                      
-                  // otherwise use the selector
-                  } else {
-                      try {
-                          mutable_updates().position((*(last_position = update_selector->select(*last_position, WithSource<Update<Position>>{provider, u}))).value);
-                      } catch (const std::exception& e) {
-                          LOG(WARNING) << "Error while updating position";
+                  if (auto sp = wp.lock())
+                  {
+                      // if this is the first update, use it
+                      if (!sp->last_position) {
+                          sp->updates.position((*(sp->last_position = WithSource<Update<Position>>{provider, u})).value);
+
+                      // otherwise use the selector
+                      } else {
+                          try {
+                              sp->updates.position((*(sp->last_position = update_selector->select(*sp->last_position, WithSource<Update<Position>>{provider, u}))).value);
+                          } catch (const std::exception& e) {
+                              LOG(WARNING) << "Error while updating position";
+                          }
                       }
                   }
-              }));
-        connections.push_back(provider->updates().heading.connect(
-              [this](const location::Update<location::Heading>& u)
-              {
-                  mutable_updates().heading(u);
-              }));
-        connections.push_back(provider->updates().velocity.connect(
-              [this](const location::Update<location::Velocity>& u)
-              {
-                  mutable_updates().velocity(u);
-              }));
+              });
+        provider->heading_updates().connect(
+              [wp](const location::Update<location::Heading>& u)
+              {
+                  if (auto sp = wp.lock())
+                    sp->updates.heading(u);
+              });
+        provider->velocity_updates().connect(
+              [wp](const location::Update<location::Velocity>& u)
+              {
+                  if (auto sp = wp.lock())
+                    sp->updates.velocity(u);
+              });
     }
 
-}
-
-// We always match :)
-bool location::FusionProvider::matches_criteria(const location::Criteria&)
-{
-    return true;
-}
-
-// We forward all events to the other providers.
-void location::FusionProvider::on_wifi_and_cell_reporting_state_changed(location::WifiAndCellIdReportingState state)
-{
-    for (auto provider : providers)
-        provider->on_wifi_and_cell_reporting_state_changed(state);
-}
-
-void location::FusionProvider::on_reference_location_updated(const location::Update<location::Position>& position)
-{
-    for (auto provider : providers)
-        provider->on_reference_location_updated(position);
-}
-
-void location::FusionProvider::on_reference_velocity_updated(const location::Update<location::Velocity>& velocity)
-{
-    for (auto provider : providers)
-        provider->on_reference_velocity_updated(velocity);
-}
-
-void location::FusionProvider::on_reference_heading_updated(const location::Update<location::Heading>& heading)
-{
-    for (auto provider : providers)
-        provider->on_reference_heading_updated(heading);
-}
-
-void location::FusionProvider::start_position_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->start_position_updates();
-}
-
-void location::FusionProvider::stop_position_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->stop_position_updates();
-}
-
-void location::FusionProvider::start_heading_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->start_heading_updates();
-}
-
-void location::FusionProvider::stop_heading_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->stop_heading_updates();
-}
-
-void location::FusionProvider::start_velocity_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->start_velocity_updates();
-}
-
-void location::FusionProvider::stop_velocity_updates()
-{
-    for (auto provider : providers)
-        provider->state_controller()->stop_velocity_updates();
+    return sp;
+}
+
+fusion::Provider::Ptr fusion::Provider::create(const std::set<location::Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector)
+{
+    auto sp = fusion::Provider::Ptr{new fusion::Provider{providers, update_selector}};
+    return sp->finalize(update_selector);
 }

=== renamed file 'src/location/fusion_provider.h' => 'src/location/providers/fusion/provider.h'
--- src/location/fusion_provider.h	2016-06-28 11:53:34 +0000
+++ src/location/providers/fusion/provider.h	2016-08-12 12:03:50 +0000
@@ -15,39 +15,57 @@
  *
  * Authored by: Scott Sweeny <[e-mail]
  */
-#ifndef LOCATION_FUSION_PROVIDER_H
-#define LOCATION_FUSION_PROVIDER_H
+#ifndef LOCATION_PROVIDERS_FUSION_PROVIDER_H
+#define LOCATION_PROVIDERS_FUSION_PROVIDER_H
 
 #include <location/provider.h>
-#include <location/provider_selection_policy.h>
-#include <location/update_selector.h>
+#include <location/providers/fusion/update_selector.h>
 
 namespace location
 {
-class FusionProvider : public Provider
+namespace providers
+{
+namespace fusion
+{
+class Provider : public std::enable_shared_from_this<Provider>, public location::Provider
 {
 public:
-    typedef std::shared_ptr<FusionProvider> Ptr;
-
-    FusionProvider(const std::set<Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector);
-
-    bool matches_criteria(const Criteria &criteria) override;
-    void on_wifi_and_cell_reporting_state_changed(location::WifiAndCellIdReportingState state) override;
-    void on_reference_location_updated(const Update<Position>& position) override;
-    void on_reference_velocity_updated(const Update<Velocity>& velocity) override;
-    void on_reference_heading_updated(const Update<Heading>& heading) override;
-    void start_position_updates() override;
-    void stop_position_updates() override;
-    void start_heading_updates() override;
-    void stop_heading_updates() override;
-    void start_velocity_updates() override;
-    void stop_velocity_updates() override;
+    typedef std::shared_ptr<Provider> Ptr;
+
+    static Ptr create(const std::set<location::Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector);
+
+    // From Provider
+    void on_new_event(const Event& event) override;
+
+    void enable() override;
+    void disable() override;
+    void activate() override;
+    void deactivate() override;
+
+    Requirements requirements() const override;
+    bool satisfies(const Criteria& criteria) override;
+    const core::Signal<Update<Position>>& position_updates() const override;
+    const core::Signal<Update<Heading>>& heading_updates() const override;
+    const core::Signal<Update<Velocity>>& velocity_updates() const override;
 
 private:
+    Provider(const std::set<location::Provider::Ptr>& providers, const UpdateSelector::Ptr& update_selector);
+
+    std::shared_ptr<Provider> finalize(const UpdateSelector::Ptr& update_selector);
+
     Optional<WithSource<Update<Position>>> last_position;
-    std::set<Provider::Ptr> providers;
+    std::set<location::Provider::Ptr> providers;
     std::vector<core::ScopedConnection> connections;
+
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<Heading>> heading;
+        core::Signal<Update<Velocity>> velocity;
+    } updates;
 };
 }
+}
+}
 
-#endif // LOCATION_FUSION_PROVIDER_H
+#endif // LOCATION_PROVIDERS_FUSION_PROVIDER_H

=== renamed file 'src/location/update_selector.h' => 'src/location/providers/fusion/update_selector.h'
--- src/location/update_selector.h	2016-06-28 11:53:34 +0000
+++ src/location/providers/fusion/update_selector.h	2016-08-12 12:03:50 +0000
@@ -25,7 +25,7 @@
 {
 
 template<typename T>
-struct WithSource { std::shared_ptr<Provider> source; T value; };
+struct WithSource { std::weak_ptr<Provider> source; T value; };
 
 class UpdateSelector
 {

=== removed directory 'src/location/providers/geoclue'
=== removed file 'src/location/providers/geoclue/CMakeLists.txt'
--- src/location/providers/geoclue/CMakeLists.txt	2016-06-27 06:44:50 +0000
+++ src/location/providers/geoclue/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-option(
-    LOCATION_ENABLE_GEOCLUE_PROVIDER
-    "Enable location provider connecting to existing geoclue providers"
-    ON
-)
-
-if (LOCATION_ENABLE_GEOCLUE_PROVIDER)
-
-  message(STATUS "Enabling support for Geoclue location providers")
-
-  add_library(geoclue provider.cpp)
-
-  set(
-    ENABLED_PROVIDER_TARGETS
-    ${ENABLED_PROVIDER_TARGETS} geoclue
-    PARENT_SCOPE
-  )
-
-  set(
-    ENABLED_PROVIDER_TARGETS_DEFINITIONS
-    -DLOCATION_PROVIDERS_GEOCLUE ${ENABLED_PROVIDER_TARGETS_DEFINITIONS}
-    PARENT_SCOPE
-  )
-endif (LOCATION_ENABLE_GEOCLUE_PROVIDER)

=== removed file 'src/location/providers/geoclue/geoclue.h'
--- src/location/providers/geoclue/geoclue.h	2016-06-26 21:17:03 +0000
+++ src/location/providers/geoclue/geoclue.h	1970-01-01 00:00:00 +0000
@@ -1,257 +0,0 @@
-/*
- * Copyright © 2012-2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- */
-#ifndef LOCATION_PROVIDERS_GEOCLUE_GEOCLUE_H_
-#define LOCATION_PROVIDERS_GEOCLUE_GEOCLUE_H_
-
-#include <core/dbus/service.h>
-#include <core/dbus/traits/service.h>
-#include <core/dbus/types/struct.h>
-#include <core/dbus/types/stl/tuple.h>
-
-#include <string>
-
-namespace dbus = core::dbus;
-
-namespace org
-{
-namespace freedesktop
-{
-struct Geoclue
-{
-    enum class Status : int
-    {
-        error,
-        unavailable,
-        acquiring,
-        available
-    };
-
-    friend std::ostream& operator<<(std::ostream& out, const Status& status)
-    {
-        static std::map<Status, std::string> lut =
-        {
-            {Status::error, "error"},
-            {Status::unavailable, "unavailable"},
-            {Status::acquiring, "acquiring"},
-            {Status::available, "available"}
-        };
-
-        return out << lut[status];
-    }
-
-    struct GetProviderInfo
-    {
-        inline static std::string name()
-        {
-            return "GetProviderInfo";
-        }
-        typedef Geoclue Interface;
-        typedef std::tuple<std::string, std::string> ResultType;
-        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-    };
-
-    struct GetStatus
-    {
-        inline static std::string name()
-        {
-            return "GetStatus";
-        }
-        typedef Geoclue Interface;
-        typedef int32_t ResultType;
-        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-    };
-
-    struct AddReference
-    {
-        inline static std::string name()
-        {
-            return "AddReference";
-        }
-        typedef Geoclue Interface;
-        typedef void ResultType;
-        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-    };
-
-    struct RemoveReference
-    {
-        inline static std::string name()
-        {
-            return "RemoveReference";
-        }
-        typedef Geoclue Interface;
-        typedef void ResultType;
-        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-    };
-
-    struct Address
-    {
-        struct GetAddress
-        {
-            inline static std::string name()
-            {
-                return "GetAddress";
-            }
-            typedef Address Interface;
-            typedef std::tuple<int32_t, std::map<std::string, std::string>, dbus::types::Struct<std::tuple<int32_t, double, double>>> ResultType;
-            inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-        };
-
-        struct Signals
-        {
-            struct AddressChanged
-            {
-                inline static std::string name()
-                {
-                    return "PositionChanged";
-                };
-                typedef Address Interface;
-                typedef std::tuple<int32_t, std::map<std::string, std::string>, dbus::types::Struct<std::tuple<int32_t, double, double>>> ArgumentType;
-            };
-        };
-    };
-
-    struct Position
-    {
-        struct Field
-        {
-            Field() = delete;
-
-            static const int none = 0;
-            static const int latitude = 1;
-            static const int longitude = 2;
-            static const int altitude = 3;
-        };
-
-        typedef std::bitset<4> FieldFlags;
-
-        struct GetPosition
-        {
-            inline static std::string name()
-            {
-                return "GetPosition";
-            }
-            typedef Position Interface;
-            typedef std::tuple<int32_t, int32_t, double, double, double, dbus::types::Struct<std::tuple<int32_t, double, double>>> ResultType;
-            inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-        };
-
-        struct Signals
-        {
-            struct PositionChanged
-            {
-                inline static std::string name()
-                {
-                    return "PositionChanged";
-                };
-                typedef Position Interface;
-                typedef std::tuple<int32_t, int32_t, double, double, double, dbus::types::Struct<std::tuple<int32_t, double, double>>> ArgumentType;
-            };
-        };
-    };
-
-    struct Velocity
-    {
-        struct Field
-        {
-            Field() = delete;
-
-            static const int none = 0;
-            static const int speed = 1;
-            static const int direction = 2;
-            static const int climb = 3;
-        };
-
-        typedef std::bitset<4> FieldFlags;
-
-        struct GetVelocity
-        {
-            inline static std::string name()
-            {
-                return "GetVelocity";
-            }
-            typedef Velocity Interface;
-            typedef std::tuple<int32_t, int32_t, double, double, double> ResultType;
-            inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-        };
-        struct Signals
-        {
-            struct VelocityChanged
-            {
-                inline static std::string name()
-                {
-                    return "VelocityChanged";
-                };
-                typedef Velocity Interface;
-                typedef std::tuple<int32_t, int32_t, double, double, double> ArgumentType;
-            };
-        };
-    };
-};
-}
-}
-
-namespace core
-{
-namespace dbus
-{
-namespace traits
-{
-template<>
-struct Service<org::freedesktop::Geoclue>
-{
-    inline static const std::string& interface_name()
-    {
-        static const std::string s{"org.freedesktop.Geoclue"};
-        return s;
-    }
-};
-
-template<>
-struct Service<org::freedesktop::Geoclue::Address>
-{
-    inline static const std::string& interface_name()
-    {
-        static const std::string s{"org.freedesktop.Geoclue.Address"};
-        return s;
-    }
-};
-
-template<>
-struct Service<org::freedesktop::Geoclue::Position>
-{
-    inline static const std::string& interface_name()
-    {
-        static const std::string s{"org.freedesktop.Geoclue.Position"};
-        return s;
-    }
-};
-
-template<>
-struct Service<org::freedesktop::Geoclue::Velocity>
-{
-    inline static const std::string& interface_name()
-    {
-        static const std::string s{"org.freedesktop.Geoclue.Velocity"};
-        return s;
-    }
-};
-}
-}
-}
-
-#endif // LOCATION_PROVIDERS_GEOCLUE_GEOCLUE_H_

=== removed file 'src/location/providers/geoclue/provider.cpp'
--- src/location/providers/geoclue/provider.cpp	2016-06-26 21:17:03 +0000
+++ src/location/providers/geoclue/provider.cpp	1970-01-01 00:00:00 +0000
@@ -1,165 +0,0 @@
-/*
- * Copyright © 2012-2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *              Manuel de la Pena <[e-mail]>
- */
-
-#include "provider.h"
-
-namespace dbus = core::dbus;
-
-namespace
-{
-dbus::Bus::Ptr the_session_bus()
-{
-    static dbus::Bus::Ptr session_bus = std::make_shared<dbus::Bus>(dbus::WellKnownBus::session);
-    return session_bus;
-}
-}
-
-void location::providers::geoclue::Provider::start()
-{
-    if (!worker.joinable())
-        worker = std::move(std::thread{std::bind(&dbus::Bus::run, bus)});
-}
-
-void location::providers::geoclue::Provider::stop()
-{
-    bus->stop();
-    if (worker.joinable())
-        worker.join();
-}
-
-void location::providers::geoclue::Provider::on_position_changed(const fd::Geoclue::Position::Signals::PositionChanged::ArgumentType& arg)
-{
-    fd::Geoclue::Position::FieldFlags flags{static_cast<unsigned long>(std::get<0>(arg))};
-    location::Position pos
-    {
-        flags.test(fd::Geoclue::Position::Field::latitude) ?
-            location::wgs84::Latitude{std::get<2>(arg)* location::units::Degrees} : location::wgs84::Latitude{},
-        flags.test(fd::Geoclue::Position::Field::longitude) ?
-            location::wgs84::Longitude{std::get<3>(arg)* location::units::Degrees} : location::wgs84::Longitude{}
-    };
-
-    if (flags.test(fd::Geoclue::Position::Field::altitude))
-        pos.altitude = location::wgs84::Altitude{std::get<4>(arg)* location::units::Meters};
-
-    location::Update<location::Position> update(pos);
-    mutable_updates().position(update);
-}
-
-void location::providers::geoclue::Provider::on_velocity_changed(const fd::Geoclue::Velocity::Signals::VelocityChanged::ArgumentType& arg)
-{
-    fd::Geoclue::Velocity::FieldFlags flags{static_cast<unsigned long>(std::get<0>(arg))};
-    if (flags.none())
-        return;
-    if (flags.test(fd::Geoclue::Velocity::Field::speed))
-    {
-        location::Update<location::Velocity> update
-        {
-            std::get<2>(arg) * location::units::MetersPerSecond,
-            location::Clock::now()
-        };
-        mutable_updates().velocity(update);
-    }
-
-    if (flags.test(fd::Geoclue::Velocity::Field::direction))
-    {
-        location::Update<location::Heading> update
-        {
-            std::get<3>(arg) * location::units::Degrees,
-            location::Clock::now()
-        };
-
-        mutable_updates().heading(update);
-    }
-}
-
-location::Provider::Ptr location::providers::geoclue::Provider::create_instance(const location::ProviderFactory::Configuration& config)
-{
-    location::providers::geoclue::Provider::Configuration pConfig;
-    pConfig.name = config.count(Configuration::key_name()) > 0 ?
-                   config.get<std::string>(Configuration::key_name()) : throw std::runtime_error("Missing bus-name");
-    pConfig.path = config.count(Configuration::key_path()) > 0 ?
-                   config.get<std::string>(Configuration::key_path()) : throw std::runtime_error("Missing bus-path");
-    return location::Provider::Ptr{new location::providers::geoclue::Provider{pConfig}};
-}
-
-location::providers::geoclue::Provider::Provider(const location::providers::geoclue::Provider::Configuration& config)
-        : location::Provider(config.features, config.requirements),
-          bus(the_session_bus()),
-          service(dbus::Service::use_service(bus, config.name)),
-          object(service->object_for_path(config.path)),
-          signal_position_changed(object->get_signal<fd::Geoclue::Position::Signals::PositionChanged>()),
-          signal_velocity_changed(object->get_signal<fd::Geoclue::Velocity::Signals::VelocityChanged>())
-{
-    position_updates_connection = signal_position_changed->connect(
-            std::bind(&location::providers::geoclue::Provider::on_position_changed, this, std::placeholders::_1));
-    velocity_updates_connection = signal_velocity_changed->connect(
-            std::bind(&location::providers::geoclue::Provider::on_velocity_changed, this, std::placeholders::_1));
-
-    auto info = object->invoke_method_synchronously<
-        fd::Geoclue::GetProviderInfo,
-        fd::Geoclue::GetProviderInfo::ResultType>();
-    auto status = object->invoke_method_synchronously<
-        fd::Geoclue::GetStatus,
-        fd::Geoclue::GetStatus::ResultType>();
-        
-    std::cout << "GeoclueProvider: [" 
-              << std::get<0>(info.value()) << ", " 
-              << std::get<1>(info.value()) << ","
-              << static_cast<fd::Geoclue::Status>(status.value()) << "]" <<std::endl;
-}
-
-location::providers::geoclue::Provider::~Provider() noexcept
-{
-    stop();
-}
-
-bool location::providers::geoclue::Provider::matches_criteria(const location::Criteria&)
-{
-    return true;
-}
-
-void location::providers::geoclue::Provider::start_position_updates()
-{
-    start();
-}
-
-void location::providers::geoclue::Provider::stop_position_updates()
-{
-    stop();
-}
-
-void location::providers::geoclue::Provider::start_velocity_updates()
-{
-    start();
-}
-
-void location::providers::geoclue::Provider::stop_velocity_updates()
-{
-    stop();
-}    
-
-void location::providers::geoclue::Provider::start_heading_updates()
-{
-    start();
-}
-
-void location::providers::geoclue::Provider::stop_heading_updates()
-{
-    stop();
-}    

=== removed file 'src/location/providers/geoclue/provider.h'
--- src/location/providers/geoclue/provider.h	2016-06-26 21:17:03 +0000
+++ src/location/providers/geoclue/provider.h	1970-01-01 00:00:00 +0000
@@ -1,106 +0,0 @@
-/*
- * Copyright © 2012-2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * 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 Lesser 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/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *              Manuel de la Pena <[e-mail]>
- */
-#ifndef LOCATION_PROVIDERS_GEOCLUE_PROVIDER_H_
-#define LOCATION_PROVIDERS_GEOCLUE_PROVIDER_H_
-
-#include <core/dbus/object.h>
-#include <core/dbus/signal.h>
-
-#include "core/dbus/object.h"
-#include "core/dbus/signal.h"
-
-#include <location/provider.h>
-#include <location/provider_factory.h>
-
-#include <thread>
-
-#include "geoclue.h"
-
-namespace fd = org::freedesktop;
-
-namespace location
-{
-namespace providers
-{
-namespace geoclue
-{
-class Provider : public location::Provider
-{
-
-  typedef dbus::Signal<
-      fd::Geoclue::Position::Signals::PositionChanged,
-      fd::Geoclue::Position::Signals::PositionChanged::ArgumentType
-  > PositionChanged;
-
-  typedef dbus::Signal<
-      fd::Geoclue::Velocity::Signals::VelocityChanged,
-      fd::Geoclue::Velocity::Signals::VelocityChanged::ArgumentType
-  > VelocityChanged;
-
-  public:
-    static Provider::Ptr create_instance(const ProviderFactory::Configuration&);
-
-    struct Configuration
-    {
-        static std::string key_name() { return "name"; }
-        static std::string key_path() { return "path"; }
-        std::string name;
-        std::string path;
-
-        Provider::Features features = Provider::Features::none;
-        Provider::Requirements requirements = Provider::Requirements::none;
-    };
-
-    Provider(const Configuration& config);
-    ~Provider() noexcept;
-
-    virtual bool matches_criteria(const Criteria&);
-
-    virtual void start_position_updates() override;
-    virtual void stop_position_updates() override;
-
-    virtual void start_velocity_updates() override;
-    virtual void stop_velocity_updates() override;
-
-    virtual void start_heading_updates() override;
-    virtual void stop_heading_updates() override;
-
-  private:
-    void start();
-    void stop();
-
-    void on_position_changed(const fd::Geoclue::Position::Signals::PositionChanged::ArgumentType& arg);
-    void on_velocity_changed(const fd::Geoclue::Velocity::Signals::VelocityChanged::ArgumentType& arg);
-
-  private:
-    dbus::Bus::Ptr bus;
-    dbus::Service::Ptr service;
-    dbus::Object::Ptr object;
-    PositionChanged::Ptr signal_position_changed;
-    VelocityChanged::Ptr signal_velocity_changed;
-    PositionChanged::SubscriptionToken position_updates_connection;
-    VelocityChanged::SubscriptionToken velocity_updates_connection;
-
-    std::thread worker;
-};
-}
-}
-}
-
-#endif // LOCATION_PROVIDERS_GEOCLUE_PROVIDER_H_

=== modified file 'src/location/providers/gps/provider.cpp'
--- src/location/providers/gps/provider.cpp	2016-06-27 10:56:44 +0000
+++ src/location/providers/gps/provider.cpp	2016-08-12 12:03:50 +0000
@@ -37,30 +37,27 @@
 }
 
 location::providers::gps::Provider::Provider(const std::shared_ptr<HardwareAbstractionLayer>& hal)
-    : location::Provider(
-          location::Provider::Features::position | location::Provider::Features::velocity | location::Provider::Features::heading,
-          location::Provider::Requirements::satellites),
-          hal(hal)
+    : hal(hal)
 {
 
     hal->position_updates().connect([this](const location::Position& pos)
     {
-        mutable_updates().position(Update<Position>(pos));
+        updates.position(Update<Position>(pos));
     });
 
     hal->heading_updates().connect([this](const location::Heading& heading)
     {
-        mutable_updates().heading(Update<Heading>(heading));
+        updates.heading(Update<Heading>(heading));
     });
 
     hal->velocity_updates().connect([this](const location::Velocity& velocity)
     {
-        mutable_updates().velocity(Update<Velocity>(velocity));
+        updates.velocity(Update<Velocity>(velocity));
     });
 
     hal->space_vehicle_updates().connect([this](const std::set<location::SpaceVehicle>& svs)
     {
-        mutable_updates().svs(Update<std::set<location::SpaceVehicle>>(svs));
+        updates.svs(Update<std::set<location::SpaceVehicle>>(svs));
     });
 }
 
@@ -68,39 +65,59 @@
 {
 }
 
-bool location::providers::gps::Provider::matches_criteria(const location::Criteria&)
+void location::providers::gps::Provider::on_new_event(const Event&)
+{
+}
+
+location::Provider::Requirements location::providers::gps::Provider::requirements() const
+{
+    return Requirements::satellites;
+}
+
+bool location::providers::gps::Provider::satisfies(const location::Criteria&)
 {
     return true;
 }
 
-void location::providers::gps::Provider::start_position_updates()
+void location::providers::gps::Provider::enable()
+{
+}
+
+void location::providers::gps::Provider::disable()
+{
+}
+
+void location::providers::gps::Provider::activate()
 {
     hal->start_positioning();
 }
 
-void location::providers::gps::Provider::stop_position_updates()
+void location::providers::gps::Provider::deactivate()
 {
     hal->stop_positioning();
 }
 
-void location::providers::gps::Provider::start_velocity_updates()
-{   
-}
-
-void location::providers::gps::Provider::stop_velocity_updates()
-{
-}    
-
-void location::providers::gps::Provider::start_heading_updates()
-{
-}
-
-void location::providers::gps::Provider::stop_heading_updates()
-{
+const core::Signal<location::Update<location::Position>>& location::providers::gps::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::Heading>>& location::providers::gps::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::Velocity>>& location::providers::gps::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}
+
+const core::Signal<location::Update<std::set<location::SpaceVehicle>>>& location::providers::gps::Provider::svs_updates() const
+{
+    return updates.svs;
 }
 
 void location::providers::gps::Provider::on_reference_location_updated(const location::Update<location::Position>& position)
 {
     hal->inject_reference_position(position.value);
 }
-

=== modified file 'src/location/providers/gps/provider.h'
--- src/location/providers/gps/provider.h	2016-06-26 21:17:03 +0000
+++ src/location/providers/gps/provider.h	2016-08-12 12:03:50 +0000
@@ -43,21 +43,31 @@
     Provider& operator=(const Provider&) = delete;
     ~Provider() noexcept;
 
-    bool matches_criteria(const Criteria&);
-
-    void start_position_updates();
-    void stop_position_updates();
-
-    void start_velocity_updates();
-    void stop_velocity_updates();
-
-    void start_heading_updates();
-    void stop_heading_updates();
-
+    void on_new_event(const Event& event) override;
+
+    void enable() override;
+    void disable() override;
+    void activate() override;
+    void deactivate() override;
+
+    Requirements requirements() const override;
+    bool satisfies(const Criteria& criteria) override;
+    const core::Signal<Update<Position>>& position_updates() const override;
+    const core::Signal<Update<Heading>>& heading_updates() const override;
+    const core::Signal<Update<Velocity>>& velocity_updates() const override;
+
+    const core::Signal<Update<std::set<SpaceVehicle>>>& svs_updates() const;
     void on_reference_location_updated(const Update<Position>& position);
 
   private:
     std::shared_ptr<HardwareAbstractionLayer> hal;
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<Heading>> heading;
+        core::Signal<Update<Velocity>> velocity;
+        core::Signal<Update<std::set<SpaceVehicle>>> svs;
+    } updates;
 };
 }
 }

=== added file 'src/location/providers/proxy.cpp'
--- src/location/providers/proxy.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/proxy.cpp	2016-08-12 12:03:50 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Scott Sweeny <[e-mail]
+ */
+
+#include <location/providers/proxy.h>
+
+location::providers::Proxy::Proxy(const std::set<Provider::Ptr>& providers)
+      : providers{providers}
+{
+    for (auto provider : providers)
+    {
+        connections.emplace_back(provider->position_updates().connect([this](const location::Update<location::Position>& u)
+        {
+            updates.position(u);
+        }));
+
+        connections.emplace_back(provider->heading_updates().connect([this](const location::Update<location::Heading>& u)
+        {
+            updates.heading(u);
+        }));
+
+        connections.emplace_back(provider->velocity_updates().connect([this](const location::Update<location::Velocity>& u)
+        {
+            updates.velocity(u);
+        }));
+    }
+}
+
+void location::providers::Proxy::on_new_event(const Event& event)
+{
+    for (auto provider: providers) provider->on_new_event(event);
+}
+
+void location::providers::Proxy::enable()
+{
+    for (auto provider : providers) provider->enable();
+}
+
+void location::providers::Proxy::disable()
+{
+    for (auto provider : providers) provider->disable();
+}
+
+void location::providers::Proxy::activate()
+{
+    for (auto provider : providers) provider->activate();
+}
+
+void location::providers::Proxy::deactivate()
+{
+    for (auto provider : providers) provider->deactivate();
+}
+
+location::Provider::Requirements location::providers::Proxy::requirements() const
+{
+    location::Provider::Requirements reqs{location::Provider::Requirements::none};
+    for (auto provider : providers) reqs = reqs | provider->requirements();
+    return reqs;
+}
+
+bool location::providers::Proxy::satisfies(const Criteria& criteria)
+{
+    bool result{true};
+    for (auto provider : providers) result &= provider->satisfies(criteria);
+    return result;
+}
+
+const core::Signal<location::Update<location::Position>>& location::providers::Proxy::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::Heading>>& location::providers::Proxy::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::Velocity>>& location::providers::Proxy::velocity_updates() const
+{
+    return updates.velocity;
+}

=== added file 'src/location/providers/proxy.h'
--- src/location/providers/proxy.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/proxy.h	2016-08-12 12:03:50 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser 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/>.
+ *
+ * Authored by: Scott Sweeny <[e-mail]
+ */
+#ifndef LOCATION_PROVIDERS_PROXY_H
+#define LOCATION_PROVIDERS_PROXY_H
+
+#include <location/provider.h>
+
+#include <set>
+
+namespace location
+{
+namespace providers
+{
+class Proxy : public Provider
+{
+public:
+    explicit Proxy(const std::set<Provider::Ptr>& providers);
+
+    // From Provider
+    void on_new_event(const Event&) override;
+    void enable() override;
+    void disable() override;
+    void activate() override;
+    void deactivate() override;
+
+    Requirements requirements() const override;
+    bool satisfies(const Criteria& criteria) override;
+    const core::Signal<Update<Position>>& position_updates() const override;
+    const core::Signal<Update<Heading>>& heading_updates() const override;
+    const core::Signal<Update<Velocity>>& velocity_updates() const override;
+
+private:
+    std::set<Provider::Ptr> providers;
+    std::vector<core::ScopedConnection> connections;
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<Heading>> heading;
+        core::Signal<Update<Velocity>> velocity;
+    } updates;
+};
+}
+}
+#endif // LOCATION_PROVIDERS_PROXY_H

=== modified file 'src/location/providers/remote/interface.h'
--- src/location/providers/remote/interface.h	2016-06-28 11:53:34 +0000
+++ src/location/providers/remote/interface.h	2016-08-12 12:03:50 +0000
@@ -47,111 +47,39 @@
         return s;
     }
 
-    // Checks if a provider satisfies a set of accuracy criteria.
-    DBUS_CPP_METHOD_DEF(MatchesCriteria, remote::Interface)
-    // Checks if the provider has got a specific requirement.
-    DBUS_CPP_METHOD_DEF(Requires, remote::Interface)
-    // Checks if the provider supports a specific feature.
-    DBUS_CPP_METHOD_DEF(Supports, remote::Interface)
-    // Called by the engine whenever the wifi and cell ID reporting state changes.
-    DBUS_CPP_METHOD_DEF(OnWifiAndCellIdReportingStateChanged, remote::Interface)
-    // Called by the engine whenever the reference location changed.
-    DBUS_CPP_METHOD_DEF(OnReferenceLocationChanged, remote::Interface)
-    // Called by the engine whenever the reference heading changed.
-    DBUS_CPP_METHOD_DEF(OnReferenceHeadingChanged, remote::Interface)
-    // Called by the engine whenever the reference velocity changed.
-    DBUS_CPP_METHOD_DEF(OnReferenceVelocityChanged, remote::Interface)
-
-    DBUS_CPP_METHOD_DEF(StartPositionUpdates, remote::Interface)
-    DBUS_CPP_METHOD_DEF(StopPositionUpdates, remote::Interface)
-    DBUS_CPP_METHOD_DEF(StartHeadingUpdates, remote::Interface)
-    DBUS_CPP_METHOD_DEF(StopHeadingUpdates, remote::Interface)
-    DBUS_CPP_METHOD_DEF(StartVelocityUpdates, remote::Interface)
-    DBUS_CPP_METHOD_DEF(StopVelocityUpdates, remote::Interface)
-
-    struct Signals
-    {
-        DBUS_CPP_SIGNAL_DEF(PositionChanged, remote::Interface, location::Position)
-        DBUS_CPP_SIGNAL_DEF(HeadingChanged, remote::Interface, location::Heading)
-        DBUS_CPP_SIGNAL_DEF(VelocityChanged, remote::Interface, location::Velocity)
-    };
-
-    struct Properties
-    {
-        DBUS_CPP_READABLE_PROPERTY_DEF(HasPosition, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(HasVelocity, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(HasHeading, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(RequiresSatellites, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(RequiresCellNetwork, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(RequiresDataNetwork, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(RequiresMonetarySpending, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(ArePositionUpdatesRunning, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(AreHeadingUpdatesRunning, remote::Interface, bool)
-        DBUS_CPP_READABLE_PROPERTY_DEF(AreVelocityUpdatesRunning, remote::Interface, bool)
-    };
+    struct Observer
+    {
+        static const std::string& name()
+        {
+            static const std::string s{"com.ubuntu.remote.Service.Provider.Observer"};
+            return s;
+        }
+
+        DBUS_CPP_METHOD_DEF(UpdatePosition, remote::Interface::Observer)
+        DBUS_CPP_METHOD_DEF(UpdateHeading, remote::Interface::Observer)
+        DBUS_CPP_METHOD_DEF(UpdateVelocity, remote::Interface::Observer)
+    };
+
+    DBUS_CPP_METHOD_DEF(OnNewEvent, remote::Interface)
+    DBUS_CPP_METHOD_DEF(AddObserver, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Satisfies, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Requirements, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Enable, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Disable, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Activate, remote::Interface)
+    DBUS_CPP_METHOD_DEF(Deactivate, remote::Interface)
 
     struct Skeleton
     {
         // Creates a new skeleton instance and installs the interface
         // remote::Interface on it.
         Skeleton(const core::dbus::Object::Ptr& object)
-            : object{object},
-              properties
-              {
-                  object->get_property<Properties::HasPosition>(),
-                  object->get_property<Properties::HasVelocity>(),
-                  object->get_property<Properties::HasHeading>(),
-                  object->get_property<Properties::RequiresSatellites>(),
-                  object->get_property<Properties::RequiresCellNetwork>(),
-                  object->get_property<Properties::RequiresDataNetwork>(),
-                  object->get_property<Properties::RequiresMonetarySpending>(),
-                  object->get_property<Properties::ArePositionUpdatesRunning>(),
-                  object->get_property<Properties::AreHeadingUpdatesRunning>(),
-                  object->get_property<Properties::AreVelocityUpdatesRunning>()
-              },
-              signals
-              {
-                  object->get_signal<Signals::PositionChanged>(),
-                  object->get_signal<Signals::HeadingChanged>(),
-                  object->get_signal<Signals::VelocityChanged>()
-              }
+            : object{object}
         {
         }
 
         // The object that the interface is installed on.
         core::dbus::Object::Ptr object;
-        // All known properties.
-        struct
-        {
-            std::shared_ptr<core::dbus::Property<Properties::HasPosition>> has_position;
-            std::shared_ptr<core::dbus::Property<Properties::HasVelocity>> has_velocity;
-            std::shared_ptr<core::dbus::Property<Properties::HasHeading>> has_heading;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresSatellites>> requires_satellites;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresCellNetwork>> requires_cell_network;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresDataNetwork>> requires_data_network;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresMonetarySpending>> requires_monetary_spending;
-            std::shared_ptr<core::dbus::Property<Properties::ArePositionUpdatesRunning>> are_position_updates_running;
-            std::shared_ptr<core::dbus::Property<Properties::AreHeadingUpdatesRunning>> are_heading_updates_running;
-            std::shared_ptr<core::dbus::Property<Properties::AreVelocityUpdatesRunning>> are_velocity_updates_running;
-        } properties;
-        // All known signals.
-        struct
-        {
-            std::shared_ptr<core::dbus::Signal<
-                Signals::PositionChanged,
-                Signals::PositionChanged::ArgumentType
-            >> position_changed;
-
-            std::shared_ptr<core::dbus::Signal<
-                Signals::HeadingChanged,
-                Signals::HeadingChanged::ArgumentType
-            >> heading_changed;
-
-            std::shared_ptr<core::dbus::Signal<
-                Signals::VelocityChanged,
-                Signals::VelocityChanged::ArgumentType
-            >> velocity_changed;
-        } signals;
     };
 
     struct Stub
@@ -159,63 +87,12 @@
         // Creates a new skeleton instance and installs the interface
         // remote::Interface on it.
         Stub(const core::dbus::Object::Ptr& object)
-            : object{object},
-              properties
-              {
-                  object->get_property<Properties::HasPosition>(),
-                  object->get_property<Properties::HasVelocity>(),
-                  object->get_property<Properties::HasHeading>(),
-                  object->get_property<Properties::RequiresSatellites>(),
-                  object->get_property<Properties::RequiresCellNetwork>(),
-                  object->get_property<Properties::RequiresDataNetwork>(),
-                  object->get_property<Properties::RequiresMonetarySpending>(),
-                  object->get_property<Properties::ArePositionUpdatesRunning>(),
-                  object->get_property<Properties::AreHeadingUpdatesRunning>(),
-                  object->get_property<Properties::AreVelocityUpdatesRunning>()
-              },
-              signals
-              {
-                  object->get_signal<Signals::PositionChanged>(),
-                  object->get_signal<Signals::HeadingChanged>(),
-                  object->get_signal<Signals::VelocityChanged>()
-              }
+            : object{object}
         {
         }
 
         // The object that the interface is installed on.
-        core::dbus::Object::Ptr object;
-        // All known properties.
-        struct
-        {
-            std::shared_ptr<core::dbus::Property<Properties::HasPosition>> has_position;
-            std::shared_ptr<core::dbus::Property<Properties::HasVelocity>> has_velocity;
-            std::shared_ptr<core::dbus::Property<Properties::HasHeading>> has_heading;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresSatellites>> requires_satellites;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresCellNetwork>> requires_cell_network;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresDataNetwork>> requires_data_network;
-            std::shared_ptr<core::dbus::Property<Properties::RequiresMonetarySpending>> requires_monetary_spending;
-            std::shared_ptr<core::dbus::Property<Properties::ArePositionUpdatesRunning>> are_position_updates_running;
-            std::shared_ptr<core::dbus::Property<Properties::AreHeadingUpdatesRunning>> are_heading_updates_running;
-            std::shared_ptr<core::dbus::Property<Properties::AreVelocityUpdatesRunning>> are_velocity_updates_running;
-        } properties;
-        // All known signals.
-        struct
-        {
-            std::shared_ptr<core::dbus::Signal<
-                Signals::PositionChanged,
-                Signals::PositionChanged::ArgumentType
-            >> position_changed;
-
-            std::shared_ptr<core::dbus::Signal<
-                Signals::HeadingChanged,
-                Signals::HeadingChanged::ArgumentType
-            >> heading_changed;
-
-            std::shared_ptr<core::dbus::Signal<
-                Signals::VelocityChanged,
-                Signals::VelocityChanged::ArgumentType
-            >> velocity_changed;
-        } signals;
+        core::dbus::Object::Ptr object;   
     };
 
 };

=== modified file 'src/location/providers/remote/provider.cpp'
--- src/location/providers/remote/provider.cpp	2016-06-26 21:17:03 +0000
+++ src/location/providers/remote/provider.cpp	2016-08-12 12:03:50 +0000
@@ -17,9 +17,12 @@
  */
 
 #include <location/providers/remote/provider.h>
-
 #include <location/providers/remote/interface.h>
 
+#include <location/dbus/codec.h>
+#include <location/events/registry.h>
+#include <location/events/reference_position_updated.h>
+#include <location/events/wifi_and_cell_id_reporting_state_changed.h>
 #include <location/logging.h>
 
 #include <core/dbus/object.h>
@@ -40,113 +43,6 @@
 
 namespace
 {
-struct Runtime
-{
-    static Runtime& instance()
-    {
-        static Runtime runtime;
-        return runtime;
-    }
-
-    Runtime()
-        : running{true},
-          worker1{std::bind(&Runtime::run, this, std::ref(io.service))},
-          worker2{std::bind(&Runtime::run, this, std::ref(task.service))}
-    {
-    }
-
-    ~Runtime()
-    {
-        stop();
-    }
-
-    void run(boost::asio::io_service& service)
-    {
-        while (running)
-        {
-            try
-            {
-                service.run();
-                break;  // provider has exited correctly
-            }
-            catch (const std::exception& e)
-            {
-                LOG(WARNING) << e.what();
-            }
-            catch (...)
-            {
-                LOG(WARNING) << "Caught exception from event loop, restarting.";
-            }
-        }
-    }
-
-    void stop()
-    {
-        running = false;
-
-        task.service.stop();
-
-        if (worker2.joinable())
-            worker2.join();
-
-        io.service.stop();
-
-        if (worker1.joinable())
-            worker1.join();
-    }
-
-    bool running;
-    struct
-    {
-        boost::asio::io_service service;
-        boost::asio::io_service::work keep_alive
-        {
-            service
-        };
-    } io;
-    struct
-    {
-        boost::asio::io_service service;
-        boost::asio::io_service::work keep_alive
-        {
-            service
-        };
-    } task;
-    std::thread worker1;
-    std::thread worker2;
-};
-
-core::dbus::Bus::Ptr bus_from_name(const std::string& bus_name)
-{
-    core::dbus::Bus::Ptr bus;
-
-    if (bus_name == "system")
-        bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::system);
-    else if (bus_name == "session")
-        bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::session);
-    else if (bus_name == "system_with_address_from_env")
-        bus = std::make_shared<core::dbus::Bus>(core::posix::this_process::env::get_or_throw("DBUS_SYSTEM_BUS_ADDRESS"));
-    else if (bus_name == "session_with_address_from_env")
-        bus = std::make_shared<core::dbus::Bus>(core::posix::this_process::env::get_or_throw("DBUS_SESSION_BUS_ADDRESS"));
-
-    if (not bus) throw std::runtime_error
-    {
-        "Could not create bus for name: " + bus_name
-    };
-
-    bus->install_executor(core::dbus::asio::make_executor(bus, Runtime::instance().io.service));
-
-    return bus;
-}
-
-void throw_if_error(const dbus::Result<void>& result)
-{
-    if (result.is_error()) throw std::runtime_error
-    {
-        result.error().print()
-    };
-}
-
 template<typename T>
 T throw_if_error_or_return(const dbus::Result<T>& result)
 {
@@ -156,13 +52,127 @@
     };
     return result.value();
 }
+
+core::dbus::types::ObjectPath generate_path_for_observer()
+{
+    static constexpr const char* pattern{"/com/ubuntu/location/provider/observer/%1%"};
+    static std::size_t counter{0};
+
+    return core::dbus::types::ObjectPath{(boost::format{pattern} % ++counter).str()};
+}
+}
+
+remote::Provider::Observer::Stub::Stub(const core::dbus::Object::Ptr& object)
+    : object{object}
+{
+
+}
+
+void remote::Provider::Observer::Stub::on_new_position(const Update<Position>& update)
+{
+    try
+    {
+        object->invoke_method_asynchronously_with_callback<remote::Interface::Observer::UpdatePosition, void>([](const core::dbus::Result<void>&)
+        {
+
+        }, update);
+    }
+    catch(const std::exception& e)
+    {
+        LOG(WARNING) << e.what();
+    }
+    catch(...)
+    {
+    }
+}
+
+void remote::Provider::Observer::Stub::on_new_heading(const Update<Heading>& update)
+{
+    try
+    {
+        object->invoke_method_asynchronously_with_callback<remote::Interface::Observer::UpdateHeading, void>([](const core::dbus::Result<void>&)
+        {
+
+        }, update);
+    }
+    catch(const std::exception& e)
+    {
+        LOG(WARNING) << e.what();
+    }
+    catch(...)
+    {
+    }
+}
+
+void remote::Provider::Observer::Stub::on_new_velocity(const Update<Velocity>& update)
+{
+    try
+    {
+        object->invoke_method_asynchronously_with_callback<remote::Interface::Observer::UpdateVelocity, void>([](const core::dbus::Result<void>&)
+        {
+
+        }, update);
+    }
+    catch(const std::exception& e)
+    {
+        LOG(WARNING) << e.what();
+    }
+    catch(...)
+    {
+    }
+}
+
+remote::Provider::Observer::Skeleton::Skeleton(const core::dbus::Bus::Ptr& bus, const core::dbus::Object::Ptr& object, const std::shared_ptr<Observer>& impl)
+    : bus{bus}, object{object}, impl{impl}
+{
+    object->install_method_handler<remote::Interface::Observer::UpdatePosition>([this](const core::dbus::Message::Ptr& msg)
+    {
+        VLOG(50) << "remote::Interface::Observer::UpdatePosition";
+        location::Update<location::Position> update; msg->reader() >> update;
+        on_new_position(update);
+        Skeleton::bus->send(dbus::Message::make_method_return(msg));
+    });
+
+    object->install_method_handler<remote::Interface::Observer::UpdateHeading>([this](const core::dbus::Message::Ptr& msg)
+    {
+        VLOG(50) << "remote::Interface::Observer::UpdateHeading";
+        location::Update<location::Heading> update; msg->reader() >> update;
+        on_new_heading(update);
+        Skeleton::bus->send(dbus::Message::make_method_return(msg));
+    });
+
+    object->install_method_handler<remote::Interface::Observer::UpdateVelocity>([this](const core::dbus::Message::Ptr& msg)
+    {
+        VLOG(50) << "remote::Interface::Observer::UpdateVelocity";
+        location::Update<location::Velocity> update; msg->reader() >> update;
+        on_new_velocity(update);
+        Skeleton::bus->send(dbus::Message::make_method_return(msg));
+    });
+}
+
+void remote::Provider::Observer::Skeleton::on_new_position(const Update<Position>& update)
+{
+    impl->on_new_position(update);
+}
+
+void remote::Provider::Observer::Skeleton::on_new_heading(const Update<Heading>& update)
+{
+    impl->on_new_heading(update);
+}
+
+void remote::Provider::Observer::Skeleton::on_new_velocity(const Update<Velocity>& update)
+{
+    impl->on_new_velocity(update);
 }
 
 struct remote::Provider::Stub::Private
 {
-    Private(const remote::stub::Configuration& config)
-            : object(config.object),
-              stub(object)
+    Private(const remote::stub::Configuration& config, location::Provider::Requirements requirements)
+            : bus{config.bus},
+              service{config.service},
+              object{config.object},
+              requirements{requirements},
+              stub{object}
     {
     }
 
@@ -170,125 +180,47 @@
     {
     }
 
+    dbus::Bus::Ptr bus;
+    dbus::Service::Ptr service;
     dbus::Object::Ptr object;
+    location::Provider::Requirements requirements;
     remote::Interface::Stub stub;
+    std::set<std::shared_ptr<remote::Provider::Observer>> observers;
+    struct
+    {
+        core::Signal<location::Update<location::Position>> position;
+        core::Signal<location::Update<location::Heading>> heading;
+        core::Signal<location::Update<location::Velocity>> velocity;
+    } updates;
 };
 
-std::string remote::Provider::Stub::class_name()
-{
-    return "remote::Provider";
-}
-
-cul::Provider::Ptr remote::Provider::Stub::create_instance(const cul::ProviderFactory::Configuration& config)
-{
-    auto bus_name = config.count(Stub::key_bus) > 0 ? config.get<std::string>(Stub::key_bus) :
-                                                       "system";
-    auto name = config.count(Stub::key_name) > 0 ? config.get<std::string>(Stub::key_name) :
-                                                   throw std::runtime_error("Missing bus-name");
-    auto path = config.count(Stub::key_path) > 0 ? config.get<std::string>(Stub::key_path) :
-                                                   throw std::runtime_error("Missing bus-path");
-
-    auto bus = bus_from_name(bus_name);
-    auto service = dbus::Service::use_service(bus, name);
-    auto object = service->object_for_path(path);
-
-    // Check if the service has come up
-    if (!bus->has_owner_for_name(name)) {
-        // If it hasn't wait for it to come up
-        bool valid = false;
-        std::mutex guard;
-        std::condition_variable cv;
-        dbus::DBus daemon(bus);
-        dbus::ServiceWatcher::Ptr service_watcher(
-            daemon.make_service_watcher(name, dbus::DBus::WatchMode::registration));
-
-        service_watcher->service_registered().connect([&valid, &guard, &cv]()
-            {
-                std::unique_lock<std::mutex> ul(guard);
-                valid = true;
-                cv.notify_all();
-            });
-
-        std::unique_lock<std::mutex> ul(guard);
-        if (not cv.wait_for(ul, std::chrono::seconds{30}, [&valid]() { return valid; }))
-            throw std::runtime_error("Remote service failed to start");
-    }
-
-    return create_instance_with_config(remote::stub::Configuration{object});
-}
-
-cul::Provider::Ptr remote::Provider::Stub::create_instance_with_config(const remote::stub::Configuration& config)
-{
-    std::shared_ptr<remote::Provider::Stub> result{new remote::Provider::Stub{config}};
-
-    // This call throws if we fail to reach the remote end. With that, we make sure that
-    // we do not return a potentially invalid instance that throws later on.
-    result->ping();
-
-    result->setup_event_connections();
-    return result;
-}
-
-remote::Provider::Stub::Stub(const remote::stub::Configuration& config)
-        : location::Provider(/* TODO(tvoss) Features should be all initially*/),
-          d(new Private(config))
-{
-}
-
-void remote::Provider::Stub::setup_event_connections()
-{
-    std::weak_ptr<remote::Provider::Stub> wp{shared_from_this()};
-
-    d->stub.signals.position_changed->connect(
-        [wp](const remote::Interface::Signals::PositionChanged::ArgumentType& arg)
-        {
-            VLOG(50) << "remote::Provider::Stub::PositionChanged: " << arg;
-            Runtime::instance().task.service.post([wp, arg]()
-            {
-                auto sp = wp.lock();
-
-                if (not sp)
-                    return;
-
-                sp->mutable_updates().position(arg);
-            });
-        });
-
-    d->stub.signals.heading_changed->connect(
-        [wp](const remote::Interface::Signals::HeadingChanged::ArgumentType& arg)
-        {
-            VLOG(50) << "remote::Provider::Stub::HeadingChanged: " << arg;
-            Runtime::instance().task.service.post([wp, arg]()
-            {
-                auto sp = wp.lock();
-
-                if (not sp)
-                    return;
-
-                sp->mutable_updates().heading(arg);
-            });
-        });
-
-    d->stub.signals.velocity_changed->connect(
-        [wp](const remote::Interface::Signals::VelocityChanged::ArgumentType& arg)
-        {
-            VLOG(50) << "remote::Provider::Stub::VelocityChanged: " << arg;
-            Runtime::instance().task.service.post([wp, arg]()
-            {
-                auto sp = wp.lock();
-
-                if (not sp)
-                    return;
-
-                sp->mutable_updates().velocity(arg);
-            });
-        });
-}
-
-void remote::Provider::Stub::ping()
-{
-    // Requires reaches out to the remote side and throws in case of issues.
-    requires(Provider::Requirements::satellites);
+void remote::Provider::Stub::create_instance_with_config(const remote::stub::Configuration& config, const std::function<void(const Provider::Ptr&)>& cb)
+{
+    config.object->invoke_method_asynchronously_with_callback<remote::Interface::Requirements, Provider::Requirements>([config, cb](const core::dbus::Result<Provider::Requirements>& result)
+    {
+        VLOG(50) << "Finished querying results from remote provider: " << std::boolalpha << result.is_error();
+        if (not result.is_error())
+        {
+            std::shared_ptr<remote::Provider::Stub> provider{new remote::Provider::Stub{config, result.value()}};
+            cb(provider->finalize());
+        }
+        else
+        {
+            LOG(WARNING) << result.error().print();
+        }
+    });
+}
+
+remote::Provider::Stub::Stub(const remote::stub::Configuration& config, Provider::Requirements requirements)
+        : d(new Private(config, requirements))
+{
+}
+
+std::shared_ptr<remote::Provider::Stub> remote::Provider::Stub::finalize()
+{
+    auto thiz = shared_from_this();
+    add_observer(thiz);
+    return thiz;
 }
 
 remote::Provider::Stub::~Stub() noexcept
@@ -296,188 +228,114 @@
     VLOG(10) << __PRETTY_FUNCTION__;
 }
 
-bool remote::Provider::Stub::matches_criteria(const cul::Criteria& criteria)
-{
-    VLOG(10) << __PRETTY_FUNCTION__ << std::endl;    
-    return throw_if_error_or_return(d->stub.object->transact_method<remote::Interface::MatchesCriteria, bool>(criteria));
-}
-
-bool remote::Provider::Stub::supports(const cul::Provider::Features& f) const
-{
-    VLOG(10) << __PRETTY_FUNCTION__;
-    return throw_if_error_or_return(d->stub.object->transact_method<remote::Interface::Supports, bool>(f));
-}
-
-bool remote::Provider::Stub::requires(const cul::Provider::Requirements& r) const
-{
-    VLOG(10) << __PRETTY_FUNCTION__;
-    return throw_if_error_or_return(d->stub.object->transact_method<remote::Interface::Requires, bool>(r));
-}
-
-void remote::Provider::Stub::on_wifi_and_cell_reporting_state_changed(cul::WifiAndCellIdReportingState state)
-{
-    VLOG(10) << __PRETTY_FUNCTION__;
-    throw_if_error(d->stub.object->transact_method<remote::Interface::OnWifiAndCellIdReportingStateChanged, void>(state));
-}
-
-void remote::Provider::Stub::on_reference_location_updated(const cul::Update<cul::Position>& position)
-{
-    std::weak_ptr<Private> wp{d};
-    Runtime::instance().task.service.post([wp, position]()
-    {
-        auto sp = wp.lock();
-
-        if (not sp)
-            return;
-
-        try
-        {
-            throw_if_error(sp->stub.object->transact_method<remote::Interface::OnReferenceLocationChanged, void>(position));
-        } catch(const std::exception& e)
-        {
-            // We drop the error and just log it for post-mortem inspection.
-            LOG(WARNING) << "Transaction<remote::Interface::OnReferenceLocationChanged>: " << e.what();
-        }
-    });
-}
-
-void remote::Provider::Stub::on_reference_velocity_updated(const cul::Update<cul::Velocity>& velocity)
-{
-    std::weak_ptr<Private> wp{d};