Merge lp:~thomas-voss/platform-api/add-documentation-part-1 into lp:platform-api

[Thomas Voß]

Add first wave of doxygen documentation and make the documentation known to the packaging setup.

Add first wave of doxygen documentation and make the documentation known to the packaging setup.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:82
http://jenkins.qa.ubuntu.com/job/platform-api-ci/66/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-saucy-amd64-ci/36
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-saucy-armhf-ci/36
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-saucy-armhf-ci/36/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-saucy-i386-ci/36

Click here to trigger a rebuild:
http://s-jenkins:8080/job/platform-api-ci/66/rebuild

review: Approve (continuous-integration)

[lp:~thomas-voss/platform-api/add-documentation-part-1]

83. By Thomas Voß on 2013-07-05

[ Thomas Voß ]
* * Adjust the cmake setup and get rid of -DUSE_GLES, instead rely on
  automatic detection if the header is available. * Adjust the cmake
  setup to bail out if EGL is not available. * Adjust the cmake setup
  to autogenerate doxygen API documentation.
* * Add a pkgconfig file for the platform API * Adjust installation of
  header files to account for version.
[ Ubuntu daily release ]
* Automatic snapshot from revision 84

84. By Thomas Voß on 2013-07-05

Addressing review comments.

85. By Thomas Voß on 2013-07-05

 Adjust Document:-line.

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-03 07:23:59 +0000
+++ CMakeLists.txt	2013-07-05 09:17:25 +0000
@@ -80,7 +80,7 @@
 )
 
 if(NOT Hybris)
-  message("Notice: libhybris-common.so not found, disabling hybris support")
+  message(STATUS "Notice: libhybris-common.so not found, disabling hybris support")
   set(ENABLE_HYBRIS_IMPLEMENTATION OFF)
 endif()
 
 
=== modified file 'android/hybris/ubuntu_application_gps_for_hybris.cpp'
--- android/hybris/ubuntu_application_gps_for_hybris.cpp	2013-02-05 07:46:29 +0000
+++ android/hybris/ubuntu_application_gps_for_hybris.cpp	2013-07-05 09:17:25 +0000
@@ -15,7 +15,7 @@
  *
  * Authored by: Daniel d'Andrada <[e-mail]>
  */
-#include <ubuntu/application/ubuntu_application_gps.h>
+#include <ubuntu/hardware/gps.h>
 
 #include <pthread.h>
 
@@ -23,12 +23,12 @@
 #include <hardware/gps.h>
 #include <hardware_legacy/power.h>
 
-#define WAKE_LOCK_NAME  "UBUNTU_GPS"
+#define WAKE_LOCK_NAME  "U_HARDWARE_GPS"
 
-struct UbuntuGps_
+struct UHardwareGps_
 {
-    UbuntuGps_(UbuntuGpsParams* params);
-    ~UbuntuGps_();
+    UHardwareGps_(UHardwareGpsParams* params);
+    ~UHardwareGps_();
 
     bool init();
 
@@ -48,28 +48,28 @@
     const GpsDebugInterface* gps_debug_interface;
     const AGpsRilInterface* agps_ril_interface;
 
-    UbuntuGpsLocationCallback location_cb;
-    UbuntuGpsStatusCallback status_cb;
-    UbuntuGpsSvStatusCallback sv_status_cb;
-    UbuntuGpsNmeaCallback nmea_cb;
-    UbuntuGpsSetCapabilities set_capabilities_cb;
-    UbuntuGpsRequestUtcTime request_utc_time_cb;
-
-    UbuntuGpsXtraDownloadRequest xtra_download_request_cb;
-
-    UbuntuAgpsStatusCallback agps_status_cb;
-
-    UbuntuGpsNiNotifyCallback gps_ni_notify_cb;
-
-    UbuntuAgpsRilRequestSetId request_setid_cb;
-    UbuntuAgpsRilRequestRefLoc request_refloc_cb;
+    UHardwareGpsLocationCallback location_cb;
+    UHardwareGpsStatusCallback status_cb;
+    UHardwareGpsSvStatusCallback sv_status_cb;
+    UHardwareGpsNmeaCallback nmea_cb;
+    UHardwareGpsSetCapabilities set_capabilities_cb;
+    UHardwareGpsRequestUtcTime request_utc_time_cb;
+
+    UHardwareGpsXtraDownloadRequest xtra_download_request_cb;
+
+    UHardwareGpsAGpsStatusCallback agps_status_cb;
+
+    UHardwareGpsNiNotifyCallback gps_ni_notify_cb;
+
+    UHardwareGpsAGpsRilRequestSetId request_setid_cb;
+    UHardwareGpsAGpsRilRequestRefLoc request_refloc_cb;
 
     void* context;
 };
 
 namespace
 {
-UbuntuGps hybris_gps_instance = NULL;
+UHardwareGps hybris_gps_instance = NULL;
 }
 
 static void location_callback(GpsLocation* location)
@@ -78,7 +78,7 @@
         return;
 
     hybris_gps_instance->location_cb(
-        reinterpret_cast<UbuntuGpsLocation*>(location),
+        reinterpret_cast<UHardwareGpsLocation*>(location),
         hybris_gps_instance->context);
 }
 
@@ -96,7 +96,7 @@
         return;
 
     hybris_gps_instance->sv_status_cb(
-            reinterpret_cast<UbuntuGpsSvStatus*>(sv_status),
+            reinterpret_cast<UHardwareGpsSvStatus*>(sv_status),
             hybris_gps_instance->context);
 }
 
@@ -202,7 +202,7 @@
     */
 
     hybris_gps_instance->agps_status_cb(
-        reinterpret_cast<UbuntuAgpsStatus*>(agps_status), hybris_gps_instance->context);
+        reinterpret_cast<UHardwareGpsAGpsStatus*>(agps_status), hybris_gps_instance->context);
 }
 
 AGpsCallbacks agps_callbacks =
@@ -215,7 +215,7 @@
 {
     if (hybris_gps_instance)
         hybris_gps_instance->gps_ni_notify_cb(
-            reinterpret_cast<UbuntuGpsNiNotification*>(notification),
+            reinterpret_cast<UHardwareGpsNiNotification*>(notification),
             hybris_gps_instance->context);
 }
 
@@ -245,7 +245,7 @@
 };
 
 
-UbuntuGps_::UbuntuGps_(UbuntuGpsParams* params)
+UHardwareGps_::UHardwareGps_(UHardwareGpsParams* params)
     : gps_interface(NULL),
       gps_xtra_interface(NULL),
       agps_interface(NULL),
@@ -294,13 +294,13 @@
     }
 }
 
-UbuntuGps_::~UbuntuGps_()
+UHardwareGps_::~UHardwareGps_()
 {
     if (gps_interface)
         gps_interface->cleanup();
 }
 
-bool UbuntuGps_::init()
+bool UHardwareGps_::init()
 {
     // fail if the main interface fails to initialize
     if (!gps_interface || gps_interface->init(&gps_callbacks) != 0)
@@ -320,7 +320,7 @@
     return true;
 }
 
-bool UbuntuGps_::start()
+bool UHardwareGps_::start()
 {
     if (gps_interface)
         return (gps_interface->start() == 0);
@@ -328,7 +328,7 @@
         return false;
 }
 
-bool UbuntuGps_::stop()
+bool UHardwareGps_::stop()
 {
     if (gps_interface)
         return (gps_interface->stop() == 0);
@@ -336,25 +336,25 @@
         return false;
 }
 
-void UbuntuGps_::inject_time(int64_t time, int64_t time_reference, int uncertainty)
+void UHardwareGps_::inject_time(int64_t time, int64_t time_reference, int uncertainty)
 {
     if (gps_interface)
         gps_interface->inject_time(time, time_reference, uncertainty);
 }
 
-void UbuntuGps_::inject_location(double latitude, double longitude, float accuracy)
+void UHardwareGps_::inject_location(double latitude, double longitude, float accuracy)
 {
     if (gps_interface)
         gps_interface->inject_location(latitude, longitude, accuracy);
 }
 
-void UbuntuGps_::delete_aiding_data(uint16_t flags)
+void UHardwareGps_::delete_aiding_data(uint16_t flags)
 {
     if (gps_interface)
         gps_interface->delete_aiding_data(flags);
 }
 
-bool UbuntuGps_::set_position_mode(uint32_t mode, uint32_t recurrence, uint32_t min_interval,
+bool UHardwareGps_::set_position_mode(uint32_t mode, uint32_t recurrence, uint32_t min_interval,
                                     uint32_t preferred_accuracy, uint32_t preferred_time)
 {
     if (gps_interface)
@@ -364,7 +364,7 @@
         return false;
 }
 
-void UbuntuGps_::inject_xtra_data(char* data, int length)
+void UHardwareGps_::inject_xtra_data(char* data, int length)
 {
     if (gps_xtra_interface)
         gps_xtra_interface->inject_xtra_data(data, length);
@@ -373,58 +373,58 @@
 /////////////////////////////////////////////////////////////////////
 // Implementation of the C API
 
-UbuntuGps ubuntu_gps_new(UbuntuGpsParams* params)
+UHardwareGps u_hardware_gps_new(UHardwareGpsParams* params)
 {
     if (hybris_gps_instance != NULL)
         return NULL;
 
-    UbuntuGps ubuntu_gps = new UbuntuGps_(params);
-    hybris_gps_instance = ubuntu_gps;
+    UHardwareGps u_hardware_gps = new UHardwareGps_(params);
+    hybris_gps_instance = u_hardware_gps;
 
-    if (!ubuntu_gps->init())
+    if (!u_hardware_gps->init())
     {
-        delete ubuntu_gps;
-        ubuntu_gps = NULL;
+        delete u_hardware_gps;
+        u_hardware_gps = NULL;
     }
 
-    return ubuntu_gps;
+    return u_hardware_gps;
 }
 
-void ubuntu_gps_delete(UbuntuGps handle)
+void u_hardware_gps_delete(UHardwareGps handle)
 {
     delete handle;
     if (handle == hybris_gps_instance)
         hybris_gps_instance = NULL;
 }
 
-bool ubuntu_gps_start(UbuntuGps self)
+bool u_hardware_gps_start(UHardwareGps self)
 {
     return self->start();
 }
 
-bool ubuntu_gps_stop(UbuntuGps self)
+bool u_hardware_gps_stop(UHardwareGps self)
 {
     return self->stop();
 }
 
-void ubuntu_gps_inject_time(UbuntuGps self, int64_t time, int64_t time_reference,
+void u_hardware_gps_inject_time(UHardwareGps self, int64_t time, int64_t time_reference,
                             int uncertainty)
 {
     self->inject_time(time, time_reference, uncertainty);
 }
 
-void ubuntu_gps_inject_location(UbuntuGps self, double latitude, double longitude,
+void u_hardware_gps_inject_location(UHardwareGps self, double latitude, double longitude,
                                 float accuracy)
 {
     self->inject_location(latitude, longitude, accuracy);
 }
 
-void ubuntu_gps_delete_aiding_data(UbuntuGps self, uint16_t flags)
+void u_hardware_gps_delete_aiding_data(UHardwareGps self, uint16_t flags)
 {
     self->delete_aiding_data(flags);
 }
 
-bool ubuntu_gps_set_position_mode(UbuntuGps self, uint32_t mode, uint32_t recurrence,
+bool u_hardware_gps_set_position_mode(UHardwareGps self, uint32_t mode, uint32_t recurrence,
                                   uint32_t min_interval, uint32_t preferred_accuracy,
                                   uint32_t preferred_time)
 {
@@ -432,7 +432,7 @@
                                    preferred_time);
 }
 
-void ubuntu_gps_inject_xtra_data(UbuntuGps self, char* data, int length)
+void u_hardware_gps_inject_xtra_data(UHardwareGps self, char* data, int length)
 {
     self->inject_xtra_data(data, length);
 }
 
=== modified file 'debian/changelog'
--- debian/changelog	2013-07-05 02:01:11 +0000
+++ debian/changelog	2013-07-05 09:17:25 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 platform-api (0.18.1+13.10.20130705-0ubuntu1) saucy; urgency=low
 
   [ Thomas Voß ]
@@ -13,6 +14,14 @@
 
  -- Ubuntu daily release <[e-mail]>  Fri, 05 Jul 2013 02:01:10 +0000
 
+=======
+platform-api (0.18.1+13.10.20130703-0ubuntu2) UNRELEASED; urgency=low
+
+  * Split out hal to ease integration of location service.
+
+ -- Thomas Voß <tvoss@x220>  Thu, 04 Jul 2013 19:09:22 +0200
+
+>>>>>>> MERGE-SOURCE
 platform-api (0.18.1+13.10.20130703-0ubuntu1) saucy; urgency=low
 
   [ Ricardo Mendoza ]
 
=== added file 'debian/libplatform-api1-dev.doc-base'
--- debian/libplatform-api1-dev.doc-base	1970-01-01 00:00:00 +0000
+++ debian/libplatform-api1-dev.doc-base	2013-07-05 09:17:25 +0000
@@ -0,0 +1,8 @@
+Document: Ubuntu Platform API
+Title: Ubuntu Platform API Reference Documentation
+Author: Thomas Voß
+Abstract: This is the reference documentation for the Ubuntu Platform API
+Section: Debian
+Format: HTML
+Index: /usr/share/doc/ubuntu-platform-api/html/index.html
+Files: /usr/share/doc/ubuntu-platform-api/html/*.html
 \ No newline at end of file
 
=== modified file 'debian/libplatform-api1-dev.install'
--- debian/libplatform-api1-dev.install	2013-06-13 12:04:14 +0000
+++ debian/libplatform-api1-dev.install	2013-07-05 09:17:25 +0000
@@ -1,2 +1,3 @@
 usr/lib/*/libubuntu_application_api.so
+usr/lib/*/libubuntu_platform_hardware_api.so
 usr/lib/*/pkgconfig/ubuntu-platform-api.pc
 
=== modified file 'debian/libplatform-api1-hybris.install'
--- debian/libplatform-api1-hybris.install	2013-03-20 12:49:06 +0000
+++ debian/libplatform-api1-hybris.install	2013-07-05 09:17:25 +0000
@@ -1,1 +1,2 @@
-usr/lib/*/libubuntu_application_api.so.*
+usr/lib/*/libubuntu_application_api.so*
+usr/lib/*/libubuntu_platform_hardware_api.so*
 \ No newline at end of file
 
=== modified file 'debian/libplatform-api1-hybris.symbols'
--- debian/libplatform-api1-hybris.symbols	2013-06-21 02:01:18 +0000
+++ debian/libplatform-api1-hybris.symbols	2013-07-05 09:17:25 +0000
@@ -1,12 +1,9 @@
 libubuntu_application_api.so.1 libplatform-api1-hybris #MINVER#
- (c++)"ua_sensors_light_disable(void*)@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::path_to_library()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::instance()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::Bridge()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::Bridge()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::~Bridge()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::~Bridge()@Base" 0.18.1daily13.06.21
- (c++)"ubuntu::hybris::Bridge::resolve_symbol(char const*) const@Base" 0.18.1daily13.06.21
+ _Z24ua_sensors_light_disablePv@Base 0.18.1daily13.06.21
+ _ZGVZN8internal6BridgeINS_13ToApplicationEE8instanceEvE6bridge@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZN8internal6BridgeINS_13ToApplicationEED1Ev@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZN8internal6BridgeINS_13ToApplicationEED2Ev@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZZN8internal6BridgeINS_13ToApplicationEE8instanceEvE6bridge@Base 0.18.1+13.10.20130703-0ubuntu2
  u_application_description_destroy@Base 0.18.1daily13.06.21
  u_application_description_new@Base 0.18.1daily13.06.21
  u_application_description_set_application_id@Base 0.18.1daily13.06.21
@@ -81,15 +78,6 @@
  uas_light_event_get_timestamp@Base 0.18.1daily13.06.21
  uas_proximity_event_get_distance@Base 0.18.1daily13.06.21
  uas_proximity_event_get_timestamp@Base 0.18.1daily13.06.21
- ubuntu_gps_delete@Base 0.18.1daily13.06.21
- ubuntu_gps_delete_aiding_data@Base 0.18.1daily13.06.21
- ubuntu_gps_inject_location@Base 0.18.1daily13.06.21
- ubuntu_gps_inject_time@Base 0.18.1daily13.06.21
- ubuntu_gps_inject_xtra_data@Base 0.18.1daily13.06.21
- ubuntu_gps_new@Base 0.18.1daily13.06.21
- ubuntu_gps_set_position_mode@Base 0.18.1daily13.06.21
- ubuntu_gps_start@Base 0.18.1daily13.06.21
- ubuntu_gps_stop@Base 0.18.1daily13.06.21
  ubuntu_ui_install_task_controller@Base 0.18.1daily13.06.21
  ubuntu_ui_report_notification_invisible@Base 0.18.1daily13.06.21
  ubuntu_ui_report_notification_visible@Base 0.18.1daily13.06.21
@@ -105,3 +93,17 @@
  ubuntu_ui_session_unfocus_running_sessions@Base 0.18.1daily13.06.21
  ubuntu_ui_set_surface_trap@Base 0.18.1daily13.06.21
  ubuntu_ui_unset_surface_trap@Base 0.18.1daily13.06.21
+libubuntu_platform_hardware_api.so.1 libplatform-api1-hybris #MINVER#
+ _ZGVZN8internal6BridgeINS_13ToApplicationEE8instanceEvE6bridge@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZN8internal6BridgeINS_13ToApplicationEED1Ev@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZN8internal6BridgeINS_13ToApplicationEED2Ev@Base 0.18.1+13.10.20130703-0ubuntu2
+ _ZZN8internal6BridgeINS_13ToApplicationEE8instanceEvE6bridge@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_delete@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_delete_aiding_data@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_inject_location@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_inject_time@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_inject_xtra_data@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_new@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_set_position_mode@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_start@Base 0.18.1+13.10.20130703-0ubuntu2
+ u_hardware_gps_stop@Base 0.18.1+13.10.20130703-0ubuntu2
 
=== modified file 'doc/CMakeLists.txt'
--- doc/CMakeLists.txt	2013-06-11 09:40:30 +0000
+++ doc/CMakeLists.txt	2013-07-05 09:17:25 +0000
@@ -26,5 +26,5 @@
     COMMENT "Generating API documentation with Doxygen" VERBATIM)
   install(
     DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
-    DESTINATION share/ubuntu-platform-api/doc)
+    DESTINATION share/doc/ubuntu-platform-api)
 endif(DOXYGEN_FOUND)
 \ No newline at end of file
 
=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2013-06-11 09:40:30 +0000
+++ doc/Doxyfile.in	2013-07-05 09:17:25 +0000
@@ -26,7 +26,7 @@
 # identify the project. Note that if you do not use Doxywizard you need
 # to put quotes around the project name if it contains spaces.
 
-PROJECT_NAME           = @CMAKE_PROJECT_NAME@
+PROJECT_NAME           = "Ubuntu Platform API"
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number.
 # This could be handy for archiving the generated documentation or
@@ -38,7 +38,7 @@
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          =
+PROJECT_BRIEF          = "A library helping with tight integration into the Ubuntu platform"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not
@@ -209,7 +209,7 @@
 # For instance, some of the names that are used will be different. The list
 # of all members will be omitted, etc.
 
-OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_FOR_C  = YES
 
 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
 # sources only. Doxygen will then generate output that is more tailored for
@@ -365,7 +365,7 @@
 # Private class members and static file members will be hidden unless
 # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
 
-EXTRACT_ALL            = NO
+EXTRACT_ALL            = YES
 
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
 # will be included in the documentation.
@@ -668,7 +668,7 @@
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/../include
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@ @CMAKE_CURRENT_SOURCE_DIR@/../include
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@@ -728,7 +728,7 @@
 # directories that contain example code fragments that are included (see
 # the \include command).
 
-EXAMPLE_PATH           = @CMAKE_CURRENT_SOURCE_DIR@/../examples
+EXAMPLE_PATH           = @CMAKE_CURRENT_SOURCE_DIR@/../src
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
@@ -791,7 +791,7 @@
 # This can be useful if you have a project on for instance GitHub and want reuse
 # the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = @CMAKE_CURRENT_SOURCE_DIR@/mainpage.md
 
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
@@ -807,7 +807,7 @@
 # Setting the INLINE_SOURCES tag to YES will include the body
 # of functions and classes directly in the documentation.
 
-INLINE_SOURCES         = YES
+INLINE_SOURCES         = NO
 
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 # doxygen to hide any special comment blocks from generated source code
@@ -975,7 +975,7 @@
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
 
-HTML_DYNAMIC_SECTIONS  = NO
+HTML_DYNAMIC_SECTIONS  = YES
 
 # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
 # entries shown in the various tree structured indices initially; the user
@@ -1145,7 +1145,7 @@
 # navigation tree you can set this option to NO if you already set
 # GENERATE_TREEVIEW to YES.
 
-DISABLE_INDEX          = NO
+DISABLE_INDEX          = YES
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information.
@@ -1157,7 +1157,7 @@
 # Since the tree basically has the same information as the tab index you
 # could consider to set DISABLE_INDEX to NO when enabling this option.
 
-GENERATE_TREEVIEW      = NO
+GENERATE_TREEVIEW      = YES
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
 # (range [0,1..20]) that doxygen will group on one line in the generated HTML
@@ -1434,7 +1434,7 @@
 # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
 # generate man pages
 
-GENERATE_MAN           = NO
+GENERATE_MAN           = YES
 
 # The MAN_OUTPUT tag is used to specify where the man pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 
=== modified file 'doc/mainpage.md'
--- doc/mainpage.md	2013-02-14 16:25:13 +0000
+++ doc/mainpage.md	2013-07-05 09:17:25 +0000
@@ -1,4 +1,4 @@
-Ubuntu Platform API	{#mainpage}
+Ubuntu Platform API {#mainpage}
 ===================
 
 The Ubuntu platform API Implements access to the Ubuntu platform and
 
=== modified file 'include/ubuntu/application/CMakeLists.txt'
--- include/ubuntu/application/CMakeLists.txt	2013-06-11 11:05:25 +0000
+++ include/ubuntu/application/CMakeLists.txt	2013-07-05 09:17:25 +0000
@@ -7,7 +7,6 @@
   lifecycle_delegate.h
   operation_mode.h
   options.h
-  ubuntu_application_gps.h
 )
 
 install(
@@ -16,4 +15,4 @@
 )
 
 add_subdirectory(sensors)
-add_subdirectory(ui)
 \ No newline at end of file
+add_subdirectory(ui)
 
=== modified file 'include/ubuntu/application/archive.h'
--- include/ubuntu/application/archive.h	2013-06-03 20:54:26 +0000
+++ include/ubuntu/application/archive.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_ARCHIVE_H_
@@ -26,139 +26,311 @@
 
 struct UApplicationArchive;
 
+/**
+ * \brief Creates a new archive, ownership is transferred to caller.
+ * \ingroup application_support
+ * \sa u_application_archive_destroy
+ * \returns A new archive instance or NULL if not enough memory is available.
+ */
 UApplicationArchive*
 u_application_archive_new();
 
+/**
+ * \brief Destroys the given archive instance and releases all resources held by the instance.
+ * \ingroup application_support
+ * \param[in] archive The instance to be destroyed.
+ * \post All resources held by the instance are released. The result of any operation invoked on the destroyed instance are undefined.
+ */
 void
 u_application_archive_destroy(
-	UApplicationArchive *archive);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	int8_t c);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	uint8_t c);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	int16_t s);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	uint16_t s);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	int32_t s);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	uint32_t s);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	int64_t s);
-
-UStatus
-u_application_archive_write(
-	UApplicationArchive *archive,
-	uint64_t s);
-
+    UApplicationArchive *archive);
+
+/**
+ * \brief Writes a signed 8-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] c The signed 8-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    int8_t c);
+
+/**
+ * \brief Writes an unsigned 8-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] c The unsigned 8-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    uint8_t c);
+
+/**
+ * \brief Writes a signed 16-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The signed 16-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    int16_t s);
+
+/**
+ * \brief Writes an unsigned 16-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The unsigned 16-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    uint16_t s);
+
+/**
+ * \brief Writes a signed 32-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The signed 32-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    int32_t s);
+
+/**
+ * \brief Writes an unsigned 32-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The unsigned 32-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    uint32_t s);
+
+/**
+ * \brief Writes a signed 64-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The signed 64-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    int64_t s);
+
+/**
+ * \brief Writes an unsigned 64-bit integer to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The unsigned 64-bit integer to write to the archive.
+ */
+UStatus
+u_application_archive_write(
+    UApplicationArchive *archive,
+    uint64_t s);
+
+/**
+ * \brief Writes a string of characters to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The string to write.
+ * \param[in] size The number of characters to write to the archive.
+ */
 UStatus
 u_application_archive_write_stringn(
-	UApplicationArchive *archive,
-	const char *s,
-	size_t size);
+    UApplicationArchive *archive,
+    const char *s,
+    size_t size);
 
+/**
+ * \brief Writes a string of wide characters to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] s The string to write.
+ * \param[in] size The number of characters to write to the archive.
+ */
 UStatus
 u_application_archive_write_wstringn(
-	UApplicationArchive *archive,
-	const wchar_t *s,
-	size_t size);
+    UApplicationArchive *archive,
+    const wchar_t *s,
+    size_t size);
 
+/**
+ * \brief Writes a blob of binary data to the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to write to.
+ * \param[in] data The binary blob to write.
+ * \param[in] size The size of the blob.
+ */
 UStatus
 u_application_archive_write_bytes(
-	UApplicationArchive *archive,
-	const intptr_t *data,
-	size_t size);
+    UApplicationArchive *archive,
+    const intptr_t *data,
+    size_t size);
 
 UStatus
 u_application_archive_write_begin_blockn(
-	UApplicationArchive* archive,
-	const char *name,
-	size_t size);
+    UApplicationArchive* archive,
+    const char *name,
+    size_t size);
 
 UStatus
 u_application_archive_write_end_blockn(
-	UApplicationArchive* archive,
-	const char *name,
-	size_t size);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	int8_t *c);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	uint8_t *c);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	int16_t *s);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	uint16_t *s);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	int32_t *s);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	uint32_t *s);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	int64_t *s);
-
-UStatus
-u_application_archive_read(
-	const UApplicationArchive *archive,
-	uint64_t *s);
-
+    UApplicationArchive* archive,
+    const char *name,
+    size_t size);
+
+/**
+ * \brief Reads a signed 8-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] c Pointer to memory that receives the signed 8-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    int8_t *c);
+
+/**
+ * \brief Reads an unsigned 8-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] c Pointer to memory that receives the unsigned 8-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    uint8_t *c);
+
+/**
+ * \brief Reads a signed 16-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the signed 16-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    int16_t *s);
+
+/**
+ * \brief Reads an unsigned 16-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the unsigned 16-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    uint16_t *s);
+
+/**
+ * \brief Reads a signed 32-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the signed 32-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    int32_t *s);
+
+/**
+ * \brief Reads an unsigned 32-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the unsigned 32-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    uint32_t *s);
+
+/**
+ * \brief Reads a signed 64-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the signed 64-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    int64_t *s);
+
+/**
+ * \brief Reads an unsigned 64-bit integer from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the unsigned 64-bit integer.
+ */
+UStatus
+u_application_archive_read(
+    const UApplicationArchive *archive,
+    uint64_t *s);
+
+/**
+ * \brief Reads a string of characters from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the string.
+ * \param[out] size Pointer to memory that receives the size of the string.
+ */
 UStatus
 u_application_archive_read_stringn(
-	const UApplicationArchive *archive,
-	const char **s,
-	size_t *size);
+    const UApplicationArchive *archive,
+    const char **s,
+    size_t *size);
 
+/**
+ * \brief Reads a string of wide characters from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] s Pointer to memory that receives the wide string.
+ * \param[out] size Pointer to memory that receives the size of the string.
+ */
 UStatus
 u_application_archive_read_wstringn(
-	UApplicationArchive *archive,
-	const wchar_t *s,
-	size_t size);
+    UApplicationArchive *archive,
+    const wchar_t *s,
+    size_t size);
 
+/**
+ * \brief Reads a blob of binary data from the supplied archive
+ * \ingroup application_support
+ * \returns U_STATUS_SUCCESS if successful, and U_STATUS_ERROR in case of failures.
+ * \param[in] archive The archive to read from.
+ * \param[out] data Pointer to memory that receives the binary data.
+ * \param[out] size Pointer to memory that receives the size of the blob.
+ */
 UStatus
 u_application_archive_read_bytes(
-	UApplicationArchive *archive,
-	const intptr_t *data,
-	size_t size);
+    UApplicationArchive *archive,
+    const intptr_t *data,
+    size_t size);
 
 #endif /* UBUNTU_APPLICATION_ARCHIVE_H_ */
 
=== modified file 'include/ubuntu/application/description.h'
--- include/ubuntu/application/description.h	2013-05-27 22:14:00 +0000
+++ include/ubuntu/application/description.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_DESCRIPTION_H_
@@ -27,33 +27,71 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Encapsulates properties of an application instance.
+     * \ingroup application_support
+     */
     typedef void UApplicationDescription;
-    
+
+    /**
+     * \brief Creates a new instance of application description.
+     * \ingroup application_support
+     * \returns A new application description instance or NULL if not enough memory is available.
+     */
     UApplicationDescription*
     u_application_description_new();
-    
+
+    /**
+     * \brief Destroys an instance of application description and releases all resources.
+     * \ingroup application_support
+     * \param[in] desc The instance to be destroyed.
+     */
     void
     u_application_description_destroy(
-    	UApplicationDescription *desc);
-    
+        UApplicationDescription *desc);
+
+    /**
+     * \brief Sets the application id contained in the description instance.
+     * \ingroup application_support
+     * \param[in] desc The application description instance, must not be NULL.
+     * \param[in] id The new application id, must not be NULL.
+     */
     void
     u_application_description_set_application_id(
-    	UApplicationDescription *desc,
-    	UApplicationId *id);
-    
-    UApplicationId* 
+        UApplicationDescription *desc,
+        UApplicationId *id);
+
+    /**
+     * \brief Queries the application id contained in the description instance.
+     * \ingroup application_support
+     * \returns The app id contained in the instance.
+     * \param[in] desc The application description instance, must not be NULL.
+     */
+    UApplicationId*
     u_application_description_get_application_id(
-    	UApplicationDescription *desc);
-    
+        UApplicationDescription *desc);
+
+    /**
+     * \brief Sets the application lifecycle delegate
+     * \ingroup application_support
+     * \param[in] desc The application description instance, must not be NULL.
+     * \param[in] lifecycle_delegate The new lifecycle delegate, must not be NULL.
+     */
     void
     u_application_description_set_application_lifecycle_delegate(
-    	UApplicationDescription *desc,
-    	UApplicationLifecycleDelegate *lifecycle_delegate);
-    
-    UApplicationLifecycleDelegate* 
+        UApplicationDescription *desc,
+        UApplicationLifecycleDelegate *lifecycle_delegate);
+
+    /**
+     * \brief Queries the application lifecycle delegate
+     * \ingroup application_support
+     * \returns The application lifecycle delegate contained in the description instance.
+     * \param[in] desc The application description instance, must not be NULL.
+     */
+    UApplicationLifecycleDelegate*
     u_application_description_get_application_lifecycle_delegate(
-    	UApplicationDescription *desc);
-   
+        UApplicationDescription *desc);
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'include/ubuntu/application/id.h'
--- include/ubuntu/application/id.h	2013-06-04 22:08:07 +0000
+++ include/ubuntu/application/id.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_ID_H_
@@ -26,21 +26,43 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief An opaque type describing an application ID.
+     * \ingroup application_support
+     */
     typedef void UApplicationId;
-    
+
+    /**
+     * \brief Creates a new application ID from an existing string.
+     * \ingroup application_support
+     * \param[in] string The string containing the application ID.
+     * \param[in] size The size of the string.
+     */
     UApplicationId*
     u_application_id_new_from_stringn(
-    	const char *string, 
-    	size_t size);
-    
+        const char *string,
+        size_t size);
+
+    /**
+     * \brief Destroy the supplied application ID instance.
+     * \ingroup application_support
+     * \param[in] id The instance to be destroyed.
+     */
     void
     u_application_id_destroy(UApplicationId *id);
-    
+
+    /**
+     * \brief Compares two application ID instances.
+     * \ingroup application_support
+     * \returns -1 iff lhs < rhs, 0 iff lhs == rhs, 1 iff lhs > rhs.
+     * \param[in] lhs The left-hand-side id to be compared.
+     * \param[in] rhs The right-hand-side id to be compared.
+     */
     int
     u_application_id_compare(
-    	UApplicationId *lhs,
-    	UApplicationId *rhs);
-       
+        UApplicationId *lhs,
+        UApplicationId *rhs);
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'include/ubuntu/application/instance.h'
--- include/ubuntu/application/instance.h	2013-05-27 22:14:00 +0000
+++ include/ubuntu/application/instance.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_INSTANCE_H_
@@ -27,31 +27,65 @@
 extern "C" {
 #endif
 
+    /** \defgroup application_support Functions and types to support application development. */
+
+    /**
+     * \brief Opaque type describing an application instance.
+     * \ingroup application_support
+     * An application instance encapsulates the event loop of an app.
+     */
     typedef void UApplicationInstance;
-    
+
+    /**
+     * \brief Creates a new application instance with a reference count of 1.
+     * \ingroup application_support
+     * \returns A new application instance or NULL in case of low-memory.
+     * \param[in] desc A description object, must not be NULL.
+     * \param[in] options An options object, must not be NULL.
+     */
     UApplicationInstance*
     u_application_instance_new_from_description_with_options(
-    	UApplicationDescription *desc,
-    	UApplicationOptions *options);
-    
+        UApplicationDescription *desc,
+        UApplicationOptions *options);
+
+    /**
+     * \brief Increments the reference count of an application instance.
+     * \ingroup application_support
+     * \param[in] instance The instance to increment the reference count for.
+     */
     void
     u_application_instance_ref(
-    	UApplicationInstance *instance);
-    
+        UApplicationInstance *instance);
+
+    /**
+     * \brief Decrements the reference count of an application instance and releases all resources held by the object if the reference count reaches 0.
+     * \ingroup application_support
+     * \param[in] instance The instance to decrement the reference count for.
+     */
     void
     u_application_instance_unref(
-    	UApplicationInstance *instance);
-    
+        UApplicationInstance *instance);
+
+    /**
+     * \brief Destroys the application instance and releases all its resources.
+     * \ingroup application_support
+     * \param[in] instance The instance to be destroyed.
+     */
     void
     u_application_instance_destroy(
-    	UApplicationInstance *instance);
-    
+        UApplicationInstance *instance);
+
+    /**
+     * \brief Executes the event loop of the application instance
+     * \ingroup application_support
+     * \param[in] instance The instance to be executed.
+     */
     void
     u_application_instance_run(
-    	UApplicationInstance *instance);
+        UApplicationInstance *instance);
 
 #ifdef __cplusplus
 }
 #endif
-    
+
 #endif /* UBUNTU_APPLICATION_INSTANCE_H_ */
 
=== modified file 'include/ubuntu/application/lifecycle_delegate.h'
--- include/ubuntu/application/lifecycle_delegate.h	2013-05-27 21:49:05 +0000
+++ include/ubuntu/application/lifecycle_delegate.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_LIFECYCLE_DELEGATE_H_
@@ -26,55 +26,127 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-    
+
+    /**
+     * \brief Prototype for the callback that is invoked whenever the app has been resumed.
+     * \ingroup application_support
+     * \param[in] options Application instance options
+     * \param[in] context The callback context as specified by the application
+     */
     typedef void (*u_on_application_resumed)(const UApplicationOptions *options, void *context);
+    /**
+     * \brief Prototype for the callback that is invoked whenever the app is about to be stopped.
+     * Applications can serialize their state to the supplied archive.
+     * \ingroup application_support
+     */
     typedef void (*u_on_application_about_to_stop)(UApplicationArchive *archive, void *context);
-    
+
+    /**
+     * \brief Opaque type encapsulating all app-specific callback functions.
+     * \ingroup application_support
+     */
     typedef void UApplicationLifecycleDelegate;
-    
+
+    /**
+     * \brief Creates a new instance of the lifecycle delegate with an initial refernce count of 1.
+     * \ingroup application_support
+     * \returns A new instance of the lifecycle delegate or NULL if no memory is available.
+     */
     UApplicationLifecycleDelegate*
     u_application_lifecycle_delegate_new();
-    
+
+    /**
+     * \brief Destroys an instance of the lifecycle delegate and releases all of its resources.
+     * \ingroup application_support
+     * \param[in] delegate The instance to be destroyed.
+     */
     void
     u_application_lifecycle_delegate_destroy(
         UApplicationLifecycleDelegate *delegate);
-    
+
+    /**
+     * \brief Increments the reference count of the supplied lifecycle delegate.
+     * \ingroup application_support
+     * \param[in] delegate The lifecycle delegate to increment the reference count for.
+     */
     void
     u_application_lifecycle_delegate_ref(
         UApplicationLifecycleDelegate *delegate);
-    
+
+    /**
+     * \brief Decrements the reference count of the supplied lifecycle delegate and destroys it if the count reaches 0.
+     * \ingroup application_support
+     * \param[in] delegate The lifecycle delegate to decrement the reference count for.
+     */
     void
     u_application_lifecycle_delegate_unref(
         UApplicationLifecycleDelegate *delegate);
-    
+
+    /**
+     * \brief Sets the resumed cb for the supplied delegate.
+     * \ingroup application_support
+     * \param[in] delegate The lifecycle delegate to adjust the cb for.
+     * \param[in] cb The new callback to be invoked whenever the app resumes.
+     */
     void
     u_application_lifecycle_delegate_set_application_resumed_cb(
         UApplicationLifecycleDelegate *delegate,
         u_on_application_resumed cb);
-    
+
+    /**
+     * \brief Queries the resumed cb from the supplied delegate.
+     * \ingroup application_support
+     * \returns The callback to be invoked whenever the app resumes.
+     * \param[in] delegate The lifecycle delegate to query the callback from.
+     */
     u_on_application_resumed
     u_application_lifecycle_delegate_get_application_resumed_cb(
         UApplicationLifecycleDelegate *delegate);
-    
+
+    /**
+     * \brief Sets the about-to-stop cb for the supplied delegate.
+     * \ingroup application_support
+     * \param[in] delegate The lifecycle delegate to adjust the cb for.
+     * \param[in] cb The new callback to be invoked whenever the app is about to be stopped..
+     */
     void
     u_application_lifecycle_delegate_set_application_about_to_stop_cb(
         UApplicationLifecycleDelegate *delegate,
         u_on_application_about_to_stop cb);
-    
+
+    /**
+     * \brief Queries the about-to-be-stopped cb from the supplied delegate.
+     * \ingroup application_support
+     * \returns The callback to be invoked whenever the app is about to be stopped.
+     * \param[in] delegate The lifecycle delegate to query the callback from.
+     */
     u_on_application_about_to_stop
     u_application_lifecycle_delegate_get_application_about_to_stop_cb(
         UApplicationLifecycleDelegate *delegate);
-    
+
+    /**
+     * \brief Sets the cb context for the supplied delegate.
+     * \ingroup application_support
+     * \param[in] delegate The lifecycle delegate to adjust the context for.
+     * \param[in] context The new cb context.
+     */
     void
     u_application_lifecycle_delegate_set_context(
         UApplicationLifecycleDelegate *delegate,
         void *context);
-    
+
+    /**
+     * \brief Queries the cb context from the supplied delegate.
+     * \ingroup application_support
+     * \returns The context that is passed to callbacks of this delegate.
+     * \param[in] delegate The lifecycle delegate to query the context from.
+     * \param[in] context Unused.
+     */
     void*
     u_application_lifecycle_delegate_get_context(
         UApplicationLifecycleDelegate *delegate,
         void *context);
-    
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'include/ubuntu/application/operation_mode.h'
--- include/ubuntu/application/operation_mode.h	2013-05-27 21:49:05 +0000
+++ include/ubuntu/application/operation_mode.h	2013-07-05 09:17:25 +0000
@@ -14,16 +14,20 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_OPERATION_MODE_H_
 #define UBUNTU_APPLICATION_OPERATION_MODE_H_
 
+/**
+ * \brief Describes the different operational modes that an
+ * application can run in.
+ */
 typedef enum
 {
-	U_APPLICATION_FOREGROUND_APP,
-	U_APPLICATION_BACKGROUND_SERVICE
+    U_APPLICATION_FOREGROUND_APP,
+    U_APPLICATION_BACKGROUND_SERVICE
 } UApplicationOperationMode;
 
 #endif /* UBUNTU_APPLICATION_OPERATION_MODE_H_ */
 
=== modified file 'include/ubuntu/application/options.h'
--- include/ubuntu/application/options.h	2013-05-27 22:14:00 +0000
+++ include/ubuntu/application/options.h	2013-07-05 09:17:25 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Ricardo Mendoza <[e-mail]>
- *              Thomas Voß <[e-mail]>           
+ *              Thomas Voß <[e-mail]>
  */
 
 #ifndef UBUNTU_APPLICATION_OPTIONS_H_
@@ -26,21 +26,43 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Encapsulates options as passed to the application.
+     * \ingroup application_support
+     */
     typedef void UApplicationOptions;
-    
+
+    /**
+     * \brief Parses options from the command line.
+     * \ingroup application_support
+     * \returns An options instance if parsing was successful, or 0 otheriwse.
+     * \param[in] argc Number of arguments.
+     * \param[in] argv Arguments.
+     */
     UApplicationOptions*
     u_application_options_new_from_cmd_line(
-    	int argc, 
-    	char** argv);
-    
+        int argc,
+        char** argv);
+
+    /**
+     * \brief Destroys the options object and releases all resources.
+     * \ingroup application_support
+     * \param[in] options The object to be destroyed.
+     */
     void
     u_application_options_destroy(
-    	UApplicationOptions *options);
-    
+        UApplicationOptions *options);
+
+    /**
+     * \brief Queries the operation mode from the supplied options object.
+     * \ingroup application_support
+     * \returns The operation mode as stored in the options object.
+     * \param[in] options The options object to be queried.
+     */
     UApplicationOperationMode
     u_application_options_get_operation_mode(
-    	UApplicationOptions *options);
-       
+        UApplicationOptions *options);
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'include/ubuntu/application/sensors/accelerometer.h'
--- include/ubuntu/application/sensors/accelerometer.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/accelerometer.h	2013-07-05 09:17:25 +0000
@@ -26,36 +26,94 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Opaque type that models the accelerometer.
+     * \ingroup sensor_access
+     */
     typedef void UASensorsAccelerometer;
+
+    /**
+     * \brief Callback type used by applications to subscribe to accelerometer events.
+     * \ingroup sensor_access
+     */
     typedef void (*on_accelerometer_event_cb)(UASAccelerometerEvent* event,
                                               void* context);
 
+    /**
+     * \brief Create a new object for accessing the accelerometer.
+     * \ingroup sensor_access
+     * \returns A new instance or NULL in case of errors.
+     */
     UASensorsAccelerometer*
-    ua_sensors_accelerometer_new(); 
+    ua_sensors_accelerometer_new();
 
+    /**
+     * \brief Enables the supplied accelerometer.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be enabled.
+     */
     UStatus
     ua_sensors_accelerometer_enable(
         UASensorsAccelerometer* sensor);
 
+    /**
+     * \brief Disables the supplied accelerometer.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be disabled.
+     */
     UStatus
     ua_sensors_accelerometer_disable(
         UASensorsAccelerometer* sensor);
 
+    /**
+     * \brief Queries the minimum delay between two readings for the supplied sensor.
+     * \ingroup sensor_access
+     * \returns The minimum delay between two readings in [ms].
+     * \param[in] sensor The sensor instance to be queried.
+     */
     uint32_t
     ua_sensors_accelerometer_get_min_delay(
         UASensorsAccelerometer* sensor);
-    
+
+    /**
+     * \brief Queries the minimum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The minimum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_accelerometer_get_min_value(
         UASensorsAccelerometer* sensor);
-  
+
+    /**
+     * \brief Queries the maximum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The maximum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_accelerometer_get_max_value(
         UASensorsAccelerometer* sensor);
- 
+
+    /**
+     * \brief Queries the numeric resolution supported by the sensor
+     * \ingroup sensor_access
+     * \returns The numeric resolution supported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_accelerometer_get_resolution(
         UASensorsAccelerometer* sensor);
+
+    /**
+     * \brief Set the callback to be invoked whenever a new sensor reading is available.
+     * \ingroup sensor_access
+     * \param[in] sensor The sensor instance to associate the callback with.
+     * \param[in] cb The callback to be invoked.
+     * \param[in] ctx The context supplied to the callback invocation.
+     */
     void
     ua_sensors_accelerometer_set_reading_cb(
         UASensorsAccelerometer* sensor,
 
=== modified file 'include/ubuntu/application/sensors/event/accelerometer.h'
--- include/ubuntu/application/sensors/event/accelerometer.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/event/accelerometer.h	2013-07-05 09:17:25 +0000
@@ -25,20 +25,48 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Opaque type describing an accelerometer reading.
+     * \ingroup sensor_access
+     */
     typedef void UASAccelerometerEvent;
 
+    /**
+     * \brief Query the timestamp of the sensor reading.
+     * \ingroup sensor_access
+     * \returns The timestamp of the sensor reading in [µs], timebase: monotonic clock.
+     * \param[in] event The reading to be queried.
+     */
     uint64_t
     uas_accelerometer_event_get_timestamp(
         UASAccelerometerEvent* event);
-   
+
+    /**
+     * \brief Query the acceleration in x-axis direction.
+     * \ingroup sensor_access
+     * \returns The acceleration in x-axis direction.
+     * \param[in] event The reading to be queried.
+     */
     float
     uas_accelerometer_event_get_acceleration_x(
         UASAccelerometerEvent* event);
-  
+
+    /**
+     * \brief Query the acceleration in y-axis direction.
+     * \ingroup sensor_access
+     * \returns The acceleration in y-axis direction.
+     * \param[in] event The reading to be queried.
+     */
     float
     uas_accelerometer_event_get_acceleration_y(
         UASAccelerometerEvent* event);
-  
+
+    /**
+     * \brief Query the acceleration in z-axis direction.
+     * \ingroup sensor_access
+     * \returns The acceleration in z-axis direction.
+     * \param[in] event The reading to be queried.
+     */
     float
     uas_accelerometer_event_get_acceleration_z(
         UASAccelerometerEvent* event);
 
=== modified file 'include/ubuntu/application/sensors/event/light.h'
--- include/ubuntu/application/sensors/event/light.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/event/light.h	2013-07-05 09:17:25 +0000
@@ -25,12 +25,28 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Opaque type describing an ambient light sensor reading.
+     * \ingroup sensor_access
+     */
     typedef void UASLightEvent;
 
+    /**
+     * \brief Query the timestamp of the sensor reading.
+     * \ingroup sensor_access
+     * \returns The timestamp of the sensor reading in [µs], timebase: monotonic clock.
+     * \param[in] event The reading to be queried.
+     */
     uint64_t
     uas_light_event_get_timestamp(
         UASLightEvent* event);
-   
+
+    /**
+     * \brief Query the value measured by the ambient light sensor.
+     * \ingroup sensor_access
+     * \returns The ambient light level.
+     * \param[in] event The reading to be queried.
+     */
     float
     uas_light_event_get_light(
         UASLightEvent* event);
 
=== modified file 'include/ubuntu/application/sensors/event/proximity.h'
--- include/ubuntu/application/sensors/event/proximity.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/event/proximity.h	2013-07-05 09:17:25 +0000
@@ -25,17 +25,39 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Useful constants when inspecting readings from the proximity sensor.
+     * \ingroup sensor_access
+     */
     typedef enum {
-        U_PROXIMITY_NEAR = 1,
-        U_PROXIMITY_FAR = 2
-    } UASProximityDistance;
-
+        U_PROXIMITY_NEAR = 1, /**< The reading indicates that something is near the sensor/device. */
+        U_PROXIMITY_FAR = 2 /**< The reading indicates that something is far away from the sensor/device. */
+    } UbuntuApplicationSensorsProximityDistance;
+
+    typedef UbuntuApplicationSensorsProximityDistance UASProximityDistance;
+
+    /**
+     * \brief Opaque type describing an accelerometer reading.
+     * \ingroup sensor_access
+     */
     typedef void UASProximityEvent;
 
+    /**
+     * \brief Query the timestamp of the sensor reading.
+     * \ingroup sensor_access
+     * \returns The timestamp of the sensor reading in [µs], timebase: monotonic clock.
+     * \param[in] event The reading to be queried.
+     */
     uint64_t
     uas_proximity_event_get_timestamp(
         UASProximityEvent* event);
-   
+
+    /**
+     * \brief Query the discrete distance as reported by the proximity sensor.
+     * \ingroup sensor_access
+     * \returns The discrete distance as reported by the proximity sensor.
+     * \param[in] event The reading to be queried.
+     */
     UASProximityDistance
     uas_proximity_event_get_distance(
         UASProximityEvent* event);
 
=== modified file 'include/ubuntu/application/sensors/light.h'
--- include/ubuntu/application/sensors/light.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/light.h	2013-07-05 09:17:25 +0000
@@ -26,36 +26,94 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Opaque type that models the ambient light sensor.
+     * \ingroup sensor_access
+     */
     typedef void UASensorsLight;
+
+    /**
+     * \brief Callback type used by applications to subscribe to ambient light sensor events.
+     * \ingroup sensor_access
+     */
     typedef void (*on_light_event_cb)(UASLightEvent* event,
                                       void* context);
 
+    /**
+     * \brief Create a new object for accessing the ambient light sensor.
+     * \ingroup sensor_access
+     * \returns A new instance or NULL in case of errors.
+     */
     UASensorsLight*
-    ua_sensors_light_new(); 
-
-    UStatus
-    ua_sensors_light_enable(
-        UASensorsLight* sensor);
-
-    UStatus
-    ua_sensors_light_enable(
-        UASensorsLight* sensor);
-
+    ua_sensors_light_new();
+
+    /**
+     * \brief Enables the supplied ambient light sensor.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be enabled.
+     */
+    UStatus
+    ua_sensors_light_enable(
+        UASensorsLight* sensor);
+
+    /**
+     * \brief Disables the supplied ambient light sensor.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be disabled.
+     */
+    UStatus
+    ua_sensors_light_enable(
+        UASensorsLight* sensor);
+
+    /**
+     * \brief Queries the minimum delay between two readings for the supplied sensor.
+     * \ingroup sensor_access
+     * \returns The minimum delay between two readings in [ms].
+     * \param[in] sensor The sensor instance to be queried.
+     */
     uint32_t
     ua_sensors_light_get_min_delay(
         UASensorsLight* sensor);
-    
+
+    /**
+     * \brief Queries the minimum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The minimum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_light_get_min_value(
         UASensorsLight* sensor);
-  
+
+    /**
+     * \brief Queries the maximum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The maximum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_light_get_max_value(
         UASensorsLight* sensor);
- 
+
+    /**
+     * \brief Queries the numeric resolution supported by the sensor
+     * \ingroup sensor_access
+     * \returns The numeric resolution supported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_light_get_resolution(
         UASensorsLight* sensor);
+
+    /**
+     * \brief Set the callback to be invoked whenever a new sensor reading is available.
+     * \ingroup sensor_access
+     * \param[in] sensor The sensor instance to associate the callback with.
+     * \param[in] cb The callback to be invoked.
+     * \param[in] ctx The context supplied to the callback invocation.
+     */
     void
     ua_sensors_light_set_reading_cb(
         UASensorsLight* sensor,
 
=== modified file 'include/ubuntu/application/sensors/proximity.h'
--- include/ubuntu/application/sensors/proximity.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/application/sensors/proximity.h	2013-07-05 09:17:25 +0000
@@ -26,36 +26,94 @@
 extern "C" {
 #endif
 
+    /**
+     * \brief Opaque type that models the proximity sensor.
+     * \ingroup sensor_access
+     */
     typedef void UASensorsProximity;
+
+    /**
+     * \brief Callback type used by applications to subscribe to proximity sensor events.
+     * \ingroup sensor_access
+     */
     typedef void (*on_proximity_event_cb)(UASProximityEvent* event,
                                           void* context);
 
+    /**
+     * \brief Create a new object for accessing the proximity sensor.
+     * \ingroup sensor_access
+     * \returns A new instance or NULL in case of errors.
+     */
     UASensorsProximity*
-    ua_sensors_proximity_new(); 
+    ua_sensors_proximity_new();
 
+    /**
+     * \brief Enables the supplied proximity sensor.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be enabled.
+     */
     UStatus
     ua_sensors_proximity_enable(
         UASensorsProximity* sensor);
 
+    /**
+     * \brief Disables the supplied proximity sensor.
+     * \ingroup sensor_access
+     * \returns U_STATUS_SUCCESS if successful or U_STATUS_ERROR if an error occured.
+     * \param[in] sensor The sensor instance to be disabled.
+     */
     UStatus
     ua_sensors_proximity_disable(
         UASensorsProximity* sensor);
 
+    /**
+     * \brief Queries the minimum delay between two readings for the supplied sensor.
+     * \ingroup sensor_access
+     * \returns The minimum delay between two readings in [ms].
+     * \param[in] sensor The sensor instance to be queried.
+     */
     uint32_t
     ua_sensors_proximity_get_min_delay(
         UASensorsProximity* sensor);
-    
+
+    /**
+     * \brief Queries the minimum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The minimum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_proximity_get_min_value(
         UASensorsProximity* sensor);
-  
+
+    /**
+     * \brief Queries the maximum value that can be reported by the sensor.
+     * \ingroup sensor_access
+     * \returns The maximum value that can be reported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_proximity_get_max_value(
         UASensorsProximity* sensor);
- 
+
+    /**
+     * \brief Queries the numeric resolution supported by the sensor
+     * \ingroup sensor_access
+     * \returns The numeric resolution supported by the sensor.
+     * \param[in] sensor The sensor instance to be queried.
+     */
     float
     ua_sensors_proximity_get_resolution(
         UASensorsProximity* sensor);
+
+    /**
+     * \brief Set the callback to be invoked whenever a new sensor reading is available.
+     * \ingroup sensor_access
+     * \param[in] sensor The sensor instance to associate the callback with.
+     * \param[in] cb The callback to be invoked.
+     * \param[in] ctx The context supplied to the callback invocation.
+     */
     void
     ua_sensors_proximity_set_reading_cb(
         UASensorsProximity* sensor,
 
=== added directory 'include/ubuntu/hardware'
=== renamed file 'include/ubuntu/application/ubuntu_application_gps.h' => 'include/ubuntu/hardware/gps.h'
--- include/ubuntu/application/ubuntu_application_gps.h	2013-05-27 21:49:05 +0000
+++ include/ubuntu/hardware/gps.h	2013-07-05 09:17:25 +0000
@@ -14,9 +14,10 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Daniel d'Andrada <[e-mail]>
+ * Authored by: Thomas Voß <[e-mail]>
  */
-#ifndef UBUNTU_APPLICATION_GPS_H_
-#define UBUNTU_APPLICATION_GPS_H_
+#ifndef UBUNTU_HARDWARE_GPS_H_
+#define UBUNTU_HARDWARE_GPS_H_
 
 #include <stdint.h>
 #include <stddef.h>
@@ -25,149 +26,170 @@
 extern "C" {
 #endif
 
-/** \defgroup gps_access Functions and types for accessing location services. */
+/** \defgroup gps_access Functions and types for accessing GPS H/W. */
+
+/**
+ * Maximum number of SVs for u_hardware_gps_sv_status_callback().
+ * \ingroup gps_access
+ */
+#define U_HARDWARE_GPS_MAX_SVS 32
 
 /** 
- * Maximum number of SVs for gps_sv_status_callback(). 
+ * The status of the GPS hardware.
  * \ingroup gps_access
  */
-#define UBUNTU_GPS_MAX_SVS 32
-
 enum
 {
     /** GPS status unknown. */
-    UBUNTU_GPS_STATUS_NONE = 0,
+    U_HARDWARE_GPS_STATUS_NONE = 0,
     /** GPS has begun navigating. */
-    UBUNTU_GPS_STATUS_SESSION_BEGIN = 1,
+    U_HARDWARE_GPS_STATUS_SESSION_BEGIN = 1,
     /** GPS has stopped navigating. */
-    UBUNTU_GPS_STATUS_SESSION_END = 2,
+    U_HARDWARE_GPS_STATUS_SESSION_END = 2,
     /** GPS has powered on but is not navigating. */
-    UBUNTU_GPS_STATUS_ENGINE_ON = 3,
+    U_HARDWARE_GPS_STATUS_ENGINE_ON = 3,
     /** GPS is powered off. */
-    UBUNTU_GPS_STATUS_ENGINE_OFF = 4
+    U_HARDWARE_GPS_STATUS_ENGINE_OFF = 4
 };
 
-/** 
+/**
  * Flags for the gps_set_capabilities callback.
  * \ingroup gps_access
- * GPS HAL schedules fixes for UBUNTU_GPS_POSITION_RECURRENCE_PERIODIC mode.
+ * GPS HAL schedules fixes for U_HARDWARE_GPS_POSITION_RECURRENCE_PERIODIC mode.
  * If this is not set, then the framework will use 1000ms for min_interval
  * and will start and call start() and stop() to schedule the GPS.
  */
-#define UBUNTU_GPS_CAPABILITY_SCHEDULING       0x0000001
+#define U_HARDWARE_GPS_CAPABILITY_SCHEDULING       0x0000001
 /** GPS supports MS-Based AGPS mode */
-#define UBUNTU_GPS_CAPABILITY_MSB              0x0000002
+#define U_HARDWARE_GPS_CAPABILITY_MSB              0x0000002
 /** GPS supports MS-Assisted AGPS mode */
-#define UBUNTU_GPS_CAPABILITY_MSA              0x0000004
+#define U_HARDWARE_GPS_CAPABILITY_MSA              0x0000004
 /** GPS supports single-shot fixes */
-#define UBUNTU_GPS_CAPABILITY_SINGLE_SHOT      0x0000008
+#define U_HARDWARE_GPS_CAPABILITY_SINGLE_SHOT      0x0000008
 /** GPS supports on demand time injection */
-#define UBUNTU_GPS_CAPABILITY_ON_DEMAND_TIME   0x0000010
+#define U_HARDWARE_GPS_CAPABILITY_ON_DEMAND_TIME   0x0000010
 
 /**
- * UbuntuGpsNiNotifyFlags constants
+ * UHardwareGpsNiNotifyFlags constants
  * \ingroup gps_access
  */
-typedef uint32_t UbuntuGpsNiNotifyFlags;
+typedef uint32_t UHardwareGpsNiNotifyFlags;
 /** NI requires notification */
-#define UBUNTU_GPS_NI_NEED_NOTIFY          0x0001
+#define U_HARDWARE_GPS_NI_NEED_NOTIFY          0x0001
 /** NI requires verification */
-#define UBUNTU_GPS_NI_NEED_VERIFY          0x0002
+#define U_HARDWARE_GPS_NI_NEED_VERIFY          0x0002
 /** NI requires privacy override, no notification/minimal trace */
-#define UBUNTU_GPS_NI_PRIVACY_OVERRIDE     0x0004
+#define U_HARDWARE_GPS_NI_PRIVACY_OVERRIDE     0x0004
 
 /**
  * GPS NI responses, used to define the response in
  * NI structures
  * \ingroup gps_access
  */
-typedef int UbuntuGpsUserResponseType;
+typedef int UHardwareGpsUserResponseType;
+
 enum
 {
-    UBUNTU_UBUNTU_GPS_NI_RESPONSE_ACCEPT = 1,
-    UBUNTU_UBUNTU_GPS_NI_RESPONSE_DENY = 2,
-    UBUNTU_UBUNTU_GPS_NI_RESPONSE_NORESP = 3
+    U_HARDWARE_GPS_NI_RESPONSE_ACCEPT = 1,
+    U_HARDWARE_GPS_NI_RESPONSE_DENY = 2,
+    U_HARDWARE_GPS_NI_RESPONSE_NORESP = 3
 };
 
 enum
 {
-    UBUNTU_GPS_NI_TYPE_VOICE = 1,
-    UBUNTU_GPS_NI_TYPE_UMTS_SUPL = 2,
-    UBUNTU_GPS_NI_TYPE_UMTS_CTRL_PLANE = 3
+    U_HARDWARE_GPS_NI_TYPE_VOICE = 1,
+    U_HARDWARE_GPS_NI_TYPE_UMTS_SUPL = 2,
+    U_HARDWARE_GPS_NI_TYPE_UMTS_CTRL_PLANE = 3
 };
 
 /**
  * String length constants
  * \ingroup gps_access
  */
-#define UBUNTU_GPS_NI_SHORT_STRING_MAXLEN      256
-#define UBUNTU_GPS_NI_LONG_STRING_MAXLEN       2048
+#define U_HARDWARE_GPS_NI_SHORT_STRING_MAXLEN      256
+#define U_HARDWARE_GPS_NI_LONG_STRING_MAXLEN       2048
 
 /**
  * NI data encoding scheme
  * \ingroup gps_access
  */
-typedef int UbuntuGpsNiEncodingType;
-enum
-{
-    UBUNTU_GPS_ENC_NONE = 0,
-    UBUNTU_GPS_ENC_SUPL_GSM_DEFAULT = 1,
-    UBUNTU_GPS_ENC_SUPL_UTF8 = 2,
-    UBUNTU_GPS_ENC_SUPL_UCS2 = 3,
-    UBUNTU_GPS_ENC_UNKNOWN   = -1
-};
-
-enum
-{
-    UBUNTU_AGPS_TYPE_SUPL = 1,
-    UBUNTU_AGPS_TYPE_C2K = 2
-};
-
-
+typedef int UHardwareGpsNiEncodingType;
+
+/**
+ * Known encoding types for Ni responses
+ * \ingroup gps_access
+ */
+enum
+{
+    U_HARDWARE_GPS_ENC_NONE = 0,
+    U_HARDWARE_GPS_ENC_SUPL_GSM_DEFAULT = 1,
+    U_HARDWARE_GPS_ENC_SUPL_UTF8 = 2,
+    U_HARDWARE_GPS_ENC_SUPL_UCS2 = 3,
+    U_HARDWARE_GPS_ENC_UNKNOWN   = -1
+};
+
+/**
+ * Known AGPS types
+ * \ingroup gps_access
+ */
+enum
+{
+    U_HARDWARE_GPS_AGPS_TYPE_SUPL = 1,
+    U_HARDWARE_GPS_AGPS_TYPE_C2K = 2
+};
+
+/**
+ * Known positioning modes
+ * \ingroup gps_access
+ */
 enum
 {
     /** Mode for running GPS standalone (no assistance). */
-    UBUNTU_GPS_POSITION_MODE_STANDALONE = 0,
+    U_HARDWARE_GPS_POSITION_MODE_STANDALONE = 0,
     /** AGPS MS-Based mode. */
-    UBUNTU_GPS_POSITION_MODE_MS_BASED = 1,
+    U_HARDWARE_GPS_POSITION_MODE_MS_BASED = 1,
     /** AGPS MS-Assisted mode. */
-    UBUNTU_GPS_POSITION_MODE_MS_ASSISTED = 2
+    U_HARDWARE_GPS_POSITION_MODE_MS_ASSISTED = 2
 };
 
+/**
+ * Known positioning modes
+ * \ingroup gps_access
+ */
 enum
 {
     /** Receive GPS fixes on a recurring basis at a specified period. */
-    UBUNTU_GPS_POSITION_RECURRENCE_PERIODIC = 0,
+    U_HARDWARE_GPS_POSITION_RECURRENCE_PERIODIC = 0,
     /** Request a single shot GPS fix. */
-    UBUNTU_GPS_POSITION_RECURRENCE_SINGLE = 1
+    U_HARDWARE_GPS_POSITION_RECURRENCE_SINGLE = 1
 };
 
 enum
 {
     /** GPS requests data connection for AGPS. */
-    UBUNTU_GPS_REQUEST_AGPS_DATA_CONN = 1,
+    U_HARDWARE_GPS_REQUEST_AGPS_DATA_CONN = 1,
     /** GPS releases the AGPS data connection. */
-    UBUNTU_GPS_RELEASE_AGPS_DATA_CONN = 2,
+    U_HARDWARE_GPS_RELEASE_AGPS_DATA_CONN = 2,
     /** AGPS data connection initiated */
-    UBUNTU_GPS_AGPS_DATA_CONNECTED = 3,
+    U_HARDWARE_GPS_AGPS_DATA_CONNECTED = 3,
     /** AGPS data connection completed */
-    UBUNTU_GPS_AGPS_DATA_CONN_DONE = 4,
+    U_HARDWARE_GPS_AGPS_DATA_CONN_DONE = 4,
     /** AGPS data connection failed */
-    UBUNTU_GPS_AGPS_DATA_CONN_FAILED = 5
+    U_HARDWARE_GPS_AGPS_DATA_CONN_FAILED = 5
 };
 
-/** UbuntuGpsLocation has valid latitude and longitude. */
-#define UBUNTU_GPS_LOCATION_HAS_LAT_LONG   0x0001
-/** UbuntuGpsLocation has valid altitude. */
-#define UBUNTU_GPS_LOCATION_HAS_ALTITUDE   0x0002
-/** UbuntuGpsLocation has valid speed. */
-#define UBUNTU_GPS_LOCATION_HAS_SPEED      0x0004
-/** UbuntuGpsLocation has valid bearing. */
-#define UBUNTU_GPS_LOCATION_HAS_BEARING    0x0008
-/** UbuntuGpsLocation has valid accuracy. */
-#define UBUNTU_GPS_LOCATION_HAS_ACCURACY   0x0010
+/** UHardwareGpsLocation has valid latitude and longitude. */
+#define U_HARDWARE_GPS_LOCATION_HAS_LAT_LONG   0x0001
+/** UHardwareGpsLocation has valid altitude. */
+#define U_HARDWARE_GPS_LOCATION_HAS_ALTITUDE   0x0002
+/** UHardwareGpsLocation has valid speed. */
+#define U_HARDWARE_GPS_LOCATION_HAS_SPEED      0x0004
+/** UHardwareGpsLocation has valid bearing. */
+#define U_HARDWARE_GPS_LOCATION_HAS_BEARING    0x0008
+/** UHardwareGpsLocation has valid accuracy. */
+#define U_HARDWARE_GPS_LOCATION_HAS_ACCURACY   0x0010
 
-typedef struct UbuntuGps_* UbuntuGps;
+typedef struct UHardwareGps_* UHardwareGps;
 
 /**
  * Models a location as reported by the GPS HAL.
@@ -175,234 +197,264 @@
  */
 typedef struct
 {
-    /** set to sizeof(UbuntuGpsLocation) */
-    size_t          size;
-    /** Contains UBUNTU_GPS_LOCATION_* flags bits. */
-    uint16_t        flags;
+    /** set to sizeof(UHardwareGpsLocation) */
+    size_t size;
+    /** Contains U_HARDWARE_GPS_LOCATION_* flags bits. */
+    uint16_t flags;
     /** Represents latitude in degrees. */
-    double          latitude;
+    double latitude;
     /** Represents longitude in degrees. */
-    double          longitude;
+    double longitude;
     /** Represents altitude in meters above the WGS 84 reference
      * ellipsoid. */
-    double          altitude;
+    double altitude;
     /** Represents speed in meters per second. */
-    float           speed;
+    float speed;
     /** Represents heading in degrees. */
-    float           bearing;
+    float bearing;
     /** Represents expected accuracy in meters. */
-    float           accuracy;
+    float accuracy;
     /** Timestamp for the location fix, in milliseconds since January 1, 1970 */
-    int64_t        timestamp;
-} UbuntuGpsLocation;
+    int64_t timestamp;
+} UHardwareGpsLocation;
 
-/** 
- * Represents space vehicle (satellite) information. 
+/**
+ * Represents space vehicle (satellite) information.
  * \ingroup gps_access
  */
 typedef struct {
-    /** set to sizeof(UbuntuGpsSvInfo) */
-    size_t          size;
+    /** set to sizeof(UHardwareGpsSvInfo) */
+    size_t size;
     /** Pseudo-random number for the SV. */
-    int     prn;
+    int prn;
     /** Signal to noise ratio. */
-    float   snr;
+    float snr;
     /** Elevation of SV in degrees. */
-    float   elevation;
+    float elevation;
     /** Azimuth of SV in degrees. */
-    float   azimuth;
-} UbuntuGpsSvInfo;
+    float azimuth;
+} UHardwareGpsSvInfo;
 
-/** 
- * Represents SV (Space Vehicle) status. 
+/**
+ * Represents SV (Space Vehicle) status.
  * \ingroup gps_access
  */
 typedef struct {
     /** set to sizeof(GpsSvStatus) */
-    size_t          size;
+    size_t size;
 
     /** Number of SVs currently visible. */
-    int         num_svs;
+    int num_svs;
 
     /** Contains an array of SV information. */
-    UbuntuGpsSvInfo   sv_list[UBUNTU_GPS_MAX_SVS];
+    UHardwareGpsSvInfo sv_list[U_HARDWARE_GPS_MAX_SVS];
 
     /** Represents a bit mask indicating which SVs
      * have ephemeris data.
      */
-    uint32_t    ephemeris_mask;
+    uint32_t ephemeris_mask;
 
     /** Represents a bit mask indicating which SVs
      * have almanac data.
      */
-    uint32_t    almanac_mask;
+    uint32_t almanac_mask;
 
     /**
      * Represents a bit mask indicating which SVs
      * were used for computing the most recent position fix.
      */
-    uint32_t    used_in_fix_mask;
-} UbuntuGpsSvStatus;
+    uint32_t used_in_fix_mask;
+} UHardwareGpsSvStatus;
 
-/** 
- * Represents the status of AGPS. 
+/**
+ * Represents the status of AGPS.
  * \ingroup gps_access
  */
 typedef struct {
-    /** set to sizeof(UbuntuAgpsStatus) */
+    /** set to sizeof(UHardwareGpsAGpsStatus) */
     size_t size;
 
     uint16_t type;
     uint16_t status;
     uint32_t ipaddr;
-} UbuntuAgpsStatus;
+} UHardwareGpsAGpsStatus;
 
-/** 
- * Represents an NI request 
+/**
+ * Represents an NI request
  * \ingroup gps_access
  */
 typedef struct {
-    /** set to sizeof(UbuntuGpsNiNotification) */
-    size_t          size;
+    /** set to sizeof(UHardwareGpsNiNotification) */
+    size_t size;
 
     /**
      * An ID generated by HAL to associate NI notifications and UI
      * responses
      */
-    int             notification_id;
+    int notification_id;
 
     /**
      * An NI type used to distinguish different categories of NI
-     * events, such as UBUNTU_GPS_NI_TYPE_VOICE, UBUNTU_GPS_NI_TYPE_UMTS_SUPL, ...
+     * events, such as U_HARDWARE_GPS_NI_TYPE_VOICE, U_HARDWARE_GPS_NI_TYPE_UMTS_SUPL, ...
      */
-    uint32_t       ni_type;
+    uint32_t ni_type;
 
     /**
-     * Notification/verification options, combinations of UbuntuGpsNiNotifyFlags constants
+     * Notification/verification options, combinations of UHardwareGpsNiNotifyFlags constants
      */
-    UbuntuGpsNiNotifyFlags notify_flags;
+    UHardwareGpsNiNotifyFlags notify_flags;
 
     /**
      * Timeout period to wait for user response.
      * Set to 0 for no time out limit.
      */
-    int             timeout;
+    int timeout;
 
     /**
      * Default response when time out.
      */
-    UbuntuGpsUserResponseType default_response;
+    UHardwareGpsUserResponseType default_response;
 
     /**
      * Requestor ID
      */
-    char            requestor_id[UBUNTU_GPS_NI_SHORT_STRING_MAXLEN];
+    char requestor_id[U_HARDWARE_GPS_NI_SHORT_STRING_MAXLEN];
 
     /**
      * Notification message. It can also be used to store client_id in some cases
      */
-    char            text[UBUNTU_GPS_NI_LONG_STRING_MAXLEN];
-
-    /**
-     * Client name decoding scheme
-     */
-    UbuntuGpsNiEncodingType requestor_id_encoding;
-
-    /**
-     * Client name decoding scheme
-     */
-    UbuntuGpsNiEncodingType text_encoding;
+    char text[U_HARDWARE_GPS_NI_LONG_STRING_MAXLEN];
+
+    /**
+     * Client name decoding scheme
+     */
+    UHardwareGpsNiEncodingType requestor_id_encoding;
+
+    /**
+     * Client name decoding scheme
+     */
+    UHardwareGpsNiEncodingType text_encoding;
 
     /**
      * A pointer to extra data. Format:
      * key_1 = value_1
      * key_2 = value_2
      */
-    char           extras[UBUNTU_GPS_NI_LONG_STRING_MAXLEN];
-
-} UbuntuGpsNiNotification;
-
-typedef void (* UbuntuGpsLocationCallback)(UbuntuGpsLocation* location, void* context);
-typedef void (* UbuntuGpsStatusCallback)(uint16_t status, void* context);
-typedef void (* UbuntuGpsSvStatusCallback)(UbuntuGpsSvStatus* sv_info, void* context);
-typedef void (* UbuntuGpsNmeaCallback)(int64_t timestamp, const char* nmea, int length, void* context);
-typedef void (* UbuntuGpsSetCapabilities)(uint32_t capabilities, void* context);
-typedef void (* UbuntuGpsRequestUtcTime)(void* context);
+    char extras[U_HARDWARE_GPS_NI_LONG_STRING_MAXLEN];
+
+} UHardwareGpsNiNotification;
+
+typedef void (*UHardwareGpsLocationCallback)(UHardwareGpsLocation *location, void *context);
+typedef void (*UHardwareGpsStatusCallback)(uint16_t status, void *context);
+typedef void (*UHardwareGpsSvStatusCallback)(UHardwareGpsSvStatus *sv_info, void *context);
+typedef void (*UHardwareGpsNmeaCallback)(int64_t timestamp, const char *nmea, int length, void *context);
+typedef void (*UHardwareGpsSetCapabilities)(uint32_t capabilities, void *context);
+typedef void (*UHardwareGpsRequestUtcTime)(void *context);
 
 /** Callback to request the client to download XTRA data.
  *  The client should download XTRA data and inject it by calling inject_xtra_data().
  */
-typedef void (* UbuntuGpsXtraDownloadRequest)(void* context);
+typedef void (*UHardwareGpsXtraDownloadRequest)(void *context);
 
 /** Callback with AGPS status information.
  */
-typedef void (* UbuntuAgpsStatusCallback)(UbuntuAgpsStatus* status, void* context);
+typedef void (*UHardwareGpsAGpsStatusCallback)(UHardwareGpsAGpsStatus *status, void *context);
 
 /** Callback with NI notification.
  */
-typedef void (*UbuntuGpsNiNotifyCallback)(UbuntuGpsNiNotification *notification, void* context);
+typedef void (*UHardwareGpsNiNotifyCallback)(UHardwareGpsNiNotification *notification, void *context);
 
 /*
  Callback for AGPS RIL (Radio Interface Library) set id
 */
-typedef void (*UbuntuAgpsRilRequestSetId)(uint32_t flags, void* context);
-typedef void (*UbuntuAgpsRilRequestRefLoc)(uint32_t flags, void* context);
+typedef void (*UHardwareGpsAGpsRilRequestSetId)(uint32_t flags, void *context);
+typedef void (*UHardwareGpsAGpsRilRequestRefLoc)(uint32_t flags, void *context);
 
 typedef struct
 {
 
-    UbuntuGpsLocationCallback location_cb;
-    UbuntuGpsStatusCallback status_cb;
-    UbuntuGpsSvStatusCallback sv_status_cb;
-    UbuntuGpsNmeaCallback nmea_cb;
-    UbuntuGpsSetCapabilities set_capabilities_cb;
-    UbuntuGpsRequestUtcTime request_utc_time_cb;
-
-    UbuntuGpsXtraDownloadRequest xtra_download_request_cb;
-
-    UbuntuAgpsStatusCallback agps_status_cb;
-
-    UbuntuGpsNiNotifyCallback gps_ni_notify_cb;
-
-    UbuntuAgpsRilRequestSetId request_setid_cb;
-    UbuntuAgpsRilRequestRefLoc request_refloc_cb;
+    UHardwareGpsLocationCallback location_cb;
+    UHardwareGpsStatusCallback status_cb;
+    UHardwareGpsSvStatusCallback sv_status_cb;
+    UHardwareGpsNmeaCallback nmea_cb;
+    UHardwareGpsSetCapabilities set_capabilities_cb;
+    UHardwareGpsRequestUtcTime request_utc_time_cb;
+
+    UHardwareGpsXtraDownloadRequest xtra_download_request_cb;
+
+    UHardwareGpsAGpsStatusCallback agps_status_cb;
+
+    UHardwareGpsNiNotifyCallback gps_ni_notify_cb;
+
+    UHardwareGpsAGpsRilRequestSetId request_setid_cb;
+    UHardwareGpsAGpsRilRequestRefLoc request_refloc_cb;
 
     void* context;
-} UbuntuGpsParams;
+} UHardwareGpsParams;
 
 /*
  You must create only one instance per process/application.
 */
-UbuntuGps ubuntu_gps_new(UbuntuGpsParams* params);
-void ubuntu_gps_delete(UbuntuGps handle);
-
-bool ubuntu_gps_start(UbuntuGps self);
-bool ubuntu_gps_stop(UbuntuGps self);
+UHardwareGps
+u_hardware_gps_new(UHardwareGpsParams *params);
+
+void
+u_hardware_gps_delete(UHardwareGps handle);
+
+bool
+u_hardware_gps_start(UHardwareGps self);
+
+bool
+u_hardware_gps_stop(UHardwareGps self);
 
 /*
     \param time NTP time, in milliseconds since Jan 1st 1970.
     \param time_reference time from the internal clock at the moment that NTP time was taken.
     \param uncertainty possible deviation in the time supplied (uncertainty) in milliseconds.
  */
-void ubuntu_gps_inject_time(UbuntuGps self, int64_t time, int64_t time_reference, int uncertainty);
-
-void ubuntu_gps_inject_location(UbuntuGps self, double latitude, double longitude, float accuracy);
-void ubuntu_gps_delete_aiding_data(UbuntuGps self, uint16_t flags);
+void
+u_hardware_gps_inject_time(
+    UHardwareGps self,
+    int64_t time,
+    int64_t time_reference,
+    int uncertainty);
+
+void
+u_hardware_gps_inject_location(
+    UHardwareGps self,
+    double latitude,
+    double longitude,
+    float accuracy);
+
+void
+u_hardware_gps_delete_aiding_data(
+    UHardwareGps self,
+    uint16_t flags);
 
 /*
-    \param mode One of the UBUNTU_GPS_POSITION_MODE_* values
-    \param recurrence One of the UBUNTU_GPS_POSITION_RECURRENCE_* values
+    \param mode One of the U_HARDWARE_GPS_POSITION_MODE_* values
+    \param recurrence One of the U_HARDWARE_GPS_POSITION_RECURRENCE_* values
     \param min_interval represents the time between fixes in milliseconds.
     \param preferred_accuracy The requested fix accuracy in meters. Can be zero.
     \param preferred_time The requested time to first fix in milliseconds. Can be zero.
  */
-bool ubuntu_gps_set_position_mode(UbuntuGps self, uint32_t mode, uint32_t recurrence,
-                                  uint32_t min_interval, uint32_t preferred_accuracy,
-                                  uint32_t preferred_time);
-void ubuntu_gps_inject_xtra_data(UbuntuGps self, char* data, int length);
+bool
+u_hardware_gps_set_position_mode(
+    UHardwareGps self,
+    uint32_t mode,
+    uint32_t recurrence,
+    uint32_t min_interval,
+    uint32_t preferred_accuracy,
+    uint32_t preferred_time);
+
+void
+u_hardware_gps_inject_xtra_data(
+    UHardwareGps self,
+    char* data,
+    int length);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // UBUNTU_APPLICATION_GPS_H_
+#endif // UBUNTU_HARDWARE_GPS_H_
 
=== modified file 'include/ubuntu/status.h'
--- include/ubuntu/status.h	2013-05-30 02:03:42 +0000
+++ include/ubuntu/status.h	2013-07-05 09:17:25 +0000
@@ -20,10 +20,15 @@
 #ifndef UBUNTU_STATUS_H_
 #define UBUNTU_STATUS_H_
 
+/**
+ * \brief Indicates the status of an operation.
+ */
 typedef enum
 {
-	U_STATUS_SUCCESS,
-    U_STATUS_ERROR
-} UStatus;
+    U_STATUS_SUCCESS, ///< Operation finished successfully.
+    U_STATUS_ERROR ///< Operation finished with an error.
+} UbuntuStatus;
+
+typedef UbuntuStatus UStatus;
 
 #endif /* UBUNTU_STATUS_H_ */
 
=== modified file 'include/ubuntu/unit.h'
--- include/ubuntu/unit.h	2013-05-27 17:09:02 +0000
+++ include/ubuntu/unit.h	2013-07-05 09:17:25 +0000
@@ -20,13 +20,16 @@
 #ifndef UBUNTU_UNIT_H_
 #define UBUNTU_UNIT_H_
 
+/**
+ * \brief Describes units known to the platform integration layer.
+ */
 typedef enum
 {
-	U_DEGREE,
-	U_METER,
-	U_SECOND,
-	U_METER_PER_SECOND,
-	U_MICRO_TESLA
+    U_DEGREE,
+    U_METER,
+    U_SECOND,
+    U_METER_PER_SECOND,
+    U_MICRO_TESLA
 } UbuntuUnit;
 
 typedef UbuntuUnit UUnit;
 
=== modified file 'src/hybris/CMakeLists.txt'
--- src/hybris/CMakeLists.txt	2013-06-20 12:23:48 +0000
+++ src/hybris/CMakeLists.txt	2013-07-05 09:17:25 +0000
@@ -1,14 +1,15 @@
-set(SOURCES 
-  hybris_bridge.cpp
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++0x")
+
+add_library(
+  ubuntu_application_api SHARED
+
   ubuntu_application_api_hybris.cpp
   ubuntu_application_sensors_hybris.cpp
 )
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++0x")
-
 add_library(
-  ubuntu_application_api SHARED
-  ${SOURCES}
+  ubuntu_platform_hardware_api SHARED
+  ubuntu_platform_hardware_api.cpp
 )
 
 include_directories(
@@ -20,6 +21,11 @@
   hybris-common
 )
 
+target_link_libraries(
+  ubuntu_platform_hardware_api
+  hybris-common
+)
+
 set_target_properties(
   ubuntu_application_api
   PROPERTIES
@@ -27,8 +33,21 @@
   SOVERSION ${UBUNTU_PLATFORM_API_VERSION_MAJOR}
 )
 
+set_target_properties(
+  ubuntu_platform_hardware_api
+  PROPERTIES
+  VERSION ${UBUNTU_PLATFORM_API_VERSION_MAJOR}.${UBUNTU_PLATFORM_API_VERSION_MINOR}.${UBUNTU_PLATFORM_API_VERSION_PATCH}
+  SOVERSION ${UBUNTU_PLATFORM_API_VERSION_MAJOR}
+)
+
 install(
   TARGETS ubuntu_application_api  
-  ${INSTALL_TARGETS_DEFAULT_ARGS})
+  ${INSTALL_TARGETS_DEFAULT_ARGS}
+)
+
+install(
+  TARGETS ubuntu_platform_hardware_api
+  ${INSTALL_TARGETS_DEFAULT_ARGS}
+)
 
 add_subdirectory(tests/)
 
=== added file 'src/hybris/bridge.h'
--- src/hybris/bridge.h	1970-01-01 00:00:00 +0000
+++ src/hybris/bridge.h	2013-07-05 09:17:25 +0000
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2012 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 Voss <[e-mail]>
+ *              Ricardo Mendoza <[e-mail]>
+ */
+#ifndef BRIDGE_H_
+#define BRIDGE_H_
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void *android_dlopen(const char *filename, int flag);
+extern void *android_dlsym(void *handle, const char *symbol);
+
+#ifdef __cplusplus
+}
+#endif
+
+namespace internal
+{
+
+struct ToApplication
+{
+    static const char* path()
+    {
+        return "/system/lib/libubuntu_application_api.so";
+    }
+};
+
+struct ToHardware
+{
+    static const char* path()
+    {
+        return "/system/lib/libubuntu_platform_hardware_api.so";
+    }
+};
+
+template<typename Scope = ToApplication>
+class Bridge
+{
+  public:
+    static Bridge<Scope>& instance()
+    { 
+        static Bridge<Scope> bridge; 
+        return bridge; 
+    }
+
+    void* resolve_symbol(const char* symbol) const
+    {
+        return android_dlsym(lib_handle, symbol);
+    }
+
+  protected:
+    Bridge() : lib_handle(android_dlopen(Scope::path(), RTLD_LAZY))
+    {
+        assert(lib_handle && "Error loading ubuntu_application_api");
+    }
+
+    ~Bridge()
+    {
+        // TODO android_dlclose(libcamera_handle);
+    }
+
+    void* lib_handle;
+};
+
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**********************************************************/
+/*********** Implementation starts here *******************/
+/**********************************************************/
+
+#define DLSYM(fptr, sym) if (*(fptr) == NULL) { *((void**)fptr) = (void *) internal::Bridge<>::instance().resolve_symbol(sym); }
+    
+#define IMPLEMENT_FUNCTION0(return_type, symbol)  \
+    return_type symbol()                          \
+    {                                             \
+        static return_type (*f)() = NULL;         \
+        DLSYM(&f, #symbol);                       \
+        return f();}
+
+#define IMPLEMENT_VOID_FUNCTION0(symbol)          \
+    void symbol()                                 \
+    {                                             \
+        static void (*f)() = NULL;                \
+        DLSYM(&f, #symbol);                       \
+        f();}
+    
+#define IMPLEMENT_FUNCTION1(return_type, symbol, arg1) \
+    return_type symbol(arg1 _1)                        \
+    {                                                  \
+        static return_type (*f)(arg1) = NULL;          \
+        DLSYM(&f, #symbol);                     \
+        return f(_1); }
+
+#define IMPLEMENT_SF_FUNCTION1(return_type, symbol, arg1) \
+    return_type symbol(arg1 _1)                        \
+    {                                                  \
+        static return_type (*f)(arg1) __attribute__((pcs("aapcs"))) = NULL; \
+        DLSYM(&f, #symbol);                     \
+        return f(_1); }
+
+
+#define IMPLEMENT_VOID_FUNCTION1(symbol, arg1)               \
+    void symbol(arg1 _1)                                     \
+    {                                                        \
+        static void (*f)(arg1) = NULL;                       \
+        DLSYM(&f, #symbol);                           \
+        f(_1); }
+
+#define IMPLEMENT_FUNCTION2(return_type, symbol, arg1, arg2)    \
+    return_type symbol(arg1 _1, arg2 _2)                        \
+    {                                                           \
+        static return_type (*f)(arg1, arg2) = NULL;             \
+        DLSYM(&f, #symbol);                              \
+        return f(_1, _2); }
+
+#define IMPLEMENT_VOID_FUNCTION2(symbol, arg1, arg2)            \
+    void symbol(arg1 _1, arg2 _2)                               \
+    {                                                           \
+        static void (*f)(arg1, arg2) = NULL;                    \
+        DLSYM(&f, #symbol);                              \
+        f(_1, _2); }
+
+#define IMPLEMENT_FUNCTION3(return_type, symbol, arg1, arg2, arg3)    \
+    return_type symbol(arg1 _1, arg2 _2, arg3 _3)                     \
+    {                                                                 \
+        static return_type (*f)(arg1, arg2, arg3) = NULL;             \
+        DLSYM(&f, #symbol);                                           \
+        return f(_1, _2, _3); } 
+
+#define IMPLEMENT_VOID_FUNCTION3(symbol, arg1, arg2, arg3)      \
+    void symbol(arg1 _1, arg2 _2, arg3 _3)                      \
+    {                                                           \
+        static void (*f)(arg1, arg2, arg3) = NULL;              \
+        DLSYM(&f, #symbol);                                     \
+        f(_1, _2, _3); }
+
+#define IMPLEMENT_VOID_FUNCTION4(symbol, arg1, arg2, arg3, arg4) \
+    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4)              \
+    {                                                            \
+        static void (*f)(arg1, arg2, arg3, arg4) = NULL;         \
+        DLSYM(&f, #symbol);                                      \
+        f(_1, _2, _3, _4); }
+
+#define IMPLEMENT_FUNCTION4(return_type, symbol, arg1, arg2, arg3, arg4) \
+    return_type symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4)               \
+    {                                                                    \
+        static return_type (*f)(arg1, arg2, arg3, arg4) = NULL;          \
+        DLSYM(&f, #symbol);                                              \
+        return f(_1, _2, _3, _4); }
+
+#define IMPLEMENT_FUNCTION6(return_type, symbol, arg1, arg2, arg3, arg4, arg5, arg6) \
+    return_type symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6)         \
+    {                                                                                \
+        static return_type (*f)(arg1, arg2, arg3, arg4, arg5, arg6) = NULL;          \
+        DLSYM(&f, #symbol);                                                          \
+        return f(_1, _2, _3, _4, _5, _6); }
+
+#define IMPLEMENT_VOID_FUNCTION7(symbol, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6, arg7 _7) \
+    {                                                                   \
+        static void (*f)(arg1, arg2, arg3, arg4, arg5, arg6, arg7) = NULL; \
+        DLSYM(&f, #symbol);                                             \
+        f(_1, _2, _3, _4, _5, _6, _7); }
+
+#define IMPLEMENT_VOID_FUNCTION8(symbol, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6, arg7 _7, arg8 _8) \
+    {                                                                   \
+        static void (*f)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) = NULL; \
+        DLSYM(&f, #symbol);                                             \
+        f(_1, _2, _3, _4, _5, _6, _7, _8); }
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // BRIDGE_H_
 
=== removed file 'src/hybris/hybris_bridge.cpp'
--- src/hybris/hybris_bridge.cpp	2013-06-05 22:34:41 +0000
+++ src/hybris/hybris_bridge.cpp	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 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 Voss <[e-mail]>
- *              Ricardo Mendoza <[e-mail]>
- */
-
-#include "hybris_bridge.h"
-
-#include <dlfcn.h>
-#include <assert.h>
-
-namespace uh = ubuntu::hybris;
-
-extern "C" {
-
-extern void *android_dlopen(const char *filename, int flag);
-extern void *android_dlsym(void *handle, const char *symbol);
-
-}
-
-const char* uh::Bridge::path_to_library()
-{
-    return "/system/lib/libubuntu_application_api.so";
-}
-
-uh::Bridge& uh::Bridge::instance()
-{
-    static uh::Bridge bridge;
-    return bridge;
-}
-
-uh::Bridge::Bridge()
-    : lib_handle(android_dlopen(path_to_library(), RTLD_LAZY))
-{
-    assert(lib_handle && "Error loading ubuntu_application_api");
-}
-
-uh::Bridge::~Bridge()
-{
-    // TODO android_dlclose(libcamera_handle);
-}
-
-void* uh::Bridge::resolve_symbol(const char* symbol) const
-{
-    return android_dlsym(lib_handle, symbol);
-}
 
=== removed file 'src/hybris/hybris_bridge.h'
--- src/hybris/hybris_bridge.h	2013-06-05 23:44:55 +0000
+++ src/hybris/hybris_bridge.h	1970-01-01 00:00:00 +0000
@@ -1,148 +0,0 @@
-/*
- * Copyright (C) 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 Voss <[e-mail]>
- *              Ricardo Mendoza <[e-mail]>
- */
-
-#ifndef UBUNTU_APPLICATION_API_HYBRIS_BRIDGE_H_
-#define UBUNTU_APPLICATION_API_HYBRIS_BRIDGE_H_
-
-#include <stddef.h>
-
-namespace ubuntu
-{
-namespace hybris
-{
-
-struct Bridge
-{
-    Bridge();
-    ~Bridge();
-
-    static const char* path_to_library();
-    static Bridge& instance();
-    
-    void* resolve_symbol(const char* symbol) const;
-
-    void* lib_handle;
-};
-
-}
-}
-
-// Sweet and beautiful music.
-#define DLSYM(fptr, sym) if (*(fptr) == NULL) { *((void**)fptr) = (void *) ubuntu::hybris::Bridge::instance().resolve_symbol(sym); }
-    
-#define IMPLEMENT_FUNCTION0(return_type, symbol)  \
-    return_type symbol()                          \
-    {                                             \
-        static return_type (*f)() = NULL;         \
-        DLSYM(&f, #symbol);                       \
-        return f();}
-
-#define IMPLEMENT_VOID_FUNCTION0(symbol)          \
-    void symbol()                                 \
-    {                                             \
-        static void (*f)() = NULL;                \
-        DLSYM(&f, #symbol);                       \
-        f();}
-    
-#define IMPLEMENT_FUNCTION1(return_type, symbol, arg1) \
-    return_type symbol(arg1 _1)                        \
-    {                                                  \
-        static return_type (*f)(arg1) = NULL;          \
-        DLSYM(&f, #symbol);                     \
-        return f(_1); }
-
-#define IMPLEMENT_SF_FUNCTION1(return_type, symbol, arg1) \
-    return_type symbol(arg1 _1)                        \
-    {                                                  \
-        static return_type (*f)(arg1) __attribute__((pcs("aapcs"))) = NULL; \
-        DLSYM(&f, #symbol);                     \
-        return f(_1); }
-
-
-#define IMPLEMENT_VOID_FUNCTION1(symbol, arg1)               \
-    void symbol(arg1 _1)                                     \
-    {                                                        \
-        static void (*f)(arg1) = NULL;                       \
-        DLSYM(&f, #symbol);                           \
-        f(_1); }
-
-#define IMPLEMENT_FUNCTION2(return_type, symbol, arg1, arg2)    \
-    return_type symbol(arg1 _1, arg2 _2)                        \
-    {                                                           \
-        static return_type (*f)(arg1, arg2) = NULL;             \
-        DLSYM(&f, #symbol);                              \
-        return f(_1, _2); }
-
-#define IMPLEMENT_VOID_FUNCTION2(symbol, arg1, arg2)            \
-    void symbol(arg1 _1, arg2 _2)                               \
-    {                                                           \
-        static void (*f)(arg1, arg2) = NULL;                    \
-        DLSYM(&f, #symbol);                              \
-        f(_1, _2); }
-
-#define IMPLEMENT_FUNCTION3(return_type, symbol, arg1, arg2, arg3)    \
-    return_type symbol(arg1 _1, arg2 _2, arg3 _3)                     \
-    {                                                                 \
-        static return_type (*f)(arg1, arg2, arg3) = NULL;             \
-        DLSYM(&f, #symbol);                                           \
-        return f(_1, _2, _3); } 
-
-#define IMPLEMENT_VOID_FUNCTION3(symbol, arg1, arg2, arg3)      \
-    void symbol(arg1 _1, arg2 _2, arg3 _3)                      \
-    {                                                           \
-        static void (*f)(arg1, arg2, arg3) = NULL;              \
-        DLSYM(&f, #symbol);                                     \
-        f(_1, _2, _3); }
-
-#define IMPLEMENT_VOID_FUNCTION4(symbol, arg1, arg2, arg3, arg4) \
-    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4)              \
-    {                                                            \
-        static void (*f)(arg1, arg2, arg3, arg4) = NULL;         \
-        DLSYM(&f, #symbol);                                      \
-        f(_1, _2, _3, _4); }
-
-#define IMPLEMENT_FUNCTION4(return_type, symbol, arg1, arg2, arg3, arg4) \
-    return_type symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4)               \
-    {                                                                    \
-        static return_type (*f)(arg1, arg2, arg3, arg4) = NULL;          \
-        DLSYM(&f, #symbol);                                              \
-        return f(_1, _2, _3, _4); }
-
-#define IMPLEMENT_FUNCTION6(return_type, symbol, arg1, arg2, arg3, arg4, arg5, arg6) \
-    return_type symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6)         \
-    {                                                                                \
-        static return_type (*f)(arg1, arg2, arg3, arg4, arg5, arg6) = NULL;          \
-        DLSYM(&f, #symbol);                                                          \
-        return f(_1, _2, _3, _4, _5, _6); }
-
-#define IMPLEMENT_VOID_FUNCTION7(symbol, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
-    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6, arg7 _7) \
-    {                                                                   \
-        static void (*f)(arg1, arg2, arg3, arg4, arg5, arg6, arg7) = NULL; \
-        DLSYM(&f, #symbol);                                             \
-        f(_1, _2, _3, _4, _5, _6, _7); }
-
-#define IMPLEMENT_VOID_FUNCTION8(symbol, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
-    void symbol(arg1 _1, arg2 _2, arg3 _3, arg4 _4, arg5 _5, arg6 _6, arg7 _7, arg8 _8) \
-    {                                                                   \
-        static void (*f)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) = NULL; \
-        DLSYM(&f, #symbol);                                             \
-        f(_1, _2, _3, _4, _5, _6, _7, _8); }
-
-#endif // UBUNTU_APPLICATION_API_HYBRIS_BRIDGE_H_
 
=== modified file 'src/hybris/tests/CMakeLists.txt'
--- src/hybris/tests/CMakeLists.txt	2013-06-03 20:54:26 +0000
+++ src/hybris/tests/CMakeLists.txt	2013-07-05 09:17:25 +0000
@@ -4,7 +4,7 @@
 target_link_libraries(test_android_ubuntu_app_api ubuntu_application_api EGL GLESv2)
 
 add_executable(test_android_gps_api test_gps_api.cpp)
-target_link_libraries(test_android_gps_api ubuntu_application_api)
+target_link_libraries(test_android_gps_api ubuntu_platform_hardware_api)
 
 add_executable(test_android_ubuntu_app_api_multiple_surfaces test_multiple_surfaces_event_delivery.cpp)
 target_link_libraries(test_android_ubuntu_app_api_multiple_surfaces ubuntu_application_api EGL GLESv2)
 
=== modified file 'src/hybris/tests/test_gps_api.cpp'
--- src/hybris/tests/test_gps_api.cpp	2013-02-05 08:01:14 +0000
+++ src/hybris/tests/test_gps_api.cpp	2013-07-05 09:17:25 +0000
@@ -15,7 +15,7 @@
  *
  * Authored by: Daniel d'Andrada <[e-mail]>
  */
-#include <ubuntu/application/ubuntu_application_gps.h>
+#include <ubuntu/hardware/gps.h>
 
 #include <ctime>
 #include <signal.h>
@@ -23,6 +23,8 @@
 #include <string.h>
 #include <unistd.h>
 
+namespace ubuntu
+{
 class GPSTest
 {
   public:
@@ -32,10 +34,10 @@
     bool stop();
     void inject_time();
 
-    UbuntuGps ubuntu_gps;
+    UHardwareGps u_hardware_gps;
 };
 
-void gps_location_cb(UbuntuGpsLocation* location, void* context)
+void gps_location_cb(UHardwareGpsLocation* location, void* context)
 {
     printf("gps_location_cb() called.\n");
 }
@@ -44,26 +46,26 @@
 {
     switch(status)
     {
-    case UBUNTU_GPS_STATUS_NONE:
+    case U_HARDWARE_GPS_STATUS_NONE:
         printf("status: None\n");
         break;
-    case UBUNTU_GPS_STATUS_SESSION_BEGIN:
+    case U_HARDWARE_GPS_STATUS_SESSION_BEGIN:
         printf("status: Session Begin\n");
         break;
-    case UBUNTU_GPS_STATUS_SESSION_END:
+    case U_HARDWARE_GPS_STATUS_SESSION_END:
         printf("status: Session End\n");
         break;
-    case UBUNTU_GPS_STATUS_ENGINE_ON:
+    case U_HARDWARE_GPS_STATUS_ENGINE_ON:
         printf("status: Engine On\n");
         break;
-    case UBUNTU_GPS_STATUS_ENGINE_OFF:
+    case U_HARDWARE_GPS_STATUS_ENGINE_OFF:
         printf("status: Engine Off\n");
     default:
         break;
     };
 }
 
-void gps_sb_status_cb(UbuntuGpsSvStatus* sv_info, void* context)
+void gps_sb_status_cb(UHardwareGpsSvStatus* sv_info, void* context)
 {
     printf("gps_sb_status_cb() called, listing %d space vehicles\n", sv_info->num_svs);
 }
@@ -80,15 +82,15 @@
 {
     printf("gps_set_cabapilities_cb() -");
 
-    if (capabilities & UBUNTU_GPS_CAPABILITY_SCHEDULING)
+    if (capabilities & U_HARDWARE_GPS_CAPABILITY_SCHEDULING)
         printf(" scheduling");
-    if (capabilities & UBUNTU_GPS_CAPABILITY_MSB)
+    if (capabilities & U_HARDWARE_GPS_CAPABILITY_MSB)
         printf(" MSB");
-    if (capabilities & UBUNTU_GPS_CAPABILITY_MSA)
+    if (capabilities & U_HARDWARE_GPS_CAPABILITY_MSA)
         printf(" MSA");
-    if (capabilities & UBUNTU_GPS_CAPABILITY_SINGLE_SHOT)
+    if (capabilities & U_HARDWARE_GPS_CAPABILITY_SINGLE_SHOT)
         printf(" 'single shot'");
-    if (capabilities & UBUNTU_GPS_CAPABILITY_ON_DEMAND_TIME)
+    if (capabilities & U_HARDWARE_GPS_CAPABILITY_ON_DEMAND_TIME)
         printf(" 'on demand time'");
 
     printf("\n");
@@ -105,31 +107,31 @@
     printf("gps_xtra_download_request_cb() called.\n");
 }
 
-void agps_status_cb(UbuntuAgpsStatus* status, void* context)
+void agps_status_cb(UHardwareGpsAGpsStatus* status, void* context)
 {
     printf("agps status -");
 
-    if (status->type == UBUNTU_AGPS_TYPE_SUPL)
+    if (status->type == U_HARDWARE_GPS_AGPS_TYPE_SUPL)
         printf(" SUPL");
     else
         printf(" C2K");
 
     switch (status->status)
     {
-    case UBUNTU_GPS_REQUEST_AGPS_DATA_CONN:
+    case U_HARDWARE_GPS_REQUEST_AGPS_DATA_CONN:
         printf(", request AGPS data connection");
         break;
-    case UBUNTU_GPS_RELEASE_AGPS_DATA_CONN:
+    case U_HARDWARE_GPS_RELEASE_AGPS_DATA_CONN:
         printf(", release AGPS data connection");
         break;
-    case UBUNTU_GPS_AGPS_DATA_CONNECTED:
+    case U_HARDWARE_GPS_AGPS_DATA_CONNECTED:
         printf(", request AGPS data connected");
         break;
-    case UBUNTU_GPS_AGPS_DATA_CONN_DONE:
+    case U_HARDWARE_GPS_AGPS_DATA_CONN_DONE:
         printf(", AGPS data connection done");
         break;
     default:
-    case UBUNTU_GPS_AGPS_DATA_CONN_FAILED:
+    case U_HARDWARE_GPS_AGPS_DATA_CONN_FAILED:
         printf(", AGPS data connection failed");
         break;
     }
@@ -137,7 +139,7 @@
     printf(" ipaddr=%u\n", status->ipaddr);
 }
 
-void gps_notify_cb(UbuntuGpsNiNotification *notification, void* context)
+void gps_notify_cb(UHardwareGpsNiNotification *notification, void* context)
 {
     printf("gps_notify_cb() called.\n");
 }
@@ -153,14 +155,14 @@
 }
 
 GPSTest::GPSTest()
-    : ubuntu_gps(NULL)
+    : u_hardware_gps(NULL)
 {
 }
 
 GPSTest::~GPSTest()
 {
-    if (ubuntu_gps)
-        ubuntu_gps_delete(ubuntu_gps);
+    if (u_hardware_gps)
+        u_hardware_gps_delete(u_hardware_gps);
 }
 
 void GPSTest::inject_time()
@@ -168,7 +170,7 @@
     // A real implementation would inject time from some NTP server.
     time_t t = time(0);
     int64_t time_millis = (int64_t)t * (int64_t)1000;
-    ubuntu_gps_inject_time(ubuntu_gps,
+    u_hardware_gps_inject_time(u_hardware_gps,
                            time_millis /*NTP time would go here*/,
                            time_millis /*internal time when that NTP time was taken*/,
                            10 /* possible deviation, in milliseconds*/);
@@ -176,7 +178,7 @@
 
 bool GPSTest::init_and_start()
 {
-    UbuntuGpsParams gps_params;
+    UHardwareGpsParams gps_params;
 
     gps_params.location_cb = gps_location_cb;
     gps_params.status_cb = gps_status_cb;
@@ -191,14 +193,14 @@
     gps_params.request_refloc_cb = agps_ril_request_refloc_cb;
     gps_params.context = this;
 
-    UbuntuGps ubuntu_gps = ubuntu_gps_new(&gps_params);
-    if (!ubuntu_gps)
+    UHardwareGps u_hardware_gps = u_hardware_gps_new(&gps_params);
+    if (!u_hardware_gps)
     {
         printf("GPS creation failed!\n");
         return false;
     }
 
-    bool ok = ubuntu_gps_start(ubuntu_gps);
+    bool ok = u_hardware_gps_start(u_hardware_gps);
     if (!ok)
     {
         printf("GPS start up failed!\n");
@@ -210,12 +212,13 @@
 
 bool GPSTest::stop()
 {
-    bool ok = ubuntu_gps_stop(ubuntu_gps);
+    bool ok = u_hardware_gps_stop(u_hardware_gps);
     if (!ok)
         printf("failed when stopping GPS!\n");
 
     return ok;
 }
+}
 
 void wait_for_sigint()
 {
@@ -232,7 +235,7 @@
 int main(int argc, char** argv)
 {
     int return_value = 0;
-    GPSTest test;
+    ubuntu::GPSTest test;
 
     if (!test.init_and_start())
         return 1;
 
=== modified file 'src/hybris/ubuntu_application_api_hybris.cpp'
--- src/hybris/ubuntu_application_api_hybris.cpp	2013-06-18 00:05:11 +0000
+++ src/hybris/ubuntu_application_api_hybris.cpp	2013-07-05 09:17:25 +0000
@@ -19,7 +19,6 @@
 
 #include <private/application/ui/ubuntu_application_ui.h>
 
-#include <ubuntu/application/ubuntu_application_gps.h>
 #include <ubuntu/ui/ubuntu_ui_session_service.h>
 
 // C APIs
@@ -30,21 +29,12 @@
 #include <ubuntu/application/ui/clipboard.h>
 #include <ubuntu/application/ui/display.h>
 
-#include <assert.h>
-#include <dlfcn.h>
-#include <stddef.h>
-
-#include "hybris_bridge.h"
+#include "bridge.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/**********************************************************/
-/*********** Implementation starts here *******************/
-/**********************************************************/
-
-
 // Session helpers
 IMPLEMENT_FUNCTION0(UAUiSessionProperties*, ua_ui_session_properties_new);
 IMPLEMENT_VOID_FUNCTION2(ua_ui_session_properties_set_type, UAUiSessionProperties*, UAUiSessionType);
@@ -135,18 +125,6 @@
 IMPLEMENT_VOID_FUNCTION0(ubuntu_ui_report_notification_invisible);
 IMPLEMENT_VOID_FUNCTION1(ubuntu_ui_install_task_controller, ubuntu_ui_task_controller*);
 
-// GPS
-IMPLEMENT_FUNCTION1(UbuntuGps, ubuntu_gps_new, UbuntuGpsParams*);
-IMPLEMENT_VOID_FUNCTION1(ubuntu_gps_delete, UbuntuGps);
-IMPLEMENT_FUNCTION1(bool, ubuntu_gps_start, UbuntuGps);
-IMPLEMENT_FUNCTION1(bool, ubuntu_gps_stop, UbuntuGps);
-IMPLEMENT_VOID_FUNCTION4(ubuntu_gps_inject_time, UbuntuGps, int64_t, int64_t, int);
-IMPLEMENT_VOID_FUNCTION4(ubuntu_gps_inject_location, UbuntuGps, double, double, float);
-IMPLEMENT_VOID_FUNCTION2(ubuntu_gps_delete_aiding_data, UbuntuGps, uint16_t);
-IMPLEMENT_FUNCTION6(bool, ubuntu_gps_set_position_mode, UbuntuGps, uint32_t, uint32_t,
-                                                        uint32_t, uint32_t, uint32_t);
-IMPLEMENT_VOID_FUNCTION3(ubuntu_gps_inject_xtra_data, UbuntuGps, char*, int);
-
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'src/hybris/ubuntu_application_sensors_hybris.cpp'
--- src/hybris/ubuntu_application_sensors_hybris.cpp	2013-06-05 22:59:25 +0000
+++ src/hybris/ubuntu_application_sensors_hybris.cpp	2013-07-05 09:17:25 +0000
@@ -21,7 +21,7 @@
 #include <ubuntu/application/sensors/proximity.h>
 #include <ubuntu/application/sensors/light.h>
 
-#include "hybris_bridge.h"
+#include "bridge.h"
 
 // Ubuntu Application Sensors
 
 
=== added file 'src/hybris/ubuntu_platform_hardware_api.cpp'
--- src/hybris/ubuntu_platform_hardware_api.cpp	1970-01-01 00:00:00 +0000
+++ src/hybris/ubuntu_platform_hardware_api.cpp	2013-07-05 09:17:25 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2012 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 Voss <[e-mail]>
+ *              Ricardo Mendoza <[e-mail]>
+ */
+
+// C APIs
+#include <ubuntu/hardware/gps.h>
+
+#include "bridge.h"
+
+// Hardware - GPS
+IMPLEMENT_FUNCTION1(
+UHardwareGps, 
+u_hardware_gps_new, 
+UHardwareGpsParams*);
+
+IMPLEMENT_VOID_FUNCTION1(
+u_hardware_gps_delete, 
+UHardwareGps);
+
+IMPLEMENT_FUNCTION1(
+bool, 
+u_hardware_gps_start, 
+UHardwareGps);
+
+IMPLEMENT_FUNCTION1(
+bool, 
+u_hardware_gps_stop, 
+UHardwareGps);
+
+IMPLEMENT_VOID_FUNCTION4(
+u_hardware_gps_inject_time, 
+UHardwareGps, 
+int64_t, 
+int64_t, 
+int);
+
+IMPLEMENT_VOID_FUNCTION4(
+u_hardware_gps_inject_location, 
+UHardwareGps, 
+double, 
+double, 
+float);
+
+IMPLEMENT_VOID_FUNCTION2(
+u_hardware_gps_delete_aiding_data, 
+UHardwareGps, 
+uint16_t);
+
+IMPLEMENT_FUNCTION6(
+bool, 
+u_hardware_gps_set_position_mode, 
+UHardwareGps, 
+uint32_t, 
+uint32_t,
+uint32_t, 
+uint32_t, 
+uint32_t);
+
+IMPLEMENT_VOID_FUNCTION3(
+u_hardware_gps_inject_xtra_data, 
+UHardwareGps, 
+char*, 
+int);