Merge lp:~charlesk/indicator-location/sync-with-platform-api-changes-to-accuracy-and-service into lp:indicator-location/14.04

[Charles Kerr]

Syncs indicator-location to the changed platform location service's API that's coming in lp:~thomas-voss/platform-api/expose_accuracy_and_service_status_to_platform

It's possible that this will pass CI before tvoss' branch lands because we're not relying on any new API there, only synchronizing with ones that have been removed. However it would probably be better if this went through at the same time as the other MPs in bug #1248973

[lp:~charlesk/indicator-location/sync-with-platform-api-changes-to-accuracy-and-service]

73. By Charles Kerr on 2014-01-26

consistency in UbuntuAppLocController::set_state()

74. By Charles Kerr on 2014-01-26

copyediting: more understandable variable name

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:74
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/29/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-armhf-ci/7/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~charlesk/indicator-location/sync-with-platform-api-changes-to-accuracy-and-service]

75. By Charles Kerr on 2014-01-27

prepare for adding unit tests for ualc: fix unnecessary g_warning() console message in our test harness

76. By Charles Kerr on 2014-01-27

add a mock implementation of the platform location API for our unit tests

77. By Charles Kerr on 2014-01-27

add unit tests to confirm that our mock ualc works, and that the production Controller keeps in sync with it

78. By Charles Kerr on 2014-01-27

add unit tests to confirm that Controller notifies with the correct status when the ualc's status changes.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:78
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/30/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-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/30/rebuild

review: Approve (continuous-integration)

[Ted Gould (ted)]

Doing a code review as I can't do a full review as I don't have HW to test anything on.

113 + // query the ualc to bootstrap our initial status
114 + UALocationServiceStatusFlags initial_status = 0;
115 + if (ua_location_service_controller_query_status (ualc, &initial_status) == U_STATUS_SUCCESS)
116 + set_status (initial_status);

230 + UALocationServiceStatusFlags current_status = 0;

Seems like the default initial status should be service disabled and GPS disabled, not zero, which I think has no meaning. Not sure which block would be the best to put that, perhaps both.

review: Needs Fixing

[Charles Kerr (charlesk)]

I'm not sure that code block needs fixing?

The "initial_status = 0;" call just zeroes out the field before ua_location_service_controller_query_status() populates it with a real value. It might make sense to remove that line as it's a dead store; still, it's harmless in the context you're talking about.

UALocationServiceStatusFlags is an enum with the fields "UA_LOCATION_SERVICE_GPS_ENABLED" and "UA_LOCATION_SERVICE_ENABLED", so 0 means neither are enabled. So we're in agreement about what the Controller's initial status should be (and is) before ua_location_service_controller_query_status() is called.

[lp:~charlesk/indicator-location/sync-with-platform-api-changes-to-accuracy-and-service]

79. By Charles Kerr on 2014-01-29

remove a dead store assignment in controller-ualc's constructor

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:79
http://jenkins.qa.ubuntu.com/job/indicator-location-ci/31/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-amd64-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-armhf-ci/9
        deb: http://jenkins.qa.ubuntu.com/job/indicator-location-trusty-armhf-ci/9/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Ted Gould (ted)]

On Wed, 2014-01-29 at 00:20 +0000, Charles Kerr wrote:

> UALocationServiceStatusFlags is an enum with the fields
> "UA_LOCATION_SERVICE_GPS_ENABLED" and "UA_LOCATION_SERVICE_ENABLED",
> so 0 means neither are enabled. So we're in agreement about what the
> Controller's initial status should be (and is) before
> ua_location_service_controller_query_status() is called.

I think that it would make total sense if that is what it was, but it's
not :-( It seems to be a field with both enable and disabled flags that
are independent of each other.

http://bazaar.launchpad.net/~phablet-team/platform-api/trunk/view/head:/include/ubuntu/application/location/controller.h#L30

[Charles Kerr (charlesk)]

> I think that it would make total sense if that is what it was, but it's
> not :-( It seems to be a field with both enable and disabled flags that
> are independent of each other.
>
> http://bazaar.launchpad.net/~phablet-team/platform-api/trunk/view/head:/include/ubuntu/application/location/controller.h#L30

Ah, OK I understand your confusion now. That's the API change that this branch is addressing: http://bazaar.launchpad.net/~thomas-voss/platform-api/expose_accuracy_and_service_status_to_platform/view/head:/include/ubuntu/application/location/controller.h#L34

[Ted Gould (ted)]

Ah, okay. I see.

review: Approve

[lp:~charlesk/indicator-location/sync-with-platform-api-changes-to-accuracy-and-service]

80. By Charles Kerr on 2014-05-27

fix copy-paste bug introduced by copying cmake files from indicator-datetime

Unmerged revisions

80. By Charles Kerr on 2014-05-27

fix copy-paste bug introduced by copying cmake files from indicator-datetime

79. By Charles Kerr on 2014-01-29

remove a dead store assignment in controller-ualc's constructor

78. By Charles Kerr on 2014-01-27

add unit tests to confirm that Controller notifies with the correct status when the ualc's status changes.

77. By Charles Kerr on 2014-01-27

add unit tests to confirm that our mock ualc works, and that the production Controller keeps in sync with it

76. By Charles Kerr on 2014-01-27

add a mock implementation of the platform location API for our unit tests

75. By Charles Kerr on 2014-01-27

prepare for adding unit tests for ualc: fix unnecessary g_warning() console message in our test harness

74. By Charles Kerr on 2014-01-26

copyediting: more understandable variable name

73. By Charles Kerr on 2014-01-26

consistency in UbuntuAppLocController::set_state()

72. By Charles Kerr on 2014-01-26

minor copyediting: use consistent terminology 'status' instead of 'state'

71. By Charles Kerr on 2014-01-26

failing to get a ualc in the UbuntuAppLocController constructor should be impossible, so instead of just safeguarding by doing a nullptr test before using, use g_return_if_fail() so a console message will get logged too.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-10-01 19:48:43 +0000
+++ CMakeLists.txt	2014-01-29 00:21:35 +0000
@@ -28,11 +28,12 @@
 find_package (PkgConfig REQUIRED)
 
 include (FindPkgConfig)
-pkg_check_modules (SERVICE REQUIRED
+pkg_check_modules (SERVICE_DEPS REQUIRED
                    ubuntu-platform-api>=1.0.0
                    url-dispatcher-1
                    gio-unix-2.0>=2.36
                    glib-2.0>=2.36)
+include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 ##
 ##

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-08-29 17:48:37 +0000
+++ src/CMakeLists.txt	2014-01-29 00:21:35 +0000
@@ -1,9 +1,12 @@
-
-set_property (DIRECTORY
-              APPEND PROPERTY INCLUDE_DIRECTORIES ${SERVICE_INCLUDE_DIRS})
-
-set_property (DIRECTORY
-              APPEND PROPERTY LINK_DIRECTORIES ${SERVICE_INCLUDE_DIRS})
+set (SERVICE_LIB "indicatordatetimeservice")
+set (SERVICE_EXEC "indicator-datetime-service")
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g ${CXX_WARNING_ARGS} ${GCOV_FLAGS}")
+
+#set_property (DIRECTORY
+#              APPEND PROPERTY INCLUDE_DIRECTORIES ${SERVICE_INCLUDE_DIRS})
+#
+#set_property (DIRECTORY
+#              APPEND PROPERTY LINK_DIRECTORIES ${SERVICE_INCLUDE_DIRS})
 
 
 ###
@@ -12,34 +15,22 @@
 ###  it's built apart from main() as a convenience for tests/
 ###
 
-set (INDICATOR_LIB "libindicator-location-service")
-
-add_library (${INDICATOR_LIB} STATIC controller.cc phone.cc service.cc)
-
-set_property (TARGET ${INDICATOR_LIB}
-              APPEND PROPERTY LINK_LIBRARIES ${INDICATOR_LIB} ${SERVICE_LIBRARIES} ${GCOV_LIBS})
+add_library (${SERVICE_LIB} STATIC controller.cc phone.cc service.cc controller-ualc.cc)
+include_directories (${CMAKE_SOURCE_DIR})
+link_directories (${SERVICE_DEPS_LIBRARY_DIRS})
 
 
 ###
 ###  The service execuable.
 ###
 
-set (INDICATOR_EXEC "indicator-location-service")
-
-add_executable (${INDICATOR_EXEC} main.cc controller-ualc.cc)
+add_executable (${SERVICE_EXEC} main.cc)
+target_link_libraries (${SERVICE_EXEC} ${SERVICE_LIB} ${SERVICE_DEPS_LIBRARIES})
+install (TARGETS ${SERVICE_EXEC}
+         RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR})
 
 set_property (SOURCE main.cc
               APPEND PROPERTY COMPILE_DEFINITIONS
               GETTEXT_PACKAGE="${GETTEXT_PACKAGE}"
               GNOMELOCALEDIR="@CMAKE_INSTALL_FULL_LOCALEDIR@")
 
-target_link_libraries (${INDICATOR_EXEC} libindicator-location-service)
-
-install (TARGETS ${INDICATOR_EXEC}
-         RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR})
-
-
-
-set_property (TARGET ${INDICATOR_LIB} ${INDICATOR_EXEC}
-              APPEND_STRING PROPERTY COMPILE_FLAGS " ${CC_WARNING_ARGS} ${GCOV_FLAGS} --std=c++11")
-

=== modified file 'src/controller-ualc.cc'
--- src/controller-ualc.cc	2013-08-29 17:49:40 +0000
+++ src/controller-ualc.cc	2014-01-29 00:21:35 +0000
@@ -18,20 +18,24 @@
  *   Charles Kerr <[e-mail]>
  */
 
-#include <iostream>
+#include <glib.h>
 
 #include "controller-ualc.h"
 
 UbuntuAppLocController :: UbuntuAppLocController ():
   ualc (ua_location_service_create_controller ())
 {
-  if (ualc != nullptr)
-    {
-      ua_location_service_controller_set_status_changed_handler (
-        ualc,
-        on_location_service_controller_status_changed,
-        this);
-    }
+  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);
+
+  // query the ualc to bootstrap our initial status
+  UALocationServiceStatusFlags initial_status;
+  if (ua_location_service_controller_query_status (ualc, &initial_status) == U_STATUS_SUCCESS)
+    set_status (initial_status);
 }
 
 UbuntuAppLocController :: ~UbuntuAppLocController ()
@@ -41,66 +45,47 @@
 }
 
 void
-UbuntuAppLocController :: on_location_service_controller_status_changed (
-                                                UALocationServiceStatusFlags f,
-                                                void * vself)
-{
-  auto self = static_cast<UbuntuAppLocController*>(vself);
-
-  if (f & (UA_LOCATION_SERVICE_ENABLED | UA_LOCATION_SERVICE_DISABLED))
-    self->notify_gps_enabled (self->is_location_service_enabled ());
-
-  if (f & (UA_LOCATION_SERVICE_GPS_ENABLED | UA_LOCATION_SERVICE_GPS_DISABLED))
-    self->notify_gps_enabled (self->is_gps_enabled());
+UbuntuAppLocController :: on_ualc_status_changed (UALocationServiceStatusFlags flags, void *vself)
+{
+  static_cast<UbuntuAppLocController*>(vself)->set_status (flags);
+}
+
+void
+UbuntuAppLocController :: set_status (UALocationServiceStatusFlags new_status)
+{
+  const bool loc_was_enabled = is_location_service_enabled();
+  const bool gps_was_enabled = is_gps_enabled();
+  current_status = new_status;
+  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);
 }
 
 /***
 ****
 ***/
 
-bool
-UbuntuAppLocController :: is_gps_enabled () const
-{
-  UALocationServiceStatusFlags flags = 0;
-
-  return (ualc != nullptr)
-      && (!ua_location_service_controller_query_status (ualc, &flags))
-      && (flags & UA_LOCATION_SERVICE_GPS_ENABLED);
-}
-
 void
 UbuntuAppLocController :: set_gps_enabled (bool enabled)
 {
-  UStatus status = enabled
-    ? ua_location_service_controller_enable_gps (ualc)
-    : ua_location_service_controller_disable_gps (ualc);
+  auto status = enabled ? ua_location_service_controller_enable_gps (ualc)
+                        : ua_location_service_controller_disable_gps (ualc);
 
   if (status != U_STATUS_SUCCESS)
-    std::cerr << "Error turning GPS " << (enabled?"on":"off") << std::endl;
-}
-
-/***
-****
-***/
-
-bool
-UbuntuAppLocController :: is_location_service_enabled () const
-{
-  UALocationServiceStatusFlags flags = 0;
-
-  return (ualc != nullptr)
-      && (!ua_location_service_controller_query_status (ualc, &flags))
-      && (flags & UA_LOCATION_SERVICE_ENABLED);
+    g_warning ("Error turning GPS %s", (enabled?"on":"off"));
 }
 
 void
 UbuntuAppLocController :: set_location_service_enabled (bool enabled)
 {
-  UStatus status = enabled
-    ? ua_location_service_controller_enable_service (ualc)
-    : ua_location_service_controller_disable_service (ualc);
+  auto status = enabled ? ua_location_service_controller_enable_service (ualc)
+                        : ua_location_service_controller_disable_service (ualc);
 
   if (status != U_STATUS_SUCCESS)
-    std::cerr << "Error turning Location Service " << (enabled?"on":"off")
-              << std::endl;
+    g_warning ("Error turning Location Service %s", (enabled?"on":"off"));
 }

=== modified file 'src/controller-ualc.h'
--- src/controller-ualc.h	2013-08-25 21:44:50 +0000
+++ src/controller-ualc.h	2014-01-29 00:21:35 +0000
@@ -34,18 +34,19 @@
     virtual ~UbuntuAppLocController();
 
     bool is_valid () const { return ualc != nullptr; }
-    bool is_gps_enabled () const;
-    bool is_location_service_enabled () const;
+    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);
 
   private:
 
+    UALocationServiceStatusFlags current_status = 0;
     UbuntuApplicationLocationServiceController * ualc;
 
-    static void on_location_service_controller_status_changed (
-                              UALocationServiceStatusFlags, void *);
+    static void on_ualc_status_changed (UALocationServiceStatusFlags, void *vself);
+    void set_status (UALocationServiceStatusFlags);
 };
 
 #endif // __INDICATOR_LOCATION_CONTROLLER_UALC__H__

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-08-25 20:31:26 +0000
+++ tests/CMakeLists.txt	2014-01-29 00:21:35 +0000
@@ -1,3 +1,4 @@
+
 ###
 ###  Google Test Framework
 ###
@@ -5,28 +6,46 @@
 add_library (gtest STATIC 
              ${GTEST_SOURCE_DIR}/gtest-all.cc 
              ${GTEST_SOURCE_DIR}/gtest_main.cc)
+set_target_properties (gtest PROPERTIES INCLUDE_DIRECTORIES ${INCLUDE_DIRECTORIES} ${GTEST_INCLUDE_DIR})
+set_target_properties (gtest PROPERTIES COMPILE_FLAGS ${COMPILE_FLAGS} -w)
+
+###
+###  General setup
+###
+
+include_directories (${CMAKE_SOURCE_DIR})
+#include_directories (${CMAKE_CURRENT_BINARY_DIR})
+
+set (CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -g ${CC_WARNING_ARGS}")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g ${CC_WARNING_ARGS} -std=c++11")
 
 ###
 ###  phone-test
 ###
 
-set (PHONE_TEST "phone-test")
-add_executable (${PHONE_TEST} phone-test.cc)
-add_test (${PHONE_TEST} ${PHONE_TEST})
-
+set (TEST_NAME phone-test)
+add_executable (${TEST_NAME} ${TEST_NAME}.cc)
+add_test (${TEST_NAME} ${TEST_NAME})
+add_dependencies (${TEST_NAME} libindicatorlocationservice)
+target_link_libraries (${TEST_NAME} indicatordatetimeservice 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} libindicatorlocationservice)
+target_link_libraries (${TEST_NAME} indicatordatetimeservice gtest ${SERVICE_DEPS_LIBRARIES} ${GTEST_LIBS})
 
 ###
 ###  globals
 ###
 
-set (ALL_TESTS ${PHONE_TEST})
-
-set_property (TARGET ${ALL_TESTS}
-              APPEND_STRING PROPERTY COMPILE_FLAGS "${CC_WARNING_ARGS} -g --std=c++11")
-
-set_property (TARGET ${ALL_TESTS}
-              APPEND PROPERTY LINK_LIBRARIES libindicator-location-service gtest ${GTEST_LIBS} ${GCOV_LIBS})
-
-set_property (TARGET ${ALL_TESTS} gtest
-              APPEND PROPERTY INCLUDE_DIRECTORIES ${CMAKE_SOURCE_DIR} ${SERVICE_INCLUDE_DIRS} ${GTEST_INCLUDE_DIR})
+#set_property (TARGET ${ALL_TESTS}
+#              APPEND PROPERTY LINK_LIBRARIES libindicator-location-service gtest ${GTEST_LIBS} ${GCOV_LIBS})
+#
+#set_property (TARGET ${ALL_TESTS} gtest
+#              APPEND PROPERTY INCLUDE_DIRECTORIES ${CMAKE_SOURCE_DIR} ${SERVICE_INCLUDE_DIRS} ${GTEST_INCLUDE_DIR})
 

=== modified file 'tests/gtest-dbus-fixture.h'
--- tests/gtest-dbus-fixture.h	2013-08-25 21:44:50 +0000
+++ tests/gtest-dbus-fixture.h	2014-01-29 00:21:35 +0000
@@ -61,6 +61,13 @@
       return G_SOURCE_REMOVE;
     }
 
+    static gboolean
+    wait_msec__timeout(gpointer loop)
+    {
+      g_main_loop_quit(static_cast<GMainLoop*>(loop));
+      return G_SOURCE_CONTINUE;
+    }
+
   protected:
 
     virtual void SetUp ()
@@ -103,29 +110,29 @@
       g_clear_pointer (&loop, g_main_loop_unref);
     }
 
+  protected:
+
     /* convenience func to loop while waiting for a GObject's signal */
-    void wait_for_signal (gpointer o, const gchar * signal)
+    void wait_for_signal(gpointer o, const gchar * signal, const int timeout_seconds=5)
     {
-      const int timeout_seconds = 5; // arbitrary
-
       // wait for the signal or for timeout, whichever comes first
-      guint handler_id = g_signal_connect_swapped (o, signal,
-                                                   G_CALLBACK(g_main_loop_quit),
-                                                   loop);
-      gulong timeout_id = g_timeout_add_seconds (timeout_seconds,
-                                                 wait_for_signal__timeout,
-                                                 const_cast<gchar*>(signal));
-      g_main_loop_run (loop);
-      g_source_remove (timeout_id);
-      g_signal_handler_disconnect (o, handler_id);
+      const auto handler_id = g_signal_connect_swapped(o, signal,
+                                                       G_CALLBACK(g_main_loop_quit),
+                                                       loop);
+      const auto timeout_id = g_timeout_add_seconds(timeout_seconds,
+                                                    wait_for_signal__timeout,
+                                                    loop);
+      g_main_loop_run(loop);
+      g_source_remove(timeout_id);
+      g_signal_handler_disconnect(o, handler_id);
     }
 
     /* convenience func to loop for N msec */
-    void wait_msec (int msec)
+    void wait_msec(int msec=50)
     {
-      guint id = g_timeout_add (msec, (GSourceFunc)g_main_loop_quit, loop);
-      g_main_loop_run (loop);
-      g_source_remove (id);
+      const auto id = g_timeout_add(msec, wait_msec__timeout, loop);
+      g_main_loop_run(loop);
+      g_source_remove(id);
     }
 
     GMainLoop * loop;

=== added file 'tests/ualc-mock.c'
--- tests/ualc-mock.c	1970-01-01 00:00:00 +0000
+++ tests/ualc-mock.c	2014-01-29 00:21:35 +0000
@@ -0,0 +1,152 @@
+/*
+ * 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);
+}

=== added file 'tests/ualc-test.cc'
--- tests/ualc-test.cc	1970-01-01 00:00:00 +0000
+++ tests/ualc-test.cc	2014-01-29 00:21:35 +0000
@@ -0,0 +1,235 @@
+/*
+ * 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);
+}