Merge lp:~charlesk/indicator-location/location-service-proxy into lp:indicator-location/15.04

[Charles Kerr]

Create a dbus proxy that talks to location-service to get/set the two location-service-enabled and gps-enabled boolean properties.

Create a dbus proxy that talks to location-service to get/set the two location-service-enabled and gps-enabled boolean properties.

[lp:~charlesk/indicator-location/location-service-proxy]

159. By Charles Kerr on 2015-04-17

fix a couple of bugs in the new proxy code

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:158
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/62/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-amd64-ci/5/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-armhf-ci/5/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-location-ci/62/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/indicator-location/location-service-proxy]

160. By Charles Kerr on 2015-04-17

in LocationServiceController, remove an unnecessary temporary

161. By Charles Kerr on 2015-04-17

in LocationServiceController, delete the copy ctor and assignment operator

[Antti Kaijanmäki (kaijanmaki)]

LGTM.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:160
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/63/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-amd64-ci/6

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-location-ci/63/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:158
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/64/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-amd64-ci/7/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-location-ci/64/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:158
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/65/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/indicator-location-vivid-armhf-ci/8/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-location-ci/65/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-09-02 16:56:38 +0000
+++ CMakeLists.txt	2015-04-17 16:51:36 +0000
@@ -32,7 +32,6 @@
 
 include (FindPkgConfig)
 pkg_check_modules (SERVICE_DEPS REQUIRED
-                   ubuntu-platform-api>=1.0.0
                    ubuntu-app-launch-2
                    url-dispatcher-1
                    gio-unix-2.0>=2.36

=== modified file 'debian/control'
--- debian/control	2015-04-17 16:51:36 +0000
+++ debian/control	2015-04-17 16:51:36 +0000
@@ -13,7 +13,6 @@
                libgtest-dev,
                libubuntu-app-launch2-dev,
                liburl-dispatcher1-dev,
-               libubuntu-application-api-dev,
                python,
                libproperties-cpp-dev,
 Standards-Version: 3.9.4

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-09-02 16:34:36 +0000
+++ src/CMakeLists.txt	2015-04-17 16:51:36 +0000
@@ -17,7 +17,7 @@
   controller.cc
   phone.cc
   service.cc
-  controller-ualc.cc
+  location-service-controller.cc
   accounts-service-license-controller.cc
   license-controller.cc
 )

=== renamed file 'src/controller-ualc.cc' => 'src/location-service-controller.cc'
--- src/controller-ualc.cc	2015-04-17 16:51:36 +0000
+++ src/location-service-controller.cc	2015-04-17 16:51:36 +0000
@@ -20,109 +20,388 @@
 
 #include <glib.h>
 
-#include "controller-ualc.h"
-
-UbuntuAppLocController :: UbuntuAppLocController ():
-  ualc (ua_location_service_create_controller ())
-{
-  g_return_if_fail (ualc != nullptr);
-
-  // update our status when the ualc changes
-  ua_location_service_controller_set_status_changed_handler (ualc,
-                                                             on_ualc_status_changed,
-                                                             this);
-
-  update_status();
-}
-
-UbuntuAppLocController :: ~UbuntuAppLocController ()
-{
-  if (m_update_status_tag)
-    g_source_remove(m_update_status_tag);
-
-  if (ualc != nullptr)
-    ua_location_service_controller_unref (ualc);
-}
-
-void
-UbuntuAppLocController :: on_ualc_status_changed (UALocationServiceStatusFlags /*flags*/, void *vself)
-{
-  static_cast<UbuntuAppLocController*>(vself)->update_status();
-}
-
-void
-UbuntuAppLocController :: update_status_soon()
-{
-  if (m_update_status_tag == 0)
-    {
-      constexpr int retry_interval_seconds = 5;
-
-      auto callback = [](gpointer gself){
-        g_debug("%s periodic check", G_STRLOC);
-        auto self = static_cast<UbuntuAppLocController*>(gself);
-        self->m_update_status_tag = 0;
-        self->update_status();
-        return G_SOURCE_REMOVE;
-      };
-
-      m_update_status_tag = g_timeout_add_seconds(retry_interval_seconds,
-                                                  callback,
-                                                  this);
-    }
-}
-
-void
-UbuntuAppLocController :: update_status ()
-{
-  const bool loc_was_enabled = is_location_service_enabled();
-  const bool gps_was_enabled = is_gps_enabled();
-
-  // update this.current_status with a fresh ualc status
-  UALocationServiceStatusFlags flags {};
-  auto status = ua_location_service_controller_query_status(ualc, &flags);
-  if (status == U_STATUS_SUCCESS)
-    {
-      g_debug("%s %s updating ualc controller status with flags: %d", G_STRLOC, G_STRFUNC, (int)flags);
-      current_status = flags;
-      m_is_valid.set(true);
-    }
-  else
-    {
-      g_warning("%s %s ualc_query_status returned %d", G_STRLOC, G_STRFUNC, status);
-      m_is_valid.set(false);
-      update_status_soon();
-    }
-
-  const bool loc_is_enabled = is_location_service_enabled();
-  const bool gps_is_enabled = is_gps_enabled();
-
-  if (loc_was_enabled != loc_is_enabled)
-    notify_location_service_enabled (loc_is_enabled);
-
-  if (gps_was_enabled != gps_is_enabled)
-    notify_gps_enabled (gps_is_enabled);
-}
-
-/***
-****
-***/
-
-void
-UbuntuAppLocController :: set_gps_enabled (bool enabled)
-{
-  auto status = enabled ? ua_location_service_controller_enable_gps (ualc)
-                        : ua_location_service_controller_disable_gps (ualc);
-
-  if (status != U_STATUS_SUCCESS)
-    g_warning ("Error turning GPS %s", (enabled?"on":"off"));
-}
-
-void
-UbuntuAppLocController :: set_location_service_enabled (bool enabled)
-{
-  auto status = enabled ? ua_location_service_controller_enable_service (ualc)
-                        : ua_location_service_controller_disable_service (ualc);
-
-  if (status != U_STATUS_SUCCESS)
-    g_warning ("Error turning Location Service %s", (enabled?"on":"off"));
-}
+#include "location-service-controller.h"
+#include "utils.h"
+
+/***
+****
+***/
+
+class LocationServiceController::Impl
+{
+public:
+
+    Impl(LocationServiceController& owner)
+    {
+        m_cancellable.reset(g_cancellable_new(), [](GCancellable* c) {
+            g_cancellable_cancel(c);
+            g_object_unref(c);
+        });
+
+        m_gps_enabled.changed().connect([&owner](bool b){
+            owner.notify_gps_enabled(b);
+        });
+
+        m_loc_enabled.changed().connect([&owner](bool b){
+            owner.notify_location_service_enabled(b);
+        });
+
+        g_bus_get(G_BUS_TYPE_SYSTEM,
+                  m_cancellable.get(),
+                  on_system_bus_ready,
+                  this);
+    }
+
+    ~Impl() =default;
+
+    const core::Property<bool>& is_valid() const
+    {
+        return m_is_valid;
+    }
+
+    bool is_gps_enabled() const
+    {
+        return m_gps_enabled.get();
+    }
+
+    bool is_location_service_enabled() const
+    {
+        return m_loc_enabled.get();
+    }
+
+    void set_gps_enabled(bool enabled)
+    {
+        set_bool_property(PROP_KEY_GPS_ENABLED, enabled);
+    }
+
+    void set_location_service_enabled(bool enabled)
+    {
+        set_bool_property(PROP_KEY_LOC_ENABLED, enabled);
+    }
+
+private:
+
+    /***
+    ****  bus bootstrapping & name watching
+    ***/
+
+    static void on_system_bus_ready(GObject*, GAsyncResult* res, gpointer gself)
+    {
+        GError* error;
+        GDBusConnection* system_bus;
+
+        error = nullptr;
+        system_bus = g_bus_get_finish(res, &error);
+        if (system_bus != nullptr)
+        {
+            auto self = static_cast<Impl*>(gself);
+
+            self->m_system_bus.reset(system_bus, GObjectDeleter());
+
+            auto name_tag = g_bus_watch_name_on_connection(
+                                system_bus,
+                                BUS_NAME,
+                                G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
+                                on_name_appeared,
+                                on_name_vanished,
+                                gself,
+                                nullptr);
+
+            //  manage the name_tag's lifespan
+            self->m_name_tag.reset(new guint{name_tag}, [](guint* name_tag){
+                g_bus_unwatch_name(*name_tag);
+                delete name_tag;
+            });
+        }
+        else if (error != nullptr)
+        {
+            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                g_warning("Couldn't get system bus: %s", error->message);
+            g_error_free(error);
+        }
+    }
+
+    static void on_name_appeared(GDBusConnection * system_bus,
+                                 const gchar     * bus_name,
+                                 const gchar     * name_owner,
+                                 gpointer gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+
+        // Why do we use PropertiesChanged, Get, and Set by hand instead
+        // of letting gdbus-codegen or g_dbus_proxy_new() do the dirty work?
+        // ubuntu-location-service's GetAll method is broken; proxies aren't
+        // able to bootstrap themselves and cache the object properties. Ugh.
+
+        // subscribe to PropertiesChanged signals from the service
+        auto signal_tag = g_dbus_connection_signal_subscribe(
+                              system_bus,
+                              name_owner,
+                              PROP_IFACE_NAME,
+                              "PropertiesChanged",
+                              OBJECT_PATH,
+                              nullptr, // arg0
+                              G_DBUS_SIGNAL_FLAGS_NONE,
+                              on_properties_changed,
+                              gself,
+                              nullptr);
+
+        // manage the signal_tag lifespan
+        g_object_ref(system_bus);
+        self->m_signal_tag.reset(new guint{signal_tag},
+                                 [system_bus](guint* tag){
+            g_dbus_connection_signal_unsubscribe(system_bus, *tag);
+            g_object_unref(system_bus);
+            delete tag;
+        });
+
+        // GetAll is borked so call Get on each property we care about
+        struct {
+            const char * name;
+            GAsyncReadyCallback callback;
+        } props[] = {
+            { PROP_KEY_LOC_ENABLED, on_loc_enabled_reply },
+            { PROP_KEY_GPS_ENABLED, on_gps_enabled_reply }
+        };
+        for (const auto& prop : props)
+        { 
+            g_dbus_connection_call(
+                system_bus,
+                BUS_NAME,
+                OBJECT_PATH,
+                PROP_IFACE_NAME,
+                "Get",
+                g_variant_new("(ss)", LOC_IFACE_NAME, prop.name), // args
+                G_VARIANT_TYPE("(v)"), // return type
+                G_DBUS_CALL_FLAGS_NONE,
+                -1, // use default timeout
+                self->m_cancellable.get(),
+                prop.callback,
+                gself);
+        }
+
+        g_debug("setting is_valid to true: location-service appeared");
+        self->m_is_valid.set(true);
+    }
+
+    static void on_name_vanished(GDBusConnection*, const gchar*, gpointer gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+
+        g_debug("setting is_valid to false: location-service vanished");
+        self->m_is_valid.set(false);
+        self->m_signal_tag.reset();
+    }
+
+    /***
+    ****  org.freedesktop.dbus.properties.PropertiesChanged handling
+    ***/
+
+    static void on_properties_changed(GDBusConnection * /*connection*/,
+                                      const gchar     * /*sender_name*/,
+                                      const gchar     * /*object_path*/,
+                                      const gchar     * /*interface_name*/,
+                                      const gchar     * /*signal_name*/,
+                                      GVariant *          parameters,
+                                      gpointer            gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+        const gchar *interface_name;
+        GVariant *changed_properties;
+        const gchar **invalidated_properties;
+        GVariantIter property_iter;
+        const gchar *key;
+        GVariant* val;
+
+        g_variant_get(parameters,
+                      "(&s@a{sv}^a&s)",
+                      &interface_name,
+                      &changed_properties,
+                      &invalidated_properties);
+
+        g_variant_iter_init(&property_iter, changed_properties);
+        while (g_variant_iter_next(&property_iter, "{&sv}", &key, &val))
+        {
+            if (!g_strcmp0(key, PROP_KEY_LOC_ENABLED))
+                self->m_loc_enabled.set(g_variant_get_boolean(val));
+            else if (!g_strcmp0(key, PROP_KEY_GPS_ENABLED))
+                self->m_gps_enabled.set(g_variant_get_boolean(val));
+
+            g_variant_unref(val);
+        }
+
+        g_variant_unref(changed_properties);
+        g_free(invalidated_properties);
+    }
+
+    /***
+    ****  org.freedesktop.dbus.properties.Get handling
+    ***/
+
+    static std::tuple<bool,bool> get_bool_reply_from_call(GObject      * source,
+                                                          GAsyncResult * res)
+    {
+        GError * error;
+        GVariant * v;
+        bool success {false};
+        bool result {false};
+
+        error = nullptr;
+        GDBusConnection * conn = G_DBUS_CONNECTION(source);
+        v = g_dbus_connection_call_finish(conn, res, &error);
+        if (v != nullptr)
+        {
+            GVariant* inner {};
+            g_variant_get(v, "(v)", &inner);
+            success = true;
+            result = g_variant_get_boolean(inner);
+            g_variant_unref(inner);
+            g_variant_unref(v);
+        }
+        else if (error != nullptr)
+        {
+            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                g_warning("Error calling dbus method: %s", error->message);
+            g_error_free(error);
+            success = false;
+        }
+
+        return std::make_tuple(success, result);
+    }
+
+    static void on_loc_enabled_reply(GObject      * source_object,
+                                     GAsyncResult * res,
+                                     gpointer       gself)
+    {
+        bool success, value;
+        std::tie(success, value) = get_bool_reply_from_call(source_object, res);
+        g_debug("service loc reply: success %d value %d", (int)success, (int)value);
+        if (success)
+            static_cast<Impl*>(gself)->m_loc_enabled.set(value);
+    }
+
+    static void on_gps_enabled_reply(GObject      * source_object,
+                                     GAsyncResult * res,
+                                     gpointer       gself)
+    {
+        bool success, value;
+        std::tie(success, value) = get_bool_reply_from_call(source_object, res);
+        g_debug("service gps reply: success %d value %d", (int)success, (int)value);
+        if (success)
+            static_cast<Impl*>(gself)->m_gps_enabled.set(value);
+    }
+
+    /***
+    ****  org.freedesktop.dbus.properties.Set handling
+    ***/
+
+    void set_bool_property(const char* property_name, bool b)
+    {
+        g_return_if_fail(m_system_bus);
+
+        auto args = g_variant_new("(ssv)",
+                                  LOC_IFACE_NAME,
+                                  property_name,
+                                  g_variant_new_boolean(b));
+        g_dbus_connection_call(m_system_bus.get(),
+                               BUS_NAME,
+                               OBJECT_PATH,
+                               PROP_IFACE_NAME,
+                               "Set", // method name,
+                               args,
+                               nullptr, // reply type
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1, // timeout msec
+                               m_cancellable.get(),
+                               check_method_call_reply,
+                               this);
+    }
+
+    static void check_method_call_reply(GObject      *connection,
+                                        GAsyncResult *res,
+                                        gpointer      gself)
+    {
+        GError * error;
+        GVariant * v;
+
+        error = nullptr;
+        v = g_dbus_connection_call_finish(G_DBUS_CONNECTION(connection), res, &error);
+        if (v != nullptr)
+        {
+            auto vs = g_variant_print(v, true);
+            g_debug("method call returned '%s'", vs);
+            g_free(vs);
+            g_variant_unref(v);
+        }
+        else if (error != nullptr)
+        {
+            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                g_warning("dbus method returned an error : %s", error->message);
+
+            g_error_free(error);
+        }
+    }
+
+    /***
+    ****
+    ***/
+
+    static constexpr const char* BUS_NAME {"com.ubuntu.location.Service"};
+    static constexpr const char* OBJECT_PATH {"/com/ubuntu/location/Service"};
+    static constexpr const char* LOC_IFACE_NAME {"com.ubuntu.location.Service"};
+    static constexpr const char* PROP_IFACE_NAME {"org.freedesktop.DBus.Properties"};
+    static constexpr const char* PROP_KEY_LOC_ENABLED {"IsOnline"};
+    static constexpr const char* PROP_KEY_GPS_ENABLED {"DoesSatelliteBasedPositioning"};
+
+    core::Property<bool> m_gps_enabled {false};
+    core::Property<bool> m_loc_enabled {false};
+    core::Property<bool> m_is_valid {false};
+
+    std::shared_ptr<GCancellable> m_cancellable {};
+    std::shared_ptr<GDBusConnection> m_system_bus {};
+    std::shared_ptr<guint> m_name_tag {};
+    std::shared_ptr<guint> m_signal_tag {};
+};
+
+/***
+****
+***/
+
+LocationServiceController::LocationServiceController():
+  impl{new Impl{*this}}
+{
+}
+
+LocationServiceController::~LocationServiceController()
+{
+}
+
+const core::Property<bool>&
+LocationServiceController::is_valid() const
+{
+  return impl->is_valid();
+}
+
+bool
+LocationServiceController::is_gps_enabled() const
+{
+  return impl->is_gps_enabled();
+}
+
+bool
+LocationServiceController::is_location_service_enabled() const
+{
+  return impl->is_location_service_enabled();
+}
+void
+LocationServiceController::set_gps_enabled(bool enabled)
+{
+  impl->set_gps_enabled(enabled);
+}
+
+void
+LocationServiceController::set_location_service_enabled(bool enabled)
+{
+  impl->set_location_service_enabled(enabled);
+}
+

=== renamed file 'src/controller-ualc.h' => 'src/location-service-controller.h'
--- src/controller-ualc.h	2015-04-17 16:51:36 +0000
+++ src/location-service-controller.h	2015-04-17 16:51:36 +0000
@@ -17,41 +17,33 @@
  *   Charles Kerr <[e-mail]>
  */
 
-#ifndef __INDICATOR_LOCATION_CONTROLLER_UALC__H__
-#define __INDICATOR_LOCATION_CONTROLLER_UALC__H__
-
-#include <ubuntu/status.h>
-#include <ubuntu/application/location/controller.h>
-#include <ubuntu/application/location/service.h>
+#ifndef INDICATOR_LOCATION_CONTROLLER_LOCATION_SERVICE
+#define INDICATOR_LOCATION_CONTROLLER_LOCATION_SERVICE
 
 #include "controller.h"
 
-class UbuntuAppLocController: public Controller
+#include <memory> // std::unique_ptr
+
+class LocationServiceController: public Controller
 {
   public:
-
-    UbuntuAppLocController ();
-    virtual ~UbuntuAppLocController();
-
-    virtual const core::Property<bool>& is_valid() const override { return m_is_valid; }
-    bool is_gps_enabled () const { return (current_status & UA_LOCATION_SERVICE_GPS_ENABLED) != 0; }
-    bool is_location_service_enabled () const { return (current_status & UA_LOCATION_SERVICE_ENABLED) != 0; }
-
-    void set_gps_enabled (bool enabled);
-    void set_location_service_enabled (bool enabled);
+    LocationServiceController();
+    virtual ~LocationServiceController();
+
+    virtual const core::Property<bool>& is_valid() const override;
+    bool is_gps_enabled () const override;
+    bool is_location_service_enabled () const override;
+    void set_gps_enabled (bool enabled) override;
+    void set_location_service_enabled (bool enabled) override;
+
+    LocationServiceController(const LocationServiceController&) =delete;
+    LocationServiceController& operator=(const LocationServiceController&) =delete;
 
   private:
-
-    UALocationServiceStatusFlags current_status {};
-    UbuntuApplicationLocationServiceController* ualc {};
-    core::Property<bool> m_is_valid {false};
-    unsigned int m_update_status_tag {};
-
-    static void on_ualc_status_changed (UALocationServiceStatusFlags, void *vself);
-    void update_status();
-    void update_status_soon();
+    friend class Impl;
+    class Impl;
+    std::unique_ptr<Impl> impl;
 };
 
-#endif // __INDICATOR_LOCATION_CONTROLLER_UALC__H__
-
+#endif // INDICATOR_LOCATION_CONTROLLER_LOCATION_SERVICE
 

=== modified file 'src/main.cc'
--- src/main.cc	2014-09-02 16:34:36 +0000
+++ src/main.cc	2015-04-17 16:51:36 +0000
@@ -22,7 +22,7 @@
 #include <glib.h>
 
 #include "accounts-service-license-controller.h"
-#include "controller-ualc.h"
+#include "location-service-controller.h"
 #include "service.h"
 
 static void
@@ -43,7 +43,7 @@
  
   /* set up the service */
   loop = g_main_loop_new (nullptr, false);
-  std::shared_ptr<Controller> controller (new UbuntuAppLocController ());
+  auto controller = std::make_shared<LocationServiceController>();
   auto license_controller = std::make_shared<AccountsServiceLicenseController>();
   Service service (controller, license_controller);
   service.set_name_lost_callback (on_name_lost, loop);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-05-27 15:34:07 +0000
+++ tests/CMakeLists.txt	2015-04-17 16:51:36 +0000
@@ -30,16 +30,6 @@
 target_link_libraries (${TEST_NAME} ${SERVICE_LIB} gtest ${SERVICE_DEPS_LIBRARIES} ${GTEST_LIBS})
 
 ###
-###  ualc-test
-###
-
-set (TEST_NAME ualc-test)
-add_executable (${TEST_NAME} ${TEST_NAME}.cc ualc-mock.c)
-add_test (${TEST_NAME} ${TEST_NAME})
-add_dependencies (${TEST_NAME} ${SERVICE_LIB})
-target_link_libraries (${TEST_NAME} ${SERVICE_LIB} gtest ${SERVICE_DEPS_LIBRARIES} ${GTEST_LIBS})
-
-###
 ###  globals
 ###
 

=== removed file 'tests/ualc-mock.c'
--- tests/ualc-mock.c	2014-01-27 00:03:50 +0000
+++ tests/ualc-mock.c	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU 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/>.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- */
-
-#include <ubuntu/status.h>
-#include <ubuntu/application/location/controller.h>
-#include <ubuntu/application/location/service.h>
-
-#include <glib.h>
-
-static UALocationServiceController * singleton = NULL;
-
-struct UbuntuApplicationLocationServiceController
-{
-  int ref_count;
-  gboolean loc_enabled;
-  gboolean gps_enabled;
-  UALocationServiceStatusChangedHandler changed_handler;
-  void * changed_handler_context;
-};
-
-UALocationServiceController*
-ua_location_service_create_controller(void)
-{
-  if (singleton == NULL)
-  {
-    UALocationServiceController * c = g_new0 (UALocationServiceController, 1);
-    c->loc_enabled = FALSE;
-    c->gps_enabled = FALSE;
-    singleton = c;
-  }
-
-  singleton->ref_count++;
-
-  return singleton;
-}
-
-void
-ua_location_service_controller_set_status_changed_handler (UALocationServiceController *self,
-                                                           UALocationServiceStatusChangedHandler changed_handler,
-                                                           void *changed_handler_context)
-{
-  self->changed_handler = changed_handler;
-  self->changed_handler_context = changed_handler_context;
-}
-
-static void
-notify_status_changed (UALocationServiceController *self)
-{
-  if (self->changed_handler != NULL)
-    {
-      UALocationServiceStatusFlags flags = 0;
-      ua_location_service_controller_query_status(self, &flags);
-      self->changed_handler (flags, self->changed_handler_context);
-    }
-}
-   
-UStatus
-ua_location_service_controller_query_status(UALocationServiceController *self,
-                                            UALocationServiceStatusFlags *out_flags)
-{
-  UALocationServiceStatusFlags out = 0;
-
-  g_return_val_if_fail (self != NULL, U_STATUS_ERROR);
-  g_return_val_if_fail (self->ref_count >= 1, U_STATUS_ERROR);
-  g_return_val_if_fail (out_flags != NULL, U_STATUS_ERROR);
-
-  if (self->loc_enabled)
-    out |= UA_LOCATION_SERVICE_ENABLED;
-
-  if (self->gps_enabled)
-    out |= UA_LOCATION_SERVICE_GPS_ENABLED;
-
-  *out_flags = out;
-  return U_STATUS_SUCCESS;
-}
-
-void
-ua_location_service_controller_unref (UALocationServiceController *self)
-{
-    g_return_if_fail (self != NULL);
-    g_return_if_fail (self->ref_count >= 1);
-
-    if (!--self->ref_count)
-    {
-      g_free (self);
-      singleton = NULL;
-    }
-}
-
-static UStatus
-set_gps_enabled (UALocationServiceController *self, gboolean enabled)
-{
-    g_return_if_fail (self != NULL);
-    g_return_if_fail (self->ref_count >= 1);
-
-    self->gps_enabled = enabled;
-    notify_status_changed (self);
-
-    return U_STATUS_SUCCESS;
-}
-
-UStatus
-ua_location_service_controller_enable_gps (UALocationServiceController *self)
-{
-    return set_gps_enabled (self, TRUE);
-}
-
-UStatus
-ua_location_service_controller_disable_gps (UALocationServiceController *self)
-{
-    return set_gps_enabled (self, FALSE);
-}
-
-static UStatus
-set_service_enabled (UALocationServiceController *self, gboolean enabled)
-{
-    g_return_if_fail (self != NULL);
-    g_return_if_fail (self->ref_count >= 1);
-
-    self->loc_enabled = enabled;
-    notify_status_changed (self);
-
-    return U_STATUS_SUCCESS;
-}
-
-UStatus
-ua_location_service_controller_enable_service (UALocationServiceController *self)
-{
-    return set_service_enabled (self, TRUE);
-}
-
-UStatus
-ua_location_service_controller_disable_service (UALocationServiceController *self)
-{
-    return set_service_enabled (self, FALSE);
-}

=== removed file 'tests/ualc-test.cc'
--- tests/ualc-test.cc	2014-01-27 00:15:30 +0000
+++ tests/ualc-test.cc	1970-01-01 00:00:00 +0000
@@ -1,235 +0,0 @@
-/*
- * Copyright 2014 Canonical Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU 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/>.
- *
- * Authors:
- *   Charles Kerr <[e-mail]>
- */
-
-#include "src/controller-ualc.h"
-
-#include <ubuntu/status.h>
-#include <ubuntu/application/location/controller.h>
-#include <ubuntu/application/location/service.h>
-
-#include <gtest/gtest.h>
-
-#include <glib.h>
-
-/***
-****
-***/
-
-class UalcFixture: public ::testing::Test
-{
-    typedef ::testing::Test super;
-
-  protected:
-
-    GMainLoop * loop = nullptr;
-    UALocationServiceController * ualc = nullptr;
-
-    virtual void SetUp()
-    {
-      super::SetUp();
-
-      loop = g_main_loop_new(nullptr, FALSE);
-      ualc = ua_location_service_create_controller();
-    }
-
-    virtual void TearDown()
-    {
-      g_clear_pointer(&ualc, ua_location_service_controller_unref);
-      g_clear_pointer(&loop, g_main_loop_unref);
-
-      super::TearDown();
-    }
-};
-
-
-/***
-****  Sanity check for build + fixture
-***/
-
-TEST_F(UalcFixture, HelloWorld)
-{
-  EXPECT_TRUE(true);
-  EXPECT_FALSE(false);
-}
-
-
-/***
-****  Simple test to make sure our mock UALC is behaving sanely
-***/
-
-namespace
-{
-  UALocationServiceStatusFlags simple_mock_test_flags = 0;
-
-  void * simple_mock_test_context = (void*)(0xDEADBEEF);
-
-  void simple_mock_test_changed_handler(UALocationServiceStatusFlags flags, void * c)
-  {
-    g_assert(c == simple_mock_test_context);
-    simple_mock_test_flags = flags;
-  }
-}
-
-TEST_F(UalcFixture, SimpleMockTest)
-{
-  ua_location_service_controller_set_status_changed_handler(
-    ualc, simple_mock_test_changed_handler, simple_mock_test_context);
-
-  UALocationServiceStatusFlags flags = 0;
-  EXPECT_EQ(0, simple_mock_test_flags);
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_enable_service(ualc));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED, simple_mock_test_flags);
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED, flags);
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_enable_gps(ualc));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED | UA_LOCATION_SERVICE_GPS_ENABLED, simple_mock_test_flags);
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED | UA_LOCATION_SERVICE_GPS_ENABLED, flags);
-}
-
-/***
-****  Now, actual controller tests
-***/
-
-TEST_F(UalcFixture, ControllerAccessors)
-{
-  UbuntuAppLocController c;
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_enable_service(ualc));
-  EXPECT_TRUE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_enable_gps(ualc));
-  EXPECT_TRUE(c.is_location_service_enabled());
-  EXPECT_TRUE(c.is_gps_enabled());
-
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_disable_service(ualc));
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_TRUE(c.is_gps_enabled());
-
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_disable_gps(ualc));
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-}
-
-TEST_F(UalcFixture, ControllerMutators)
-{
-  UbuntuAppLocController c;
-  UALocationServiceStatusFlags flags;
-
-  flags = 0;
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(0, flags);
-
-  // enable gps
-  c.set_gps_enabled(true);
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_TRUE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(UA_LOCATION_SERVICE_GPS_ENABLED, flags);
-
-  // disable gps
-  c.set_gps_enabled(false);
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(0, flags);
-
-  // enable service
-  c.set_location_service_enabled(true);
-  EXPECT_TRUE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED, flags);
-
-  // disable service
-  c.set_location_service_enabled(false);
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(0, flags);
-
-  // enable both
-  c.set_gps_enabled(true);
-  c.set_location_service_enabled(true);
-  EXPECT_TRUE(c.is_location_service_enabled());
-  EXPECT_TRUE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(UA_LOCATION_SERVICE_ENABLED | UA_LOCATION_SERVICE_GPS_ENABLED, flags);
-
-  // disable both
-  c.set_gps_enabled(false);
-  c.set_location_service_enabled(false);
-  EXPECT_FALSE(c.is_location_service_enabled());
-  EXPECT_FALSE(c.is_gps_enabled());
-  EXPECT_EQ(U_STATUS_SUCCESS, ua_location_service_controller_query_status(ualc, &flags));
-  EXPECT_EQ(0, flags);
-}
-
-/***
-****
-***/
-
-namespace
-{
-  struct MockListener: public ControllerListener {
-    bool last_gps = false;
-    bool last_service = false;
-    bool gps_tickled = false;
-    bool service_tickled = false;
-    void reset() { gps_tickled = service_tickled = last_gps = last_service = false; }
-    void on_gps_enabled_changed (bool b) { gps_tickled = true; last_gps = b; }
-    void on_location_service_enabled_changed (bool b) { service_tickled = true; last_service = b; }
-  };
-
-} // unnamed namespace
-
-TEST_F(UalcFixture, ControllerListeners)
-{
-  UbuntuAppLocController c;
-  MockListener l;
-  c.add_listener(&l);
-  EXPECT_FALSE(l.service_tickled);
-  EXPECT_FALSE(l.gps_tickled);
-
-  // turn on the gps...
-  c.set_gps_enabled(true);
-  EXPECT_FALSE(l.service_tickled);
-  EXPECT_TRUE(l.gps_tickled);
-  EXPECT_TRUE(l.last_gps);
-  l.reset();
-
-  // turn on the location service...
-  c.set_location_service_enabled(true);
-  EXPECT_FALSE(l.gps_tickled);
-  EXPECT_TRUE(l.service_tickled);
-  EXPECT_TRUE(l.last_service);
-  l.reset();
-
-  // service is /already/ enabled so turning
-  // it on again shouldn't trigger any changes
-  c.set_location_service_enabled(true);
-  EXPECT_FALSE(l.service_tickled);
-  EXPECT_FALSE(l.gps_tickled);
-}