Merge lp:~thomas-voss/location-service/minimize-exposed-header-surface into lp:location-service

[Thomas Voß]

Minimize the number of exposed headers.
Expose a new class location::Service exposing locationd's functionality.

Minimize the number of exposed headers.
Expose a new class location::Service exposing locationd's functionality.

[Simon Fels (morphis)]

LGTM

review: Approve

=== removed directory 'include/location/providers'
=== removed directory 'include/location/providers/remote'
=== removed directory 'include/location/service'
=== added file 'include/location/service.h'
--- include/location/service.h	1970-01-01 00:00:00 +0000
+++ include/location/service.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,164 @@
+/*
+ * 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_SERVICE_H_
+#define LOCATION_SERVICE_H_
+
+#include <location/space_vehicle.h>
+#include <location/heading.h>
+#include <location/position.h>
+#include <location/velocity.h>
+#include <location/update.h>
+
+#include <core/property.h>
+
+#include <chrono>
+#include <functional>
+
+namespace location
+{
+struct Criteria;
+
+/**
+ * @brief The Interface class models the primary interface to the location service.
+ */
+class Service
+{
+public:
+    // Safe us some typing.
+    typedef std::shared_ptr<Service> Ptr;
+
+    /**
+     * @brief Models a session with the location service.
+     */
+    class Session
+    {
+    public:
+        /**
+         * @brief Encapsulates updates provided for this session, and the ability to enable/disable updates.
+         */
+        struct Updates
+        {
+            /**
+             * @brief The Status enum models the possible states of updates.
+             */
+            enum class Status
+            {
+                enabled, ///< Updates are enabled and delivered to this session.
+                disabled ///< Updates are disabled and not delivered to this session.
+            };
+
+            core::Property<Update<Position>> position{};                ///< @brief Updates for position measurements.
+            core::Property<Status> position_status{Status::disabled};   ///< @brief Status of position updates, mutable.
+            core::Property<Update<Heading>> heading{};                  ///< @brief Updates for the heading measurements.
+            core::Property<Status> heading_status{Status::disabled};    ///< @brief Status of position updates, mutable.
+            core::Property<Update<Velocity>> velocity{};                ///< @brief Updates for velocity measurements.
+            core::Property<Status> velocity_status{Status::disabled};   ///< @brief Status of velocity updates, mutable.
+        };
+
+        // Safe us some typing.
+        typedef std::shared_ptr<Session> Ptr;
+
+        /** @cond */
+        Session(const Session&) = delete;
+        virtual ~Session() = default;
+        Session& operator=(const Session&) = delete;
+        /** @endcond */
+
+        /**
+         * @brief Provides access to the updates delivered for this session.
+         * @return A mutable reference to updates.
+         */
+        virtual Updates& updates() = 0;
+
+    protected:
+        Session() = default;
+    };
+
+    /// @brief State enumerates the known states of the service.
+    enum class State
+    {
+        disabled, ///< The service has been disabled by the user.
+        enabled,  ///< The service is enabled but not actively carrying out positioning.
+        active    ///< The service is actively trying to determine the position of the device.
+    };
+
+    /** @cond */
+    Service(const Service&) = delete;
+    Service& operator=(const Service&) = delete;
+    virtual ~Service() = default;
+    /** @endcond */
+
+    /**
+      * @brief The overall state of the service.
+      * @return a getable/observable property.
+      */
+    virtual const core::Property<State>& state() const = 0;
+
+    /**
+     * @brief Whether the service uses satellite-based positioning.
+     * @return  A setable/getable/observable property.
+     */
+    virtual core::Property<bool>& does_satellite_based_positioning() = 0;
+
+    /**
+     * @brief Whether the overall service and its positioning engine is online or not.
+     * @return  A setable/getable/observable property.
+     */
+    virtual core::Property<bool>& is_online() = 0;
+
+    /**
+     * @brief Whether the engine and its providers/reporters do call home to
+     * report reference locations together with wifi and cell ids.
+     *
+     * We consider this feature privacy sensitive and it defaults to false. The
+     * user has to explicitly opt-in into this feature.
+     *
+     * @return A setable/getable/observable property.
+     */
+    virtual core::Property<bool>& does_report_cell_and_wifi_ids() = 0;
+
+    /**
+      * @brief All space vehicles currently visible.
+      */
+    virtual core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() = 0;
+
+    /**
+     * @brief Starts a new session for the given criteria
+     * @throw std::runtime_error in case of errors.
+     * @param criteria The client's requirements in terms of accuraccy and functionality
+     * @return A session instance.
+     */
+    virtual Session::Ptr create_session_for_criteria(const Criteria& criteria) = 0;
+
+protected:
+    Service() = default;
+};
+
+/// @brief operator== returns true if lhs == rhs.
+bool operator==(Service::State lhs, Service::State rhs);
+/// @brief operator != returns true if !(lhs == rhs).
+bool operator!=(Service::State lhs, Service::State rhs);
+
+/// @brief operator<< inserts state into the out.
+std::ostream& operator<<(std::ostream& out, Service::State state);
+/// @brief operator>> extracts state from in.
+std::istream& operator>>(std::istream& in, Service::State& state);
+
+}
+
+#endif // LOCATION_SERVICE_H_

=== removed directory 'include/location/service/session'
=== modified file 'src/location/CMakeLists.txt'
--- src/location/CMakeLists.txt	2016-06-27 06:44:50 +0000
+++ src/location/CMakeLists.txt	2016-06-28 11:55:15 +0000
@@ -39,6 +39,18 @@
 
   boost_ptree_settings.cpp
 
+  service.cpp
+
+  dbus/skeleton/service.h
+  dbus/skeleton/service.cpp
+  dbus/skeleton/session.h
+  dbus/skeleton/session.cpp
+
+  dbus/stub/service.h
+  dbus/stub/service.cpp
+  dbus/stub/session.h
+  dbus/stub/session.cpp
+
   service/default_configuration.cpp
   service/default_permission_manager.cpp
   service/harvester.cpp

=== renamed file 'include/location/configuration.h' => 'src/location/configuration.h'
=== added directory 'src/location/dbus'
=== renamed file 'include/location/codec.h' => 'src/location/dbus/codec.h'
--- include/location/codec.h	2016-06-26 21:17:03 +0000
+++ src/location/dbus/codec.h	2016-06-28 11:55:15 +0000
@@ -25,6 +25,7 @@
 #include <location/space_vehicle.h>
 #include <location/update.h>
 #include <location/velocity.h>
+#include <location/service.h>
 #include <location/service/state.h>
 #include <location/units/units.h>
 #include <location/wgs84/altitude.h>
@@ -42,6 +43,49 @@
 namespace helper
 {
 template<>
+struct TypeMapper<location::Service::State>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::string;
+    }
+
+    constexpr static bool is_basic_type()
+    {
+        return true;
+    }
+    constexpr static bool requires_signature()
+    {
+        return false;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<std::string>::signature();
+        return s;
+    }
+};
+}
+
+template<>
+struct Codec<location::Service::State>
+{
+    static void encode_argument(Message::Writer& writer, const location::Service::State& in)
+    {
+        std::stringstream ss; ss << in; auto s = ss.str();
+        writer.push_stringn(s.c_str(), s.size());
+    }
+
+    static void decode_argument(Message::Reader& reader, location::Service::State& in)
+    {
+        auto s = reader.pop_string();
+        std::stringstream ss{s}; ss >> in;
+    }
+};
+
+namespace helper
+{
+template<>
 struct TypeMapper<location::service::State>
 {
     constexpr static ArgumentType type_value()
@@ -81,6 +125,7 @@
         std::stringstream ss{s}; ss >> in;
     }
 };
+
 namespace helper
 {
 template<typename T>

=== added file 'src/location/dbus/service.h'
--- src/location/dbus/service.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/service.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,171 @@
+/*
+ * 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_DBUS_SERVICE_H_
+#define LOCATION_DBUS_SERVICE_H_
+
+#include <location/service.h>
+#include <location/space_vehicle.h>
+
+#include <core/dbus/traits/service.h>
+#include <core/dbus/types/object_path.h>
+
+namespace location
+{
+namespace dbus
+{
+struct Service
+{
+    inline static const std::string& path()
+    {
+        static const std::string s{"/location/Service"};
+        return s;
+    }
+
+    struct Errors
+    {
+        struct InsufficientPermissions
+        {
+            inline static std::string name() { return "com.ubuntu.location.Service.Error.InsufficientPermissions";}
+        };
+        struct CreatingSession
+        {
+            inline static std::string name() { return "com.ubuntu.location.Service.Error.CreatingSession"; }
+        };
+    };
+
+    struct CreateSessionForCriteria
+    {
+        typedef dbus::Service Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"CreateSessionForCriteria"};
+            return s;
+        }
+
+        typedef core::dbus::types::ObjectPath ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout()
+        {
+            return std::chrono::seconds{25};
+        }
+    };
+
+    struct Properties
+    {
+        struct State
+        {
+            inline static const std::string& name()
+            {
+                static const std::string s{"State"};
+                return s;
+            }
+
+            typedef location::dbus::Service Interface;
+            typedef location::Service::State ValueType;
+            static const bool readable = true;
+            static const bool writable = true;
+        };
+
+        struct DoesSatelliteBasedPositioning
+        {
+            inline static const std::string& name()
+            {
+                static const std::string s{"DoesSatelliteBasedPositioning"};
+                return s;
+            }
+
+            typedef location::dbus::Service Interface;
+            typedef bool ValueType;
+            static const bool readable = true;
+            static const bool writable = true;
+        };
+
+        struct DoesReportCellAndWifiIds
+        {
+            inline static const std::string& name()
+            {
+                static const std::string s{"DoesReportCellAndWifiIds"};
+                return s;
+            }
+
+            typedef location::dbus::Service Interface;
+            typedef bool ValueType;
+            static const bool readable = true;
+            static const bool writable = true;
+        };
+
+        struct IsOnline
+        {
+            inline static const std::string& name()
+            {
+                static const std::string s{"IsOnline"};
+                return s;
+            }
+
+            typedef location::dbus::Service Interface;
+            typedef bool ValueType;
+            static const bool readable = true;
+            static const bool writable = true;
+        };
+
+        struct VisibleSpaceVehicles
+        {
+            inline static const std::string& name()
+            {
+                static const std::string s{"VisibleSpaceVehicles"};
+                return s;
+            }
+
+            typedef location::dbus::Service Interface;
+            typedef std::map<SpaceVehicle::Key, SpaceVehicle> ValueType;
+
+            static const bool readable = true;
+            static const bool writable = false;
+        };
+    };
+
+    Service() = delete;
+
+  };
+}
+}
+
+namespace core
+{
+namespace dbus
+{
+namespace traits
+{
+template<>
+struct Service<location::dbus::Service>
+{
+    static const std::string& interface_name()
+    {
+        static const std::string s
+        {
+            "com.ubuntu.location.Service"
+        };
+        return s;
+    }
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_SERVICE_H_

=== added file 'src/location/dbus/session.h'
--- src/location/dbus/session.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/session.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,204 @@
+/*
+ * 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_DBUS_SESSION_H_
+#define LOCATION_DBUS_SESSION_H_
+
+#include <chrono>
+#include <string>
+
+namespace location
+{
+namespace dbus
+{
+struct Session
+{
+    struct UpdatePosition
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"UpdatePosition"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+    };
+
+    struct UpdateVelocity
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"UpdateVelocity"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+    };
+
+    struct UpdateHeading
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"UpdateHeading"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+    };
+
+    struct StartPositionUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StartPositionUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct StopPositionUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StopPositionUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct StartVelocityUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StartVelocityUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct StopVelocityUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StopVelocityUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct StartHeadingUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StartHeadingUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct StopHeadingUpdates
+    {
+        typedef dbus::Session Interface;
+
+        inline static const std::string& name()
+        {
+            static const std::string s{"StopHeadingUpdates"};
+            return s;
+        }
+
+        typedef void ResultType;
+
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{5}; }
+    };
+
+    struct Errors
+    {
+        struct ErrorParsingUpdate
+        {
+            inline static std::string name(){return "com.ubuntu.location.Service.Session.ErrorParsingUpdate";}
+        };
+
+        struct ErrorStartingUpdate
+        {
+            inline static std::string name(){return "com.ubuntu.location.Service.Session.ErrorStartingUpdate";}
+        };
+    };
+};
+}
+}
+
+namespace core
+{
+namespace dbus
+{
+namespace traits
+{
+template<>
+struct Service<location::dbus::Session>
+{
+    static const std::string& interface_name()
+    {
+        static const std::string s
+        {
+            "com.ubuntu.location.Service.Session"
+        };
+        return s;
+    }
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_SESSION_H_

=== added directory 'src/location/dbus/skeleton'
=== added file 'src/location/dbus/skeleton/service.cpp'
--- src/location/dbus/skeleton/service.cpp	1970-01-01 00:00:00 +0000
+++ src/location/dbus/skeleton/service.cpp	2016-06-28 11:55:15 +0000
@@ -0,0 +1,308 @@
+/*
+ * 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/dbus/skeleton/service.h>
+#include <location/dbus/skeleton/session.h>
+
+#include <location/dbus/codec.h>
+
+#include <location/criteria.h>
+#include <location/logging.h>
+
+namespace
+{
+const std::vector<std::string>& the_empty_array_of_invalidated_properties()
+{
+    static const std::vector<std::string> v; return v;
+}
+
+core::dbus::Message::Ptr the_empty_reply()
+{
+    return core::dbus::Message::Ptr{};
+}
+}
+
+location::dbus::skeleton::Service::DBusDaemonCredentialsResolver::DBusDaemonCredentialsResolver(const core::dbus::Bus::Ptr& bus)
+    : daemon(bus)
+{
+}
+
+location::service::Credentials
+location::dbus::skeleton::Service::DBusDaemonCredentialsResolver::resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg)
+{
+    return location::service::Credentials
+    {
+        static_cast<pid_t>(daemon.get_connection_unix_process_id(msg->sender())),
+        static_cast<uid_t>(daemon.get_connection_unix_user(msg->sender()))
+    };
+}
+
+core::dbus::types::ObjectPath location::dbus::skeleton::Service::ObjectPathGenerator::object_path_for_caller_credentials(const location::service::Credentials&)
+{
+    static std::uint32_t index{0};
+    std::stringstream ss; ss << "/sessions/" << index++;
+
+    return core::dbus::types::ObjectPath{ss.str()};
+}
+
+
+location::dbus::skeleton::Service::Service(const location::dbus::skeleton::Service::Configuration& configuration)
+    : configuration(configuration),
+      daemon(configuration.incoming),
+      object(configuration.service->add_object_for_path(location::dbus::Service::path())),
+      properties_changed(object->get_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged>()),
+      properties
+      {
+          object->get_property<location::dbus::Service::Properties::State>(),
+          object->get_property<location::dbus::Service::Properties::DoesSatelliteBasedPositioning>(),
+          object->get_property<location::dbus::Service::Properties::DoesReportCellAndWifiIds>(),
+          object->get_property<location::dbus::Service::Properties::IsOnline>(),
+          object->get_property<location::dbus::Service::Properties::VisibleSpaceVehicles>()
+      },
+      connections
+      {
+          properties.state->changed().connect([this](State state)
+          {
+              on_state_changed(state);
+          }),
+          properties.does_satellite_based_positioning->changed().connect([this](bool value)
+          {
+              on_does_satellite_based_positioning_changed(value);
+          }),
+          properties.does_report_cell_and_wifi_ids->changed().connect([this](bool value)
+          {
+              on_does_report_cell_and_wifi_ids_changed(value);
+          }),
+          properties.is_online->changed().connect([this](bool value)
+          {
+              on_is_online_changed(value);
+          })
+      }
+{
+    object->install_method_handler<location::dbus::Service::CreateSessionForCriteria>([this](const core::dbus::Message::Ptr& msg)
+    {
+        handle_create_session_for_criteria(msg);
+    });
+}
+
+location::dbus::skeleton::Service::~Service() noexcept
+{
+    object->uninstall_method_handler<location::dbus::Service::CreateSessionForCriteria>();
+}
+
+core::Property<location::Service::State>& location::dbus::skeleton::Service::mutable_state()
+{
+    return *properties.state;
+}
+
+void location::dbus::skeleton::Service::handle_create_session_for_criteria(const core::dbus::Message::Ptr& in)
+{
+    VLOG(1) << __PRETTY_FUNCTION__;
+
+    auto sender = in->sender();
+    auto reply = the_empty_reply();
+    auto thiz = shared_from_this();
+
+    try
+    {
+        Criteria criteria;
+        in->reader() >> criteria;
+
+        auto credentials =
+            configuration.credentials_resolver->resolve_credentials_for_incoming_message(in);
+
+        auto result =
+            configuration.permission_manager->check_permission_for_credentials(criteria, credentials);
+
+        if (service::PermissionManager::Result::rejected == result) throw std::runtime_error
+        {
+            "Client lacks permissions to access the service with the given criteria"
+        };
+
+        auto path =
+            configuration.object_path_generator->object_path_for_caller_credentials(credentials);
+
+        auto stub =
+            core::dbus::Service::use_service(configuration.outgoing, sender);
+
+        location::dbus::skeleton::Session::Configuration config
+        {
+            path,
+            location::dbus::skeleton::Session::Local
+            {
+                create_session_for_criteria(criteria),
+                configuration.incoming,
+                configuration.service->add_object_for_path(path)
+            },
+            location::dbus::skeleton::Session::Remote
+            {
+                stub->object_for_path(path)
+            }
+        };
+
+        auto watcher = daemon.make_service_watcher(sender);
+        watcher->owner_changed().connect([thiz, path](const std::string&, const std::string&)
+        {
+            thiz->remove_from_session_store_for_path(path);
+        });
+
+        if (not add_to_session_store_for_path(path, std::move(watcher), std::make_shared<location::dbus::skeleton::Session>(config)))
+        {
+            reply = core::dbus::Message::make_error(
+                        in,
+                        location::dbus::Service::Errors::CreatingSession::name(),
+                        "Refused to create second session for same process");
+        } else
+        {
+            reply = core::dbus::Message::make_method_return(in);
+            reply->writer() << path;
+        }
+
+    } catch(const std::exception& e)
+    {
+        // We only send a very generic error message to the client to avoid
+        // leaking any sort of internal error handling details to untrusted
+        // apps.
+        reply = core::dbus::Message::make_error(
+                    in,
+                    location::dbus::Service::Errors::CreatingSession::name(),
+                    "Error creating session");
+        // We log the error for debugging purposes.
+        SYSLOG(ERROR) << "Error creating session: " << e.what();
+    }
+
+    // We are done processing the request and try to send out the result to the client.
+    try
+    {
+        configuration.incoming->send(reply);
+    } catch(const std::exception& e)
+    {
+        // We log the error for debugging purposes.
+        SYSLOG(ERROR) << "Error sending reply to session creation request: " << e.what();
+    }
+}
+
+bool location::dbus::skeleton::Service::add_to_session_store_for_path(
+        const core::dbus::types::ObjectPath& path,
+        std::unique_ptr<core::dbus::ServiceWatcher> watcher,
+        const Session::Ptr& session)
+{
+    std::lock_guard<std::mutex> lg(guard);
+    bool inserted = false;
+    std::tie(std::ignore, inserted) = session_store.insert(std::make_pair(path, Element{std::move(watcher), session}));
+    return inserted;
+}
+
+void location::dbus::skeleton::Service::remove_from_session_store_for_path(const core::dbus::types::ObjectPath& path)
+{
+    std::lock_guard<std::mutex> lg(guard);
+    session_store.erase(path);
+}
+
+void location::dbus::skeleton::Service::on_state_changed(location::Service::State state)
+{
+    std::map<std::string, core::dbus::types::Variant> dict
+    {
+        {
+            location::dbus::Service::Properties::State::name(),
+            core::dbus::types::Variant::encode(state)
+        }
+    };
+
+    properties_changed->emit(
+                std::tie(
+                    core::dbus::traits::Service<location::dbus::Service>::interface_name(),
+                    dict,
+                    the_empty_array_of_invalidated_properties()));
+}
+
+
+void location::dbus::skeleton::Service::on_does_satellite_based_positioning_changed(bool value)
+{
+    std::map<std::string, core::dbus::types::Variant> dict
+    {
+        {
+            location::dbus::Service::Properties::DoesSatelliteBasedPositioning::name(),
+            core::dbus::types::Variant::encode(value)
+        }
+    };
+
+    properties_changed->emit(
+                std::tie(
+                    core::dbus::traits::Service<location::dbus::Service>::interface_name(),
+                    dict,
+                    the_empty_array_of_invalidated_properties()));
+}
+
+void location::dbus::skeleton::Service::on_does_report_cell_and_wifi_ids_changed(bool value)
+{
+    std::map<std::string, core::dbus::types::Variant> dict
+    {
+        {
+            location::dbus::Service::Properties::DoesReportCellAndWifiIds::name(),
+            core::dbus::types::Variant::encode(value)
+        }
+    };
+
+    properties_changed->emit(
+            std::tie(
+                core::dbus::traits::Service<location::dbus::Service>::interface_name(),
+                dict,
+                the_empty_array_of_invalidated_properties()));
+}
+
+void location::dbus::skeleton::Service::on_is_online_changed(bool value)
+{
+    std::map<std::string, core::dbus::types::Variant> dict
+    {
+        {
+            location::dbus::Service::Properties::IsOnline::name(),
+            core::dbus::types::Variant::encode(value)
+        }
+    };
+    properties_changed->emit(
+            std::tie(
+                core::dbus::traits::Service<location::dbus::Service>::interface_name(),
+                dict,
+                the_empty_array_of_invalidated_properties()));
+}
+
+const core::Property<location::Service::State>& location::dbus::skeleton::Service::state() const
+{
+    return *properties.state;
+}
+
+core::Property<bool>& location::dbus::skeleton::Service::does_satellite_based_positioning()
+{
+    return *properties.does_satellite_based_positioning;
+}
+
+core::Property<bool>& location::dbus::skeleton::Service::does_report_cell_and_wifi_ids()
+{
+    return *properties.does_report_cell_and_wifi_ids;
+}
+
+core::Property<bool>& location::dbus::skeleton::Service::is_online()
+{
+    return *properties.is_online;
+}
+
+core::Property<std::map<location::SpaceVehicle::Key, location::SpaceVehicle>>& location::dbus::skeleton::Service::visible_space_vehicles()
+{
+    return *properties.visible_space_vehicles;
+}

=== added file 'src/location/dbus/skeleton/service.h'
--- src/location/dbus/skeleton/service.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/skeleton/service.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,195 @@
+/*
+ * 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_DBUS_SKELETON_SERVICE_H_
+#define LOCATION_DBUS_SKELETON_SERVICE_H_
+
+#include <location/service.h>
+
+#include <location/dbus/service.h>
+
+#include <location/service/permission_manager.h>
+
+#include <core/dbus/dbus.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
+#include <core/dbus/service_watcher.h>
+#include <core/dbus/skeleton.h>
+
+#include <core/dbus/interfaces/properties.h>
+
+namespace location
+{
+namespace dbus
+{
+namespace skeleton
+{
+class Service
+        : public location::Service,
+          public std::enable_shared_from_this<Service>
+{
+public:
+    typedef std::shared_ptr<Service> Ptr;
+
+    // Models resolution of an incoming dbus message to the credentials of the message sender.
+    struct CredentialsResolver
+    {
+        typedef std::shared_ptr<CredentialsResolver> Ptr;
+
+        CredentialsResolver() = default;
+        virtual ~CredentialsResolver() = default;
+
+        // Resolves the sender of msg to the respective credentials.
+        virtual service::Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg) = 0;
+    };
+
+    // Implements CredentialsResolver by reaching out to the dbus daemon and
+    // invoking:
+    //   * GetConnectionUnixProcessID
+    //   * GetConnectionUnixUser
+    struct DBusDaemonCredentialsResolver : public CredentialsResolver
+    {
+        // Sets up a new instance for the given bus connection.
+        DBusDaemonCredentialsResolver(const core::dbus::Bus::Ptr& bus);
+
+        // Resolves the sender of msg to pid, uid by calling out to the dbus daemon.
+        service::Credentials resolve_credentials_for_incoming_message(const core::dbus::Message::Ptr& msg);
+
+        // Stub for accessing the dbus daemon.
+        core::dbus::DBus daemon;
+    };
+
+    // Models the generation of stable and unique object paths for client-specific sessions.
+    // The requirements for the resulting object path are:
+    //   * Unique for the entire system over its complete lifetime
+    //   * Stable with respect to an app. That is, one app is always assigned the same object path.
+    struct ObjectPathGenerator
+    {
+        typedef std::shared_ptr<ObjectPathGenerator> Ptr;
+
+        ObjectPathGenerator() = default;
+        virtual ~ObjectPathGenerator() = default;
+
+        // Calculates an object path from pid and uid. The default implementation
+        // creates the path according to the following steps:
+        //    [1.] Query the AppArmor profile name for pid in credentials.
+        //    [1.1] If the process is running unconfined, rely on a counter to assemble the session name.
+        //    [1.2] If the process is confined, use the AppArmor profile name to generate the path.
+        virtual core::dbus::types::ObjectPath object_path_for_caller_credentials(const service::Credentials& credentials);
+    };
+
+    struct Configuration
+    {
+        // DBus connection set up for handling requests to the service.
+        core::dbus::Bus::Ptr incoming;
+        // DBus connection for reaching out to other services in a non-blocking way.
+        core::dbus::Bus::Ptr outgoing;
+        // Service instance that the skeleton should be exposed upon.
+        core::dbus::Service::Ptr service;
+        // An implementation of CredentialsResolver for resolving incoming message sender
+        // to Credentials = uid, pid.
+        CredentialsResolver::Ptr credentials_resolver;
+        // An implementation of ObjectPathGenerator for generating session names.
+        ObjectPathGenerator::Ptr object_path_generator;
+        // Permission manager implementation for verifying incoming requests.
+        service::PermissionManager::Ptr permission_manager;
+    };
+
+    Service(const Configuration& configuration);
+    ~Service() noexcept;
+
+    // From location::service::Interface
+    const core::Property<State>& state() const;
+    core::Property<bool>& does_satellite_based_positioning();
+    core::Property<bool>& does_report_cell_and_wifi_ids();
+    core::Property<bool>& is_online();
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles();
+
+protected:
+    // Enable subclasses to alter the state.
+    core::Property<State>& mutable_state();
+private:
+    // Handles incoming message calls for create_session_for_criteria.
+    // Dispatches to the actual implementation, and manages object lifetimes.
+    void handle_create_session_for_criteria(const core::dbus::Message::Ptr& msg);
+
+    // Tries to register the given session under the given path in the session store.
+    // Returns true iff the session has been added to the store.
+    bool add_to_session_store_for_path(
+            const core::dbus::types::ObjectPath& path,
+            std::unique_ptr<core::dbus::ServiceWatcher> watcher,
+            const Session::Ptr& session);
+
+    // Removes the session with the given path from the session store.
+    void remove_from_session_store_for_path(const core::dbus::types::ObjectPath& path);
+
+    // Called whenever the overall state of the service changes.
+    void on_state_changed(State state);
+    // Called whenever the value of the respective property changes.
+    void on_does_satellite_based_positioning_changed(bool value);
+    // Called whenever the value of the respective property changes.
+    void on_does_report_cell_and_wifi_ids_changed(bool value);
+    // Called whenever the value of the respective property changes.
+    void on_is_online_changed(bool value);
+
+    // Stores the configuration passed in at creation time.
+    Configuration configuration;
+    // We observe sessions if they have died and resigned from the bus.
+    core::dbus::DBus daemon;
+    // The skeleton object representing com.ubuntu.location.service.Interface on the bus.
+    core::dbus::Object::Ptr object;
+    // We emit property changes manually.
+    core::dbus::Signal
+    <
+        core::dbus::interfaces::Properties::Signals::PropertiesChanged,
+        core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType
+    >::Ptr properties_changed;
+
+    // DBus properties as exposed on the bus for com.ubuntu.location.service.Interface
+    struct
+    {
+        std::shared_ptr< core::dbus::Property<location::dbus::Service::Properties::State> > state;
+        std::shared_ptr< core::dbus::Property<location::dbus::Service::Properties::DoesSatelliteBasedPositioning> > does_satellite_based_positioning;
+        std::shared_ptr< core::dbus::Property<location::dbus::Service::Properties::DoesReportCellAndWifiIds> > does_report_cell_and_wifi_ids;
+        std::shared_ptr< core::dbus::Property<location::dbus::Service::Properties::IsOnline> > is_online;
+        std::shared_ptr< core::dbus::Property<location::dbus::Service::Properties::VisibleSpaceVehicles> > visible_space_vehicles;
+    } properties;
+    // We sign up to property changes here, to be able to report them to the bus
+    struct
+    {
+        core::ScopedConnection state;
+        core::ScopedConnection does_satellite_based_positioning;
+        core::ScopedConnection does_report_cell_and_wifi_ids;
+        core::ScopedConnection is_online;
+    } connections;
+    // Guards the session store.
+    std::mutex guard;
+    // We track sessions and their respective watchers.
+    struct Element
+    {
+        std::unique_ptr<core::dbus::ServiceWatcher> watcher;
+        std::shared_ptr<location::Service::Session> session;
+    };
+    // Keeps track of running sessions, keying them by their unique object path.
+    std::map<core::dbus::types::ObjectPath, Element> session_store;
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_SKELETON_SERVICE_H_

=== added file 'src/location/dbus/skeleton/session.cpp'
--- src/location/dbus/skeleton/session.cpp	1970-01-01 00:00:00 +0000
+++ src/location/dbus/skeleton/session.cpp	2016-06-28 11:55:15 +0000
@@ -0,0 +1,346 @@
+/*
+ * 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/dbus/skeleton/session.h>
+
+#include <location/dbus/codec.h>
+#include <location/dbus/session.h>
+
+#include <location/logging.h>
+
+#include <functional>
+
+namespace
+{
+core::dbus::Message::Ptr the_empty_reply()
+{
+    return core::dbus::Message::Ptr{};
+}
+}
+
+location::dbus::skeleton::Session::Session(const location::dbus::skeleton::Session::Configuration& config)
+        : configuration(config),
+          connections
+          {
+              configuration.local.impl->updates().position.changed().connect(
+                  [this](const location::Update<location::Position>& position)
+                  {
+                      on_position_changed(position);
+                  }),
+              configuration.local.impl->updates().heading.changed().connect(
+                  [this](const location::Update<location::Heading>& heading)
+                  {
+                      on_heading_changed(heading);
+                  }),
+              configuration.local.impl->updates().velocity.changed().connect(
+                  [this](const location::Update<location::Velocity>& velocity)
+                  {
+                      on_velocity_changed(velocity);
+                  })
+          }
+{
+    configuration.local.object->install_method_handler<location::dbus::Session::StartPositionUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_start_position_updates(msg);
+    });
+
+    configuration.local.object->install_method_handler<location::dbus::Session::StopPositionUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_stop_position_updates(msg);
+    });
+
+    configuration.local.object->install_method_handler<location::dbus::Session::StartVelocityUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_start_velocity_updates(msg);
+    });
+
+    configuration.local.object->install_method_handler<location::dbus::Session::StopVelocityUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_stop_velocity_updates(msg);
+    });
+
+    configuration.local.object->install_method_handler<location::dbus::Session::StartHeadingUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_start_heading_updates(msg);
+    });
+
+    configuration.local.object->install_method_handler<location::dbus::Session::StopHeadingUpdates>([this](const core::dbus::Message::Ptr& msg)
+    {
+        on_stop_heading_updates(msg);
+    });
+}
+
+location::dbus::skeleton::Session::~Session() noexcept
+{
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StartPositionUpdates>();
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StopPositionUpdates>();
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StartVelocityUpdates>();
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StopVelocityUpdates>();
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StartHeadingUpdates>();
+    configuration.local.object->uninstall_method_handler<location::dbus::Session::StopHeadingUpdates>();
+}
+
+void location::dbus::skeleton::Session::on_start_position_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StartPositionUpdates";
+
+    auto reply = the_empty_reply();
+
+    try
+    {
+        configuration.local.impl->updates().position_status = Updates::Status::enabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not enable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+void location::dbus::skeleton::Session::on_stop_position_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StopPositionUpdates";
+    auto reply = the_empty_reply();
+
+    try
+    {
+        configuration.local.impl->updates().position_status = Updates::Status::disabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not disable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+void location::dbus::skeleton::Session::on_start_heading_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StartHeadingUpdates";
+    auto reply = the_empty_reply();
+
+    try
+    {
+        configuration.local.impl->updates().position_status = Updates::Status::enabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not enable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+void location::dbus::skeleton::Session::on_stop_heading_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StopHeadingUpdates";
+    auto reply = the_empty_reply();
+    try
+    {
+        configuration.local.impl->updates().heading_status = Updates::Status::disabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not enable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+void location::dbus::skeleton::Session::on_start_velocity_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StartVelocityUpdates";
+    auto reply = the_empty_reply();
+    try
+    {
+        configuration.local.impl->updates().velocity_status = Updates::Status::enabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not enable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+void location::dbus::skeleton::Session::on_stop_velocity_updates(const core::dbus::Message::Ptr& msg)
+{
+    VLOG(10) << "MethodHandler for location::dbus::Session::StopVelocityUpdates";
+    auto reply = the_empty_reply();
+    try
+    {
+        configuration.local.impl->updates().velocity_status = Updates::Status::disabled;
+        reply = core::dbus::Message::make_method_return(msg);
+    } catch(const std::runtime_error& e)
+    {
+        // We only provide a generic error message to avoid leaking
+        // any sort of private data to unprivileged clients.
+        reply = core::dbus::Message::make_error(
+                    msg,
+                    location::dbus::Session::Errors::ErrorStartingUpdate::name(),
+                    "Could not enable position updates");
+        SYSLOG(ERROR) << e.what();
+    }
+
+    try
+    {
+        configuration.local.bus->send(reply);
+    } catch(const std::exception& e)
+    {
+        SYSLOG(ERROR) << e.what();
+    }
+}
+
+// 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)
+        {
+            if (result.is_error())
+            {
+                VLOG(10) << "Failed to communicate position update to client: " << result.error().print();
+            }
+        }, position);
+    } catch(const std::exception&)
+    {
+        // We consider the session to be dead once we hit an exception here.
+        // We thus remove it from the central and end its lifetime.
+        // on_session_died();
+    } catch(...)
+    {
+    }
+}
+
+// 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)
+        {
+            if (result.is_error())
+            {
+                VLOG(10) << "Failed to communicate heading update to client: " << result.error().print();
+            }
+        }, heading);
+    } catch(const std::exception&)
+    {
+        // We consider the session to be dead once we hit an exception here.
+        // We thus remove it from the central and end its lifetime.
+        //on_session_died();
+    } catch(...)
+    {
+    }
+}
+
+// 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)
+        {
+            if (result.is_error())
+            {
+                VLOG(10) << "Failed to communicate velocity update to client: " << result.error().print();
+            }
+        }, velocity);
+    } catch(const std::exception&)
+    {
+        // We consider the session to be dead once we hit an exception here.
+        // We thus remove it from the central and end its lifetime.
+        // on_session_died();
+    } catch(...)
+    {
+    }
+}
+
+const core::dbus::types::ObjectPath& location::dbus::skeleton::Session::path() const
+{
+    return configuration.path;
+}
+
+location::Service::Session::Updates& location::dbus::skeleton::Session::updates()
+{
+    return configuration.local.impl->updates();
+}

=== added file 'src/location/dbus/skeleton/session.h'
--- src/location/dbus/skeleton/session.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/skeleton/session.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,118 @@
+/*
+ * 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_DBUS_SKELETON_SESSION_H_
+#define LOCATION_DBUS_SKELETON_SESSION_H_
+
+#include <location/service.h>
+
+#include <location/heading.h>
+#include <location/position.h>
+#include <location/provider.h>
+#include <location/update.h>
+#include <location/velocity.h>
+
+#include <core/dbus/message.h>
+#include <core/dbus/object.h>
+
+#include <memory>
+
+namespace location
+{
+namespace dbus
+{
+namespace skeleton
+{
+class Session : public location::Service::Session
+{
+public:
+    // All local, i.e., in-process creation-time properties of the Skeleton.
+    struct Local
+    {
+        // The actual implementation of location::service::session::Interface.
+        Session::Ptr impl;
+        // The bus connection that the object is exposed upon.
+        core::dbus::Bus::Ptr bus;
+        // The object that the skeleton is mounted upon.
+        core::dbus::Object::Ptr object;
+    };
+
+    // We communicate position, heading and velocity updates to the client
+    // via an explicit function call. The reason is simple: We want to know
+    // whether the client is still alive and responding as expected to make sure
+    // that we stop positioning as early as possible.
+    struct Remote
+    {
+        // The remote object corresponding to the client, implementing
+        // com.ubuntu.location.service.session.Interface
+        core::dbus::Object::Ptr object;
+    };
+
+    struct Configuration
+    {
+        // The object path of the session object, shared between clients and service.
+        core::dbus::types::ObjectPath path;
+        // Local attributes
+        Local local;
+        // Remote attributes
+        Remote remote;
+    };
+
+    Session(const Configuration& configuration);
+    virtual ~Session() noexcept;
+
+    virtual const core::dbus::types::ObjectPath& path() const;
+
+    // From Service::Session
+    Updates& updates() override;
+
+private:
+    // Handle incoming requests for Start/StopPositionUpdates
+    virtual void on_start_position_updates(const core::dbus::Message::Ptr&);
+    virtual void on_stop_position_updates(const core::dbus::Message::Ptr&);
+    // Handles incoming requests for Start/StopHeadingUpdates
+    virtual void on_start_heading_updates(const core::dbus::Message::Ptr&);
+    virtual void on_stop_heading_updates(const core::dbus::Message::Ptr&);
+    // Handles incoming requests for Start/StopVelocityUpdates
+    virtual void on_start_velocity_updates(const core::dbus::Message::Ptr&);
+    virtual void on_stop_velocity_updates(const core::dbus::Message::Ptr&);
+
+    // Invoked whenever the actual session impl. for the session reports a position update.
+    virtual void on_position_changed(const Update<Position>& position);
+    // Invoked whenever the actual session impl. reports a heading update.
+    virtual void on_heading_changed(const Update<Heading>& heading);
+    // Invoked whenever the actual session impl. reports a velocity update.
+    virtual void on_velocity_changed(const Update<Velocity>& velocity);
+
+    // Stores all attributes passed at creation time.
+    Configuration configuration;
+    // Scoped connections for automatically disconnecting on destruction
+    struct
+    {
+        // Corresponds to position updates coming in from the actual implementation instance.
+        core::ScopedConnection position_changed;
+        // Corresponds to heading updates coming in from the actual implementation instance.
+        core::ScopedConnection heading_changed;
+        // Corresponds to velocity updates coming in from the actual implementation instance.
+        core::ScopedConnection velocity_changed;
+    } connections;
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_SKELETON_SESSION_H_

=== added directory 'src/location/dbus/stub'
=== added file 'src/location/dbus/stub/service.cpp'
--- src/location/dbus/stub/service.cpp	1970-01-01 00:00:00 +0000
+++ src/location/dbus/stub/service.cpp	2016-06-28 11:55:15 +0000
@@ -0,0 +1,82 @@
+/*
+ * 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/dbus/stub/service.h>
+#include <location/dbus/stub/session.h>
+
+#include <location/dbus/codec.h>
+#include <location/dbus/service.h>
+
+#include <location/logging.h>
+
+#include <core/dbus/property.h>
+
+location::dbus::stub::Service::Service(const core::dbus::Bus::Ptr& connection,
+                                       const core::dbus::Service::Ptr& service,
+                                       const core::dbus::Object::Ptr& object) :
+    connection{connection},
+    service{service},
+    object{object},
+    state_{object->get_property<location::dbus::Service::Properties::State>()},
+    does_satellite_based_positioning_{object->get_property<location::dbus::Service::Properties::DoesSatelliteBasedPositioning>()},
+    does_report_cell_and_wifi_ids_{object->get_property<location::dbus::Service::Properties::DoesReportCellAndWifiIds>()},
+    is_online_{object->get_property<location::dbus::Service::Properties::IsOnline>()},
+    visible_space_vehicles_{object->get_property<location::dbus::Service::Properties::VisibleSpaceVehicles>()}
+{
+}
+
+location::Service::Session::Ptr location::dbus::stub::Service::create_session_for_criteria(const location::Criteria& criteria)
+{
+    auto op = object->transact_method<
+            location::dbus::Service::CreateSessionForCriteria,
+            location::dbus::Service::CreateSessionForCriteria::ResultType
+            >(criteria);
+
+    if (op.is_error())
+    {
+        std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << op.error().print();
+        throw std::runtime_error(ss.str());
+    }
+
+    return std::make_shared<location::dbus::stub::Session>(connection, service->add_object_for_path(op.value()));
+}
+
+const core::Property<location::Service::State>& location::dbus::stub::Service::state() const
+{
+    return *state_;
+}
+
+core::Property<bool>& location::dbus::stub::Service::does_satellite_based_positioning()
+{
+    return *does_satellite_based_positioning_;
+}
+
+core::Property<bool>& location::dbus::stub::Service::does_report_cell_and_wifi_ids()
+{
+    return *does_report_cell_and_wifi_ids_;
+}
+
+core::Property<bool>& location::dbus::stub::Service::is_online()
+{
+    return *is_online_;
+}
+
+core::Property<std::map<location::SpaceVehicle::Key, location::SpaceVehicle>>& location::dbus::stub::Service::visible_space_vehicles()
+{
+    return *visible_space_vehicles_;
+}

=== added file 'src/location/dbus/stub/service.h'
--- src/location/dbus/stub/service.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/stub/service.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,65 @@
+/*
+ * 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_DBUS_STUB_SERVICE_H_
+#define LOCATION_DBUS_STUB_SERVICE_H_
+
+#include <location/service.h>
+
+#include <location/dbus/service.h>
+
+#include <core/dbus/bus.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
+#include <core/dbus/service.h>
+
+namespace location
+{
+namespace dbus
+{
+namespace stub
+{
+class Service : public location::Service
+{
+  public:
+    Service(const core::dbus::Bus::Ptr& connection,
+            const core::dbus::Service::Ptr& service,
+            const core::dbus::Object::Ptr& object);
+
+    Session::Ptr create_session_for_criteria(const Criteria& criteria) override;
+    const core::Property<State>& state() const override;
+    core::Property<bool>& does_satellite_based_positioning() override;
+    core::Property<bool>& does_report_cell_and_wifi_ids() override;
+    core::Property<bool>& is_online() override;
+    core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>>& visible_space_vehicles() override;
+
+  private:
+    core::dbus::Bus::Ptr connection;
+    core::dbus::Service::Ptr service;
+    core::dbus::Object::Ptr object;
+
+    std::shared_ptr<core::dbus::Property<location::dbus::Service::Properties::State>> state_;
+    std::shared_ptr<core::dbus::Property<location::dbus::Service::Properties::DoesSatelliteBasedPositioning>> does_satellite_based_positioning_;
+    std::shared_ptr<core::dbus::Property<location::dbus::Service::Properties::DoesReportCellAndWifiIds>> does_report_cell_and_wifi_ids_;
+    std::shared_ptr<core::dbus::Property<location::dbus::Service::Properties::IsOnline>> is_online_;
+    std::shared_ptr<core::dbus::Property<location::dbus::Service::Properties::VisibleSpaceVehicles>> visible_space_vehicles_;
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_STUB_SERVICE_H_

=== added file 'src/location/dbus/stub/session.cpp'
--- src/location/dbus/stub/session.cpp	1970-01-01 00:00:00 +0000
+++ src/location/dbus/stub/session.cpp	2016-06-28 11:55:15 +0000
@@ -0,0 +1,215 @@
+/*
+ * 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/dbus/stub/session.h>
+#include <location/dbus/codec.h>
+#include <location/dbus/session.h>
+
+#include <location/logging.h>
+
+location::dbus::stub::Session::Session(const core::dbus::Bus::Ptr& connection,
+                                       const core::dbus::Object::Ptr& object)
+        : connection_{connection},
+          object_{object},
+          position_{updates_.position_status.changed().connect([this](const Updates::Status& status)
+          {
+              switch(status)
+              {
+              case Updates::Status::enabled: start_position_updates(); break;
+              case Updates::Status::disabled: stop_position_updates(); break;
+              }
+          })},
+          velocity_{updates_.velocity_status.changed().connect([this](const Updates::Status& status)
+          {
+              switch(status)
+              {
+              case Updates::Status::enabled: start_velocity_updates(); break;
+              case Updates::Status::disabled: stop_velocity_updates(); break;
+              }
+          })},
+          heading_{updates_.heading_status.changed().connect([this](const Updates::Status& status)
+          {
+              switch(status)
+              {
+              case Updates::Status::enabled: start_heading_updates(); break;
+              case Updates::Status::disabled: stop_heading_updates(); break;
+              }
+          })}
+{
+    object_->install_method_handler<location::dbus::Session::UpdatePosition>([this](const core::dbus::Message::Ptr& incoming)
+    {
+        VLOG(10) << __PRETTY_FUNCTION__;
+
+        try
+        {
+            Update<Position> update; incoming->reader() >> update;
+            updates_.position = update;
+            connection_->send(core::dbus::Message::make_method_return(incoming));
+        } catch(const std::runtime_error& e)
+        {
+            connection_->send(core::dbus::Message::make_error(
+                                  incoming,
+                                  location::dbus::Session::Errors::ErrorParsingUpdate::name(),
+                                  e.what()));
+        }
+    });
+
+    object_->install_method_handler<location::dbus::Session::UpdateHeading>([this](const core::dbus::Message::Ptr& incoming)
+    {
+        VLOG(10) << __PRETTY_FUNCTION__;
+
+        try
+        {
+            Update<Heading> update; incoming->reader() >> update;
+            updates_.heading = update;
+            connection_->send(core::dbus::Message::make_method_return(incoming));
+        } catch(const std::runtime_error& e)
+        {
+            connection_->send(core::dbus::Message::make_error(
+                                  incoming,
+                                  location::dbus::Session::Errors::ErrorParsingUpdate::name(),
+                                  e.what()));
+        }
+    });
+
+    object_->install_method_handler<location::dbus::Session::UpdateVelocity>([this](const core::dbus::Message::Ptr& incoming)
+    {
+        VLOG(10) << __PRETTY_FUNCTION__;
+
+        try
+        {
+            Update<Velocity> update; incoming->reader() >> update;
+            updates_.velocity = update;
+            connection_->send(core::dbus::Message::make_method_return(incoming));
+        } catch(const std::runtime_error& e)
+        {
+            connection_->send(core::dbus::Message::make_error(
+                                  incoming,
+                                  location::dbus::Session::Errors::ErrorParsingUpdate::name(),
+                                  e.what()));
+        }
+    });
+}
+
+location::dbus::stub::Session::~Session() noexcept
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    object_->uninstall_method_handler<location::dbus::Session::UpdatePosition>();
+    object_->uninstall_method_handler<location::dbus::Session::UpdateHeading>();
+    object_->uninstall_method_handler<location::dbus::Session::UpdateVelocity>();
+}
+
+void location::dbus::stub::Session::start_position_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    auto result = object_->transact_method<location::dbus::Session::StartPositionUpdates,void>();
+
+    if (result.is_error())
+    {
+        std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+        throw std::runtime_error(ss.str());
+    }
+}
+
+void location::dbus::stub::Session::stop_position_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    try
+    {
+        auto result = object_->invoke_method_synchronously<location::dbus::Session::StopPositionUpdates,void>();
+
+        if (result.is_error())
+        {
+            std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+            throw std::runtime_error(ss.str());
+        }
+    } catch(const std::runtime_error& e)
+    {
+        VLOG(1) << e.what();
+    }
+}
+
+void location::dbus::stub::Session::start_velocity_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    auto result = object_->transact_method<location::dbus::Session::StartVelocityUpdates,void>();
+
+    if (result.is_error())
+    {
+        std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+        throw std::runtime_error(ss.str());
+    }
+}
+
+void location::dbus::stub::Session::stop_velocity_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    try {
+        auto result = object_->transact_method<location::dbus::Session::StopVelocityUpdates,void>();
+
+        if (result.is_error())
+        {
+            std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+            throw std::runtime_error(ss.str());
+        }
+    } catch(const std::runtime_error& e)
+    {
+        VLOG(1) << e.what();
+    }
+}
+
+void location::dbus::stub::Session::start_heading_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    auto result = object_->transact_method<location::dbus::Session::StartHeadingUpdates,void>();
+
+    if (result.is_error())
+    {
+        std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+        throw std::runtime_error(ss.str());
+    }
+}
+
+void location::dbus::stub::Session::stop_heading_updates()
+{
+    VLOG(10) << __PRETTY_FUNCTION__;
+
+    try {
+        auto result = object_->transact_method<location::dbus::Session::StopHeadingUpdates,void>();
+
+        if (result.is_error())
+        {
+            std::stringstream ss; ss << __PRETTY_FUNCTION__ << ": " << result.error().print();
+            throw std::runtime_error(ss.str());
+        }
+    } catch(const std::runtime_error& e)
+    {
+        VLOG(1) << e.what();
+    }
+}
+
+location::Service::Session::Updates& location::dbus::stub::Session::updates()
+{
+    return updates_;
+}

=== added file 'src/location/dbus/stub/session.h'
--- src/location/dbus/stub/session.h	1970-01-01 00:00:00 +0000
+++ src/location/dbus/stub/session.h	2016-06-28 11:55:15 +0000
@@ -0,0 +1,72 @@
+/*
+ * 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_DBUS_STUB_SESSION_H_
+#define LOCATION_DBUS_STUB_SESSION_H_
+
+#include <location/service.h>
+
+#include <location/heading.h>
+#include <location/position.h>
+#include <location/provider.h>
+#include <location/update.h>
+#include <location/velocity.h>
+
+#include <core/dbus/stub.h>
+
+#include <memory>
+
+namespace location
+{
+namespace dbus
+{
+namespace stub
+{
+class Session : public location::Service::Session
+{
+  public:
+    Session(const core::dbus::Bus::Ptr& connection,
+            const core::dbus::Object::Ptr& object);
+    ~Session();
+
+    void start_position_updates();
+    void stop_position_updates();
+
+    void start_velocity_updates();
+    void stop_velocity_updates();
+
+    void start_heading_updates();
+    void stop_heading_updates();
+
+    Updates& updates() override;
+
+  private:
+    core::dbus::Bus::Ptr connection_;
+    core::dbus::Object::Ptr object_;
+
+    Updates updates_;
+
+    core::ScopedConnection position_;
+    core::ScopedConnection velocity_;
+    core::ScopedConnection heading_;
+};
+}
+}
+}
+
+#endif // LOCATION_DBUS_STUB_SESSION_H_

=== renamed file 'include/location/default_provider_selection_policy.h' => 'src/location/default_provider_selection_policy.h'
=== renamed file 'include/location/fusion_provider.h' => 'src/location/fusion_provider.h'
=== renamed file 'include/location/fusion_provider_selection_policy.h' => 'src/location/fusion_provider_selection_policy.h'
=== renamed file 'include/location/init_and_shutdown.h' => 'src/location/init_and_shutdown.h'
=== renamed file 'include/location/logging.h' => 'src/location/logging.h'
=== renamed file 'include/location/newer_or_more_accurate_update_selector.h' => 'src/location/newer_or_more_accurate_update_selector.h'
=== renamed file 'include/location/newer_update_selector.h' => 'src/location/newer_update_selector.h'
=== renamed file 'include/location/provider_enumerator.h' => 'src/location/provider_enumerator.h'
=== renamed file 'include/location/provider_factory.h' => 'src/location/provider_factory.h'
=== renamed file 'include/location/provider_selection.h' => 'src/location/provider_selection.h'
=== renamed file 'include/location/provider_selection_policy.h' => 'src/location/provider_selection_policy.h'
=== renamed file 'include/location/providers/remote/interface.h' => 'src/location/providers/remote/interface.h'
--- include/location/providers/remote/interface.h	2016-06-26 21:17:03 +0000
+++ src/location/providers/remote/interface.h	2016-06-28 11:55:15 +0000
@@ -26,7 +26,7 @@
 
 #include <core/dbus/traits/service.h>
 
-#include <location/codec.h>
+#include <location/dbus/codec.h>
 #include <location/update.h>
 
 #include <location/heading.h>

=== renamed file 'include/location/providers/remote/skeleton.h' => 'src/location/providers/remote/skeleton.h'
=== renamed file 'include/location/providers/remote/stub.h' => 'src/location/providers/remote/stub.h'
=== renamed file 'include/location/proxy_provider.h' => 'src/location/proxy_provider.h'
=== added file 'src/location/service.cpp'
--- src/location/service.cpp	1970-01-01 00:00:00 +0000
+++ src/location/service.cpp	2016-06-28 11:55:15 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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/service.h>
+
+#include <map>
+#include <type_traits>
+
+namespace
+{
+typedef typename std::underlying_type<location::Service::State>::type UT;
+
+typedef std::pair<std::map<location::Service::State, std::string>, std::map<std::string, location::Service::State>> Lut;
+
+const Lut& lut()
+{
+    static const Lut instance
+    {
+        {
+            {location::Service::State::disabled, "disabled"},
+            {location::Service::State::enabled, "enabled"},
+            {location::Service::State::active, "active"}
+        },
+        {
+            {"disabled", location::Service::State::disabled},
+            {"enabled", location::Service::State::enabled},
+            {"active", location::Service::State::active}
+        }
+    };
+
+    return instance;
+}
+}
+
+bool location::operator==(location::Service::State lhs, location::Service::State rhs)
+{
+    return static_cast<UT>(lhs) == static_cast<UT>(rhs);
+}
+
+bool location::operator!=(location::Service::State lhs, location::Service::State rhs)
+{
+    return static_cast<UT>(lhs) != static_cast<UT>(rhs);
+}
+
+std::ostream& location::operator<<(std::ostream& out, location::Service::State state)
+{
+    return out << lut().first.at(state);
+}
+
+std::istream& location::operator>>(std::istream& in, location::Service::State& state)
+{
+    std::string s; in >> s; state = lut().second.at(s);
+    return in;
+}

=== renamed file 'include/location/service/configuration.h' => 'src/location/service/configuration.h'
=== renamed file 'include/location/service/default_permission_manager.h' => 'src/location/service/default_permission_manager.h'
=== renamed file 'include/location/service/interface.h' => 'src/location/service/interface.h'
--- include/location/service/interface.h	2016-06-26 21:17:03 +0000
+++ src/location/service/interface.h	2016-06-28 11:55:15 +0000
@@ -256,6 +256,6 @@
 }
 }
 
-#include <location/codec.h>
+#include <location/dbus/codec.h>
 
 #endif // LOCATION_SERVICE_INTERFACE_H_

=== renamed file 'include/location/service/permission_manager.h' => 'src/location/service/permission_manager.h'
=== renamed file 'include/location/service/session/implementation.h' => 'src/location/service/session/implementation.h'
=== renamed file 'include/location/service/session/interface.h' => 'src/location/service/session/interface.h'
=== modified file 'src/location/service/session/interface_p.h'
--- src/location/service/session/interface_p.h	2016-06-27 06:44:50 +0000
+++ src/location/service/session/interface_p.h	2016-06-28 11:55:15 +0000
@@ -223,6 +223,6 @@
 }
 }
 
-#include <location/codec.h>
+#include <location/dbus/codec.h>
 
 #endif // LOCATION_SERVICE_SESSION_INTERFACE_P_H_

=== renamed file 'include/location/service/session/skeleton.h' => 'src/location/service/session/skeleton.h'
=== renamed file 'include/location/service/session/stub.h' => 'src/location/service/session/stub.h'
=== renamed file 'include/location/service/skeleton.h' => 'src/location/service/skeleton.h'
=== renamed file 'include/location/service/state.h' => 'src/location/service/state.h'
=== renamed file 'include/location/service/stub.h' => 'src/location/service/stub.h'
=== renamed file 'include/location/update_selector.h' => 'src/location/update_selector.h'
=== modified file 'tests/position_test.cpp'
--- tests/position_test.cpp	2016-06-26 21:17:03 +0000
+++ tests/position_test.cpp	2016-06-28 11:55:15 +0000
@@ -43,7 +43,7 @@
     EXPECT_TRUE(p.altitude ? true : false);
 }
 
-#include <location/codec.h>
+#include <location/dbus/codec.h>
 
 #include <core/dbus/message_streaming_operators.h>