Merge lp:~thomas-voss/location-service/deliver-updates-to-visible-satellites into lp:location-service/15.04

[Thomas Voß]

Deliver updates to visible satellites.

Deliver updates to visible satellites.

[lp:~thomas-voss/location-service/deliver-updates-to-visible-satellites]

210. By Thomas Voß on 2016-01-11

Account for API changes in platform api's hw gps component.

Unmerged revisions

210. By Thomas Voß on 2016-01-11

Account for API changes in platform api's hw gps component.

209. By Thomas Voß on 2015-12-05

Deliver updates to visible satellites.

=== modified file 'include/location_service/com/ubuntu/location/service/skeleton.h'
--- include/location_service/com/ubuntu/location/service/skeleton.h	2015-02-13 13:19:18 +0000
+++ include/location_service/com/ubuntu/location/service/skeleton.h	2015-12-05 22:04:55 +0000
@@ -137,6 +137,8 @@
     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);
+    // Called when the visible space vehicles as observed by gps/glonass/galileo/etc. providers has changed.
+    void on_visible_space_vehicles_changed(const std::map<com::ubuntu::location::SpaceVehicle::Key, com::ubuntu::location::SpaceVehicle>& svs);
 
     // Stores the configuration passed in at creation time.
     Configuration configuration;
@@ -165,6 +167,7 @@
         core::ScopedConnection does_satellite_based_positioning;
         core::ScopedConnection does_report_cell_and_wifi_ids;
         core::ScopedConnection is_online;
+        core::ScopedConnection visible_space_vehicles;
     } connections;
     // Guards the session store.
     std::mutex guard;

=== modified file 'src/location_service/com/ubuntu/location/service/skeleton.cpp'
--- src/location_service/com/ubuntu/location/service/skeleton.cpp	2015-02-13 13:19:18 +0000
+++ src/location_service/com/ubuntu/location/service/skeleton.cpp	2015-12-05 22:04:55 +0000
@@ -91,6 +91,10 @@
           properties.is_online->changed().connect([this](bool value)
           {
               on_is_online_changed(value);
+          }),
+          properties.visible_space_vehicles->changed().connect([this](const std::map<com::ubuntu::location::SpaceVehicle::Key, com::ubuntu::location::SpaceVehicle> & svs)
+          {
+              on_visible_space_vehicles_changed(svs);
           })
       }
 {
@@ -258,6 +262,23 @@
                 the_empty_array_of_invalidated_properties()));
 }
 
+void culs::Skeleton::on_visible_space_vehicles_changed(const std::map<com::ubuntu::location::SpaceVehicle::Key, com::ubuntu::location::SpaceVehicle> & value)
+{
+    std::map<std::string, core::dbus::types::Variant> dict
+    {
+        {
+            culs::Interface::Properties::VisibleSpaceVehicles::name(),
+            core::dbus::types::Variant::encode(value)
+        }
+    };
+
+    properties_changed->emit(
+            std::tie(
+                core::dbus::traits::Service<culs::Interface>::interface_name(),
+                dict,
+                the_empty_array_of_invalidated_properties()));
+}
+
 core::Property<bool>& culs::Skeleton::does_satellite_based_positioning()
 {
     return *properties.does_satellite_based_positioning;

=== modified file 'tests/acceptance_tests.cpp'
--- tests/acceptance_tests.cpp	2015-11-27 13:00:31 +0000
+++ tests/acceptance_tests.cpp	2015-12-05 22:04:55 +0000
@@ -75,6 +75,22 @@
 
 static const bool trust_store_is_set_up_for_testing = setup_trust_store_permission_manager_for_testing();
 
+class AutoJoiningThread
+{
+public:
+    AutoJoiningThread(std::function<void()> task) : worker{task}
+    {
+    }
+
+    ~AutoJoiningThread()
+    {
+        if (worker.joinable())
+            worker.join();
+    }
+
+    std::thread worker;
+};
+
 struct NullReporter : public culs::Harvester::Reporter
 {
     NullReporter() = default;
@@ -621,12 +637,13 @@
                 std::make_shared<NullReporter>()
             }
         };
+
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
 
         configuration.engine->updates.visible_space_vehicles.set(visible_space_vehicles);
 
-        std::thread t1{[incoming](){incoming->run();}};
-        std::thread t2{[outgoing](){outgoing->run();}};
+        AutoJoiningThread t1{[incoming](){incoming->run();}};
+        AutoJoiningThread t2{[outgoing](){outgoing->run();}};
 
         sync_start.try_signal_ready_for(std::chrono::milliseconds{500});
 
@@ -635,12 +652,6 @@
         incoming->stop();
         outgoing->stop();
 
-        if (t1.joinable())
-            t1.join();
-
-        if (t2.joinable())
-            t2.join();
-
         return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
     };
 
@@ -665,6 +676,124 @@
     EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(server, client));
 }
 
+TEST_F(LocationServiceStandalone, VisibleSpaceVehiclesAreUpdated)
+{
+    EXPECT_TRUE(trust_store_is_set_up_for_testing);
+
+    core::testing::CrossProcessSync sync_start;
+
+    cul::SpaceVehicle sv1;
+    sv1.key.type = cul::SpaceVehicle::Type::gps;
+    sv1.has_ephimeris_data = true;
+    auto sv2 = sv1;
+    sv2.key.id = 1;
+
+    static const std::map<cul::SpaceVehicle::Key, cul::SpaceVehicle> vsv1
+    {
+        {sv1.key, sv1}
+    };
+
+    static const std::map<cul::SpaceVehicle::Key, cul::SpaceVehicle> vsv2
+    {
+        {sv1.key, sv1}, {sv2.key, sv2}
+    };
+
+    auto server = [this, &sync_start]()
+    {
+        SCOPED_TRACE("Server");
+
+        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 incoming = session_bus();
+        auto outgoing = session_bus();
+
+        incoming->install_executor(core::dbus::asio::make_executor(incoming));
+        outgoing->install_executor(core::dbus::asio::make_executor(outgoing));
+
+        auto dummy = new DummyProvider();
+        cul::Provider::Ptr helper(dummy);
+
+        cul::service::DefaultConfiguration config;
+        cul::service::Implementation::Configuration configuration
+        {
+            incoming,
+            outgoing,
+            config.the_engine(config.the_provider_set(helper), config.the_provider_selection_policy(), null_settings()),
+            config.the_permission_manager(incoming),
+            cul::service::Harvester::Configuration
+            {
+                cul::connectivity::platform_default_manager(),
+                std::make_shared<NullReporter>()
+            }
+        };
+
+        auto location_service = std::make_shared<cul::service::Implementation>(configuration);
+
+        bool stop_requested = false;
+        AutoJoiningThread updater{[&configuration, &stop_requested]()
+        {
+            int counter = 0;
+            while (not stop_requested)
+            {
+                configuration.engine->updates.visible_space_vehicles.set(++counter % 2 == 0 ? vsv1 : vsv2);
+                std::this_thread::sleep_for(std::chrono::milliseconds{10});
+            }
+        }};
+
+        AutoJoiningThread t1{[incoming](){incoming->run();}};
+        AutoJoiningThread t2{[outgoing](){outgoing->run();}};
+
+        sync_start.try_signal_ready_for(std::chrono::milliseconds{500});
+
+        trap->run();
+
+        stop_requested = true;
+        incoming->stop();
+        outgoing->stop();
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
+    };
+
+    auto client = [this, &sync_start]()
+    {
+        SCOPED_TRACE("Client");
+
+        EXPECT_EQ(1, sync_start.wait_for_signal_ready_for(std::chrono::milliseconds{500}));
+
+        auto bus = session_bus();
+        auto location_service = dbus::resolve_service_on_bus<
+            cul::service::Interface,
+            cul::service::Stub>(bus);
+
+        bus->install_executor(core::dbus::asio::make_executor(bus));
+        AutoJoiningThread worker{[bus]() { bus->run(); }};
+
+        bool updated{false};
+        std::mutex guard;
+        std::condition_variable cv;
+
+        location_service->visible_space_vehicles().changed().connect([&updated, &guard, &cv](const std::map<cul::SpaceVehicle::Key, cul::SpaceVehicle>& svs)
+        {
+            std::unique_lock<std::mutex> ul{guard};
+            updated = true;
+            cv.notify_all();
+        });
+
+        std::unique_lock<std::mutex> ul{guard};
+        EXPECT_TRUE(cv.wait_for(ul, std::chrono::seconds{2}, [&updated]() { return updated; }));
+
+        bus->stop();
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
+    };
+
+    EXPECT_EQ(core::testing::ForkAndRunResult::empty, core::testing::fork_and_run(server, client));
+}
+
 TEST_F(LocationServiceStandalone, NewSessionsGetLastKnownPosition)
 {
     core::testing::CrossProcessSync sync_start;