Merge lp:~thomas-voss/platform-api/add-rotation-vector-sensor into lp:platform-api

[Thomas Voß]

Export a fusioned RotationVector sensor that mangles readings from the accelerometer/magnetometer/gyroscope to determine the device's rotation in space.

Export a fusioned RotationVector sensor that mangles readings from the accelerometer/magnetometer/gyroscope to determine the device's rotation in space.

[lp:~thomas-voss/platform-api/add-rotation-vector-sensor]

325. By Thomas Voß on 2016-03-30

[ CI Train Bot ]
* debian/libubuntu-platform-hardware-api3.symbols: update to released
  version.
[ Simon Fels ]
* Workaround API break in Android GPS hardware abstraction API on MTK
  platforms. Each device which need this workaround has to add
[ Thomas Voß ]
* Expose performance boosting capabilities of the underlying
  HW/drivers.

326. By Thomas Voß on 2016-03-30

Adjust function signatures to match header file.

327. By Thomas Voß on 2016-03-30

Adjust function signatures on Android side.

328. By Thomas Voß on 2016-03-30

Install newly added headers.

329. By Thomas Voß on 2016-03-30

Add missing symbols to top-level platform api so.

330. By Thomas Voß on 2016-03-30

Add missing include.

331. By Thomas Voß on 2016-03-30

Adjust macro invocation.

332. By Thomas Voß on 2016-03-30

Add functions for subscribing to satellite visibility updates.

333. By Thomas Voß on 2016-04-04

Fix initialization of rotation vector.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:333
http://jenkins.qa.ubuntu.com/job/platform-api-ci/473/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/86
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/86
        deb: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/86/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/86

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

review: Approve (continuous-integration)

Unmerged revisions

333. By Thomas Voß on 2016-04-04

Fix initialization of rotation vector.

332. By Thomas Voß on 2016-03-30

Add functions for subscribing to satellite visibility updates.

331. By Thomas Voß on 2016-03-30

Adjust macro invocation.

330. By Thomas Voß on 2016-03-30

Add missing include.

329. By Thomas Voß on 2016-03-30

Add missing symbols to top-level platform api so.

328. By Thomas Voß on 2016-03-30

Install newly added headers.

327. By Thomas Voß on 2016-03-30

Adjust function signatures on Android side.

326. By Thomas Voß on 2016-03-30

Adjust function signatures to match header file.

325. By Thomas Voß on 2016-03-30

[ CI Train Bot ]
* debian/libubuntu-platform-hardware-api3.symbols: update to released
  version.
[ Simon Fels ]
* Workaround API break in Android GPS hardware abstraction API on MTK
  platforms. Each device which need this workaround has to add
[ Thomas Voß ]
* Expose performance boosting capabilities of the underlying
  HW/drivers.

324. By Thomas Voß on 2016-03-30

Fix FTBFS.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-25 23:01:58 +0000
+++ CMakeLists.txt	2016-04-04 06:59:39 +0000
@@ -3,7 +3,7 @@
 project(ubuntu-platform-api)
 
 set(UBUNTU_PLATFORM_API_VERSION_MAJOR 3)
-set(UBUNTU_PLATFORM_API_VERSION_MINOR 0)
+set(UBUNTU_PLATFORM_API_VERSION_MINOR 1)
 set(UBUNTU_PLATFORM_API_VERSION_PATCH 0)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")

=== modified file 'TODO.txt'
--- TODO.txt	2013-02-06 21:20:59 +0000
+++ TODO.txt	2016-04-04 06:59:39 +0000
@@ -5,3 +5,4 @@
 * Review headers to know which ones should not be exported by the package
 * Make sure the package is lintian free
 * Get the -headers package to be arch all, not used for now due restriction at Launchpad PPA
+* Wake up jenkins :)

=== modified file 'android/default/default_ubuntu_application_sensor.cpp'
--- android/default/default_ubuntu_application_sensor.cpp	2016-04-04 06:59:39 +0000
+++ android/default/default_ubuntu_application_sensor.cpp	2016-04-04 06:59:39 +0000
@@ -23,6 +23,7 @@
 #include <ubuntu/application/sensors/orientation.h>
 #include <ubuntu/application/sensors/gyroscope.h>
 #include <ubuntu/application/sensors/magnetic.h>
+#include <ubuntu/application/sensors/rotation_vector.h>
 
 #include <private/application/sensors/sensor.h>
 #include <private/application/sensors/sensor_listener.h>
@@ -158,6 +159,24 @@
 
                 break;
             }
+
+            case ubuntu::application::sensors::sensor_type_rotation_vector:
+            {
+                if (!on_rotation_vector_event)
+                    return;
+
+                ubuntu::application::sensors::RotationVectorEvent ev(
+                        reading->timestamp,
+                        reading->vector[0],
+                        reading->vector[1],
+                        reading->vector[2]
+                        );
+
+                on_rotation_vector_event(
+                    &ev, this->context
+                    );
+                break;
+            }
         }
     }
 
@@ -167,6 +186,7 @@
     on_orientation_event_cb on_orientation_event;
     on_gyroscope_event_cb on_gyroscope_event;
     on_magnetic_event_cb on_magnetic_event;
+    on_rotation_vector_event_cb on_rotation_vector_event;
     void *context;
 };
 
@@ -176,12 +196,14 @@
 ubuntu::application::sensors::Sensor::Ptr light;
 ubuntu::application::sensors::Sensor::Ptr gyroscope;
 ubuntu::application::sensors::Sensor::Ptr magnetic;
+ubuntu::application::sensors::Sensor::Ptr rotation_vector;
 ubuntu::application::sensors::SensorListener::Ptr orientation_listener;
 ubuntu::application::sensors::SensorListener::Ptr accelerometer_listener;
 ubuntu::application::sensors::SensorListener::Ptr proximity_listener;
 ubuntu::application::sensors::SensorListener::Ptr light_listener;
 ubuntu::application::sensors::SensorListener::Ptr gyroscope_listener;
 ubuntu::application::sensors::SensorListener::Ptr magnetic_listener;
+ubuntu::application::sensors::SensorListener::Ptr rotation_vector_listener;
 }
 
 static int32_t toHz(int32_t microseconds)
@@ -1267,3 +1289,191 @@
 
     return U_STATUS_SUCCESS;
 }
+
+/*
+ * Gyroscopic Sensor
+ */
+
+UASensorsRotationVector*
+ua_sensors_rotation_vector_new()
+{
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    rotation_vector =
+        ubuntu::application::sensors::SensorService::sensor_for_type(
+            ubuntu::application::sensors::sensor_type_rotation_vector);
+
+    return rotation_vector.get();
+}
+
+UStatus
+ua_sensors_rotation_vector_enable(
+    UASensorsRotationVector* sensor)
+{
+    if (sensor == NULL)
+        return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+
+    s->enable();
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus
+ua_sensors_rotation_vector_disable(
+    UASensorsRotationVector* sensor)
+{
+    if (sensor == NULL)
+        return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    s->disable();
+
+    return U_STATUS_SUCCESS;
+}
+
+uint32_t
+ua_sensors_rotation_vector_get_min_delay(
+    UASensorsRotationVector* sensor)
+{
+    if (sensor == NULL)
+        return -1;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    return toHz(s->min_delay());
+}
+
+UStatus
+ua_sensors_rotation_vector_get_min_value(
+    UASensorsRotationVector* sensor,
+    float* value)
+{
+    if (sensor == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    *value = s->min_value();
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus
+ua_sensors_rotation_vector_get_max_value(
+    UASensorsRotationVector* sensor,
+    float* value)
+{
+    if (sensor == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    *value = s->max_value();
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus
+ua_sensors_rotation_vector_get_resolution(
+    UASensorsRotationVector* sensor,
+    float* value)
+{
+    if (sensor == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    *value = s->resolution();
+
+    return U_STATUS_SUCCESS;
+}
+
+void
+ua_sensors_rotation_vector_set_reading_cb(
+    UASensorsRotationVector* sensor,
+    on_rotation_vector_event_cb cb,
+    void *ctx)
+{
+    if (sensor == NULL)
+        return;
+
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+
+    SensorListener<ubuntu::application::sensors::sensor_type_rotation_vector>* sl
+        = new SensorListener<ubuntu::application::sensors::sensor_type_rotation_vector>();
+
+    sl->on_rotation_vector_event = cb;
+    sl->context = ctx;
+
+    rotation_vector_listener = sl;
+    s->register_listener(rotation_vector_listener);
+}
+
+UStatus
+ua_sensors_rotation_vector_set_event_rate(
+    UASensorsRotationVector* sensor,
+    uint32_t rate)
+{
+    if (sensor == NULL)
+       return U_STATUS_ERROR;
+
+    ALOGI("%s():%d", __PRETTY_FUNCTION__, __LINE__);
+    auto s = static_cast<ubuntu::application::sensors::Sensor*>(sensor);
+    if (!s->set_event_rate(rate))
+        return U_STATUS_ERROR;
+
+    return U_STATUS_SUCCESS;
+}
+
+uint64_t
+uas_rotation_vector_event_get_timestamp(
+    UASRotationVectorEvent* event)
+{
+    auto ev = static_cast<ubuntu::application::sensors::RotationVectorEvent*>(event);
+    return ev->get_timestamp();
+}
+
+UStatus
+uas_rotation_vector_event_get_x_axis(
+    UASRotationVectorEvent* event,
+    float* value)
+{
+    if (event == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    auto ev = static_cast<ubuntu::application::sensors::RotationVectorEvent*>(event);
+    *value = ev->get_x_rotation();
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus
+uas_rotation_vector_event_get_y_axis(
+    UASRotationVectorEvent* event,
+    float* value)
+{
+    if (event == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    auto ev = static_cast<ubuntu::application::sensors::RotationVectorEvent*>(event);
+    *value = ev->get_y_rotation();
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus
+uas_rotation_vector_event_get_z_axis(
+    UASRotationVectorEvent* event,
+    float* value)
+{
+    if (event == NULL || value == NULL)
+        return U_STATUS_ERROR;
+
+    auto ev = static_cast<ubuntu::application::sensors::RotationVectorEvent*>(event);
+    *value = ev->get_z_rotation();
+
+    return U_STATUS_SUCCESS;
+}

=== modified file 'android/hybris/Android.mk'
--- android/hybris/Android.mk	2016-02-03 10:00:56 +0000
+++ android/hybris/Android.mk	2016-04-04 06:59:39 +0000
@@ -13,6 +13,10 @@
 	-DANDROID_VERSION_MINOR=$(ANDROID_VERSION_MINOR) \
 	-DANDROID_VERSION_PATCH=$(ANDROID_VERSION_PATCH)
 
+ifeq ($(BOARD_HAS_SUPPORT_FOR_ADDITIONAL_SATELLITE_NETWORKS),true)
+	LOCAL_CFLAGS += -DBOARD_HAS_SUPPORT_FOR_ADDITIONAL_SATELLITE_NETWORKS
+endif
+
 UPAPI_PATH := $(LOCAL_PATH)/../../
 
 LOCAL_CFLAGS += -std=gnu++0x

=== modified file 'android/hybris/ubuntu_application_gps_for_hybris.cpp'
--- android/hybris/ubuntu_application_gps_for_hybris.cpp	2016-02-02 09:04:07 +0000
+++ android/hybris/ubuntu_application_gps_for_hybris.cpp	2016-04-04 06:59:39 +0000
@@ -39,6 +39,7 @@
     void delete_aiding_data(UHardwareGpsAidingData flags);
 
     void set_server_for_type(UHardwareGpsAGpsType type, const char* hostname, uint16_t port);
+    void set_set_id(UHardwareGpsAgpsSetIdType type, const char* id);
     void set_reference_location(UHardwareGpsAGpsRefLocation* location, size_t size_of_struct);
 
     void notify_connection_is_open(const char* apn);
@@ -77,8 +78,25 @@
 
 namespace
 {
+namespace bits
+{
+// is_set determines if bit is set in the bitset over
+// a unique_integral
+bool is_set(uint32_t bit, const uint32_t* it, const uint32_t* itE)
+{
+    static const uint32_t bits_per_element = sizeof(uint32_t) * 8;
+    
+    uint32_t element_count = itE - it;
+    uint32_t idx = bit / (element_count * bits_per_element);
+
+    if (idx >= element_count)
+        return false;
+
+    return *(it + idx) & (1 << (bit % bits_per_element));
+}
+}
+
 UHardwareGps hybris_gps_instance = NULL;
-}
 
 static void location_callback(GpsLocation* location)
 {
@@ -142,7 +160,6 @@
     hybris_gps_instance->request_utc_time_cb(hybris_gps_instance->context);
 }
 
-
 typedef struct 
 {
     void (*func)(void *);
@@ -254,7 +271,7 @@
     agps_request_ref_location,
     create_thread_callback,
 };
-
+}
 
 UHardwareGps_::UHardwareGps_(UHardwareGpsParams* params)
     : gps_interface(NULL),
@@ -371,6 +388,12 @@
         agps_interface->set_server(type, hostname, port);
 }
 
+void UHardwareGps_::set_set_id(UHardwareGpsAgpsSetIdType type, const char* id)
+{
+    if (agps_ril_interface && agps_ril_interface->set_set_id)
+        agps_ril_interface->set_set_id(static_cast<AGpsSetIDType>(type), id);
+}
+
 void UHardwareGps_::set_reference_location(UHardwareGpsAGpsRefLocation* location, size_t size_of_struct)
 {
     AGpsRefLocation ref_loc;
@@ -483,6 +506,14 @@
     self->set_server_for_type(type, hostname, port);
 }
 
+void u_hardware_gps_agps_set_set_id(
+        UHardwareGps self,
+        UHardwareGpsAgpsSetIdType type,
+        const char* set_id)
+{
+    self->set_set_id(type, set_id);
+}
+
 void u_hardware_gps_agps_set_reference_location(
     UHardwareGps self,
     UHardwareGpsAGpsRefLocation *location,
@@ -521,3 +552,44 @@
 {
     self->inject_xtra_data(data, length);
 }
+
+void u_hardware_gps_sv_status_enumerate_svs(UHardwareGpsSvStatus* status, UHardwareGpsSvEnumerator enumerator, void* cookie)
+{
+    GpsSvStatus* s = reinterpret_cast<GpsSvStatus*>(status);
+
+#if defined(BOARD_HAS_SUPPORT_FOR_ADDITIONAL_SATELLITE_NETWORKS)
+    const unsigned int element_count = 8;
+    const uint32_t* am = &s->almanac_mask[0];
+    const uint32_t* em = &s->ephemeris_mask[0];
+    const uint32_t* uifm = &s->used_in_fix_mask[0];
+#else
+    const unsigned int element_count = 1;
+    const uint32_t* am = &s->almanac_mask;
+    const uint32_t* em = &s->ephemeris_mask;
+    const uint32_t* uifm = &s->used_in_fix_mask;
+#endif
+    
+    for (int i = 0; i < s->num_svs; i++)
+    {
+        UHardwareGpsSvInfo info; ::memset(&info, 0, sizeof(info));
+        info.prn = s->sv_list[i].prn;
+        info.snr = s->sv_list[i].snr;
+        info.elevation = s->sv_list[i].elevation;
+        info.azimuth = s->sv_list[i].azimuth;
+
+        // PRN is in the range of [1, 32], adjusting it to make sure we
+        // can use it for bitfield flag testing operations.
+        int prn = s->sv_list[i].prn - 1;
+        if (prn < 0)
+            continue;
+
+        if (bits::is_set(prn, am, am + element_count))
+            info.flags |= U_HARDWARE_GPS_SV_INFO_FLAG_HAS_ALMANAC;
+        if (bits::is_set(prn, em, em + element_count))
+            info.flags |= U_HARDWARE_GPS_SV_INFO_FLAG_HAS_EPHEMERIS;
+        if (bits::is_set(prn, uifm, uifm + element_count))
+            info.flags |= U_HARDWARE_GPS_SV_INFO_FLAG_USED_IN_FIX;
+
+        enumerator(&info, cookie);
+    }
+}

=== modified file 'android/include/private/application/sensors/events.h'
--- android/include/private/application/sensors/events.h	2016-04-04 06:59:39 +0000
+++ android/include/private/application/sensors/events.h	2016-04-04 06:59:39 +0000
@@ -193,6 +193,36 @@
     MagneticEvent(const MagneticEvent&) = delete;
     MagneticEvent& operator=(const MagneticEvent&) = delete;
 };
+
+class RotationVectorEvent
+{
+public:
+    RotationVectorEvent(uint64_t timestamp, float x, float y, float z)
+        : timestamp(timestamp),
+          x(x),
+          y(y),
+          z(z)
+    {}
+
+    uint64_t get_timestamp() const
+    {
+        return this->timestamp;
+    }
+
+    float get_x_rotation() const { return this->x; }
+    float get_y_rotation() const { return this->y; }
+    float get_z_rotation() const { return this->z; }
+
+private:
+    uint64_t timestamp;
+    float x;
+    float y;
+    float z;
+
+protected:
+    RotationVectorEvent(const RotationVectorEvent&) = delete;
+    RotationVectorEvent& operator=(const RotationVectorEvent&) = delete;
+};
 }
 }
 }

=== modified file 'debian/changelog'
--- debian/changelog	2016-02-03 10:00:59 +0000
+++ debian/changelog	2016-04-04 06:59:39 +0000
@@ -1,3 +1,9 @@
+platform-api (3.1.0) UNRELEASED; urgency=medium
+
+  * Add functions for subscribing to satellite visibility updates.
+
+ -- Thomas Voß <[e-mail]>  Fri, 04 Dec 2015 16:25:53 +0100
+
 platform-api (3.0.1+16.04.20160203-0ubuntu1) xenial; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'include/ubuntu/application/location/CMakeLists.txt'
--- include/ubuntu/application/location/CMakeLists.txt	2013-08-22 05:00:52 +0000
+++ include/ubuntu/application/location/CMakeLists.txt	2016-04-04 06:59:39 +0000
@@ -6,6 +6,8 @@
   position_update.h
   service.h
   session.h
+  space_vehicle.h
+  space_vehicle_update.h
   velocity_update.h
 )
 

=== modified file 'include/ubuntu/application/location/service.h'
--- include/ubuntu/application/location/service.h	2014-09-15 20:35:52 +0000
+++ include/ubuntu/application/location/service.h	2016-04-04 06:59:39 +0000
@@ -23,6 +23,7 @@
 
 #include <ubuntu/application/location/controller.h>
 #include <ubuntu/application/location/session.h>
+#include <ubuntu/application/location/space_vehicle_update.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -83,6 +84,28 @@
     typedef UbuntuApplicationLocationServiceError UALocationServiceError;
 
     /**
+     * \brief Callback type that is invoked for updates to the visibility of space vehicles.
+     * \ingroup location_service
+     */
+    typedef void (*UALocationServiceSpaceVehicleUpdateHandler)(
+        UALocationSpaceVehicleUpdate *update,
+        void *context);
+
+    /**
+     * \brief Installs an app-specific handler for updates to the visibility of space vehicles.
+     * \ingroup location_service
+     * \param[in] handler The space-vehicle visibiility updates handler.
+     * \param[in] context Application-specific, may be null.
+     *
+     * A space vehicle handler can be reset by calling this function with:
+     *   ua_location_service_set_space_vehicle_handler(NULL, NULL);
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_location_service_set_space_vehicle_update_handler(
+        UALocationServiceSpaceVehicleUpdateHandler handler,
+        void *context);
+
+    /**
      * \brief Creates a new session with the location service for low positional accuracy requirements.
      * \ingroup location_service
      * \returns A new session or NULL if the requirements cannot be

=== added file 'include/ubuntu/application/location/space_vehicle.h'
--- include/ubuntu/application/location/space_vehicle.h	1970-01-01 00:00:00 +0000
+++ include/ubuntu/application/location/space_vehicle.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef UBUNTU_APPLICATION_LOCATION_SPACE_VEHICLE_H_
+#define UBUNTU_APPLICATION_LOCATION_SPACE_VEHICLE_H_
+
+#include <ubuntu/visibility.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /**
+     * \brief Enumerates all known satellite-positioning systems and associated vehicle types.
+     * \ingroup location_service
+     */
+    typedef enum
+    {
+        UA_LOCATION_SPACE_VEHICLE_TYPE_UNKNOWN, /**< Unknown type. */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_BEIDOU, /**< People's Republic of China's regional system, currently limited to Asia and the West Pacific */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_GALILEO, /**< A global system being developed by the European Union and other partner countries, planned to be operational by 2014 (and fully deployed by 2019). */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_GLONASS, /**< Russia's global navigation system. Fully operational worldwide. */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_GPS, /**< Fully operational worldwide. */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_COMPASS, /**< People's Republic of China's global system, planned to be operational by 2020. */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_IRNSS, /**< India's regional navigation system, planned to be operational by 2014, covering India and Northern Indian Ocean. */
+        UA_LOCATION_SPACE_VEHICLE_TYPE_QZSS /**< Japanese regional system covering Asia and Oceania. */
+    } UbuntuApplicationLocationSpaceVehicleType;
+
+    typedef UbuntuApplicationLocationSpaceVehicleType UALocationSpaceVehicleType;
+
+    /**
+     * \brief Opaque type describing a space vehicle.
+     * \ingroup location_service
+     */
+    typedef struct UbuntuApplicationLocationSpaceVehicle UALocationSpaceVehicle;
+
+    /**
+     * \brief Increments the reference count of the update instance.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle instance to increment the reference count for.
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_location_space_vehicle_ref(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Decrements the reference count of the vehicle instance.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle instance to decrement the reference count for.
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_location_space_vehicle_unref(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries the type of the space vehicle.
+     * \ingroup location_service
+     */
+    UBUNTU_DLL_PUBLIC UALocationSpaceVehicleType
+    ua_location_space_vehicle_get_type(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries the unique numeric id of the vehicle instance.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle instance to query the id for.
+     */
+    UBUNTU_DLL_PUBLIC uint32_t
+    ua_location_space_vehicle_get_id(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries the signal-to-noise ratio for measurements received from the vehicle instance.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query the snr for.
+     */
+    UBUNTU_DLL_PUBLIC float
+    ua_location_space_vehicle_get_snr(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries whether we have almanac data for the vehicle available.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query.
+     */
+    UBUNTU_DLL_PUBLIC bool
+    ua_location_space_vehicle_has_almanac_data(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries whether we have ephimeris data for the vehicle available.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query.
+     */
+    UBUNTU_DLL_PUBLIC bool
+    ua_location_space_vehicle_has_ephimeris_data(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries whether the vehicle is used in caluclating the fix.
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query.
+     */
+    UBUNTU_DLL_PUBLIC bool
+    ua_location_space_vehicle_is_used_in_fix(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries the azimuth of the vehicle in [rad].
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query.
+     */
+    UBUNTU_DLL_PUBLIC float
+    ua_location_space_vehicle_azimuth_in_radians(
+        UALocationSpaceVehicle *vehicle);
+
+    /**
+     * \brief Queries the elevation of the vehicle in [rad].
+     * \ingroup location_service
+     * \param[in] vehicle The vehicle to query.
+     */
+    UBUNTU_DLL_PUBLIC float
+    ua_location_space_vehicle_elevation_in_radians(
+        UALocationSpaceVehicle *vehicle);
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // UBUNTU_APPLICATION_LOCATION_SPACE_VEHICLE_H_

=== added file 'include/ubuntu/application/location/space_vehicle_update.h'
--- include/ubuntu/application/location/space_vehicle_update.h	1970-01-01 00:00:00 +0000
+++ include/ubuntu/application/location/space_vehicle_update.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef UBUNTU_APPLICATION_LOCATION_SPACE_VEHICLE_UPDATE_H_
+#define UBUNTU_APPLICATION_LOCATION_SPACE_VEHICLE_UPDATE_H_
+
+#include <ubuntu/visibility.h>
+
+#include <ubuntu/application/location/space_vehicle.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /**
+     * \brief Opaque type encapsulating an update to visibility of space vehicles.
+     * \ingroup location_service
+     */
+    typedef struct UbuntuApplicationLocationSpaceVehicleUpdate UALocationSpaceVehicleUpdate;
+
+    /**
+     * \brief Increments the reference count of the update instance.
+     * \ingroup location_service
+     * \param[in] update The update instance to increment the reference count for.
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_location_space_vehicle_update_ref(
+        UALocationSpaceVehicleUpdate *update);
+
+    /**
+     * \brief Decrements the reference count of the update instance.
+     * \ingroup location_service
+     * \param[in] update The update instance to decrement the reference count for.
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_location_space_vehicle_update_unref(
+        UALocationSpaceVehicleUpdate *update);
+
+    /**
+     * \brief Queries the number of space vehicles contained within this update.
+     * \ingroup location_service
+     * \param[in] update The update instance to be queried.
+     */
+    UBUNTU_DLL_PUBLIC uint32_t
+    ua_location_space_vehicle_update_get_size(
+        UALocationSpaceVehicleUpdate *update);
+
+    /**
+     * \brief Queries the vehicle at index idx. Returns null if idx exceeds bounds.
+     * \ingroup location_service
+     * \param[in] idx The index, has to satisfy 0 <= idx < ua_location_space_vehicle_update_get_size.
+     * \param[in] update The update instance to be queried.
+     */
+    UBUNTU_DLL_PUBLIC UALocationSpaceVehicle*
+    ua_location_space_vehicle_update_at(
+        uint32_t idx,
+        UALocationSpaceVehicleUpdate* update);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UBUNTU_APPLICATION_LOCATION_POSITION_UPDATE_H_

=== modified file 'include/ubuntu/application/sensors/CMakeLists.txt'
--- include/ubuntu/application/sensors/CMakeLists.txt	2016-04-04 06:59:39 +0000
+++ include/ubuntu/application/sensors/CMakeLists.txt	2016-04-04 06:59:39 +0000
@@ -7,6 +7,7 @@
   proximity.h
   haptic.h
   orientation.h
+  rotation_vector.h
 )
 
 install(

=== modified file 'include/ubuntu/application/sensors/event/CMakeLists.txt'
--- include/ubuntu/application/sensors/event/CMakeLists.txt	2016-04-04 06:59:39 +0000
+++ include/ubuntu/application/sensors/event/CMakeLists.txt	2016-04-04 06:59:39 +0000
@@ -6,6 +6,7 @@
   magnetic.h
   proximity.h
   orientation.h
+  rotation_vector.h
 )
 
 install(

=== added file 'include/ubuntu/application/sensors/event/rotation_vector.h'
--- include/ubuntu/application/sensors/event/rotation_vector.h	1970-01-01 00:00:00 +0000
+++ include/ubuntu/application/sensors/event/rotation_vector.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2015 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_EVENT_H_
+#define UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_EVENT_H_
+
+#include <ubuntu/visibility.h>
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     * \brief Opaque type describing a rotation vector reading.
+     * \ingroup sensor_access
+     */
+    typedef void UASRotationVectorEvent;
+
+    /**
+     * \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.
+     */
+    UBUNTU_DLL_PUBLIC uint64_t
+    uas_rotation_vector_event_get_timestamp(
+        UASRotationVectorEvent* event);
+
+    /**
+     * \brief Query the x component of the rotation vector.
+     * \ingroup sensor_access
+     * \returns The rotation vector's x component.
+     * \param[in] event The reading to be queried.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    uas_rotation_vector_event_get_x_axis(
+        UASRotationVectorEvent* event,
+        float* value);
+
+    /**
+     * \brief Query the y component of the rotation vector.
+     * \ingroup sensor_access
+     * \returns The rotation vector's y component.
+     * \param[in] event The reading to be queried.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    uas_rotation_vector_event_get_y_axis(
+        UASRotationVectorEvent* event,
+        float* value);
+
+    /**
+     * \brief Query the z component of the rotation vector.
+     * \ingroup sensor_access
+     * \returns The rotation vector's z component.
+     * \param[in] event The reading to be queried.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    uas_rotation_vector_event_get_z_axis(
+        UASRotationVectorEvent* event,
+        float* value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_EVENT_H_

=== added file 'include/ubuntu/application/sensors/rotation_vector.h'
--- include/ubuntu/application/sensors/rotation_vector.h	1970-01-01 00:00:00 +0000
+++ include/ubuntu/application/sensors/rotation_vector.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2015 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_H_
+#define UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_H_
+
+#include <ubuntu/status.h>
+#include <ubuntu/visibility.h>
+
+#include <ubuntu/application/sensors/event/rotation_vector.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     * \brief Opaque type that models the virtual rotation vector sensor.
+     * \ingroup sensor_access
+     */
+    typedef void UASensorsRotationVector;
+
+    /**
+     * \brief Callback type used by applications to subscribe to rotation vector events.
+     * \ingroup sensor_access
+     */
+    typedef void (*on_rotation_vector_event_cb)(UASRotationVectorEvent* event,
+                                                void* context);
+
+    /**
+     * \brief Create a new object for accessing the gyroscopic sensor.
+     * \ingroup sensor_access
+     * \returns A new instance or NULL in case of errors.
+     */
+    UBUNTU_DLL_PUBLIC UASensorsRotationVector*
+    ua_sensors_rotation_vector_new();
+
+    /**
+     * \brief Enables the supplied rotation_vector 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.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_enable(
+        UASensorsRotationVector* sensor);
+
+    /**
+     * \brief Disables the supplied rotation vector 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.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_disable(
+        UASensorsRotationVector* 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.
+     */
+    UBUNTU_DLL_PUBLIC uint32_t
+    ua_sensors_rotation_vector_get_min_delay(
+        UASensorsRotationVector* 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.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_get_min_value(
+        UASensorsRotationVector* sensor,
+        float* value);
+
+    /**
+     * \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.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_get_max_value(
+        UASensorsRotationVector* sensor,
+        float* value);
+
+    /**
+     * \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.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_get_resolution(
+        UASensorsRotationVector* sensor,
+        float* value);
+
+    /**
+     * \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.
+     */
+    UBUNTU_DLL_PUBLIC void
+    ua_sensors_rotation_vector_set_reading_cb(
+        UASensorsRotationVector* sensor,
+        on_rotation_vector_event_cb cb,
+        void *ctx);
+
+    /**
+     * \brief Set the sensor event delivery rate in nanoseconds..
+     * \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 modified.
+     * \param[in] rate The new event delivery rate.
+     */
+    UBUNTU_DLL_PUBLIC UStatus
+    ua_sensors_rotation_vector_set_event_rate(
+        UASensorsRotationVector* sensor,
+        uint32_t rate);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UBUNTU_APPLICATION_SENSORS_ROTATION_VECTOR_H_

=== modified file 'include/ubuntu/hardware/gps.h'
--- include/ubuntu/hardware/gps.h	2014-05-14 16:55:19 +0000
+++ include/ubuntu/hardware/gps.h	2016-04-04 06:59:39 +0000
@@ -141,6 +141,19 @@
 };
 
 /**
+ * Known AGPS set id types
+ * \ingroup gps_access
+ */
+typedef enum
+{
+    U_HARDWARE_GPS_AGPS_SETID_TYPE_NONE = 0,
+    U_HARDWARE_GPS_AGPS_SETID_TYPE_IMSI = 1,
+    U_HARDWARE_GPS_AGPS_SETID_TYPE_MSISDN = 2
+} UbuntuHardwareGpsAgpsSetIdType;
+
+typedef UbuntuHardwareGpsAgpsSetIdType UHardwareGpsAgpsSetIdType;
+
+/**
  * Known positioning modes
  * \ingroup gps_access
  */
@@ -180,6 +193,19 @@
     U_HARDWARE_GPS_AGPS_DATA_CONN_FAILED = 5
 };
 
+typedef enum
+{
+    /** The respective space vehicle has almanac data available. */
+    U_HARDWARE_GPS_SV_INFO_FLAG_HAS_ALMANAC = 1 << 0,
+    /** The respective space vehicle has ephemeris data available. */
+    U_HARDWARE_GPS_SV_INFO_FLAG_HAS_EPHEMERIS = 1 << 1,
+    /** The respective satellite is used in calculating the current position estimate. */
+    U_HARDWARE_GPS_SV_INFO_FLAG_USED_IN_FIX = 1 << 2
+} UbuntuHardwareGpsSvInfoFlags;
+
+/** Bundles together flags describing a visible space vehicle. */
+typedef UbuntuHardwareGpsSvInfoFlags UHardwareGpsSvInfoFlags;
+
 /** Flags used to specify which aiding data to delete
     when calling delete_aiding_data(). */
 typedef uint16_t UHardwareGpsAidingData;
@@ -203,6 +229,24 @@
 #define U_HARDWARE_GPS_AGPS_TYPE_SUPL          1
 #define U_HARDWARE_GPS_AGPS_TYPE_C2K           2
 
+/** Known AGPS set id request types. */
+typedef enum
+{
+    U_HARDWARE_GPS_AGPS_REQUEST_SETID_IMSI = 1,
+    U_HARDWARE_GPS_AGPS_REQUEST_SETID_MSISDN = 2
+} UbuntuHardwareGpsAgpsRequestSetIdType;
+
+typedef UbuntuHardwareGpsAgpsRequestSetIdType UHardwareGpsAgpsRequestSetIdType;
+
+/** Known AGPS reference location request types. */
+typedef enum
+{
+    U_HARDWARE_GPS_AGPS_REQUEST_REFLOC_CELLID = 1,
+    U_HARDWARE_GPS_AGPS_REQUEST_REFLOC_MAC = 2
+} UbuntuHardwareGpsAgpsRequestRefLocType;
+
+typedef UbuntuHardwareGpsAgpsRequestRefLocType UHardwareGpsAgpsRequestRefLocType;
+
 /** Known types for AGps reference locations. */
 /** A GSM cell ID. */
 #define U_HARDWARE_GPS_AGPS_REF_LOCATION_TYPE_GSM_CELLID   1
@@ -255,12 +299,12 @@
  * \ingroup gps_access
  */
 typedef struct {
-    /** set to sizeof(UHardwareGpsSvInfo) */
-    size_t size;
     /** Pseudo-random number for the SV. */
     int prn;
     /** Signal to noise ratio. */
     float snr;
+    /** Describes ephimeris/almanac/used in fix, contains U_HARDWARE_GPS_SV_INFO_* */
+    uint32_t flags;
     /** Elevation of SV in degrees. */
     float elevation;
     /** Azimuth of SV in degrees. */
@@ -271,32 +315,19 @@
  * Represents SV (Space Vehicle) status.
  * \ingroup gps_access
  */
-typedef struct {
-    /** set to sizeof(GpsSvStatus) */
-    size_t size;
-
-    /** Number of SVs currently visible. */
-    int num_svs;
-
-    /** Contains an array of SV information. */
-    UHardwareGpsSvInfo sv_list[U_HARDWARE_GPS_MAX_SVS];
-
-    /** Represents a bit mask indicating which SVs
-     * have ephemeris data.
-     */
-    uint32_t ephemeris_mask;
-
-    /** Represents a bit mask indicating which SVs
-     * have almanac data.
-     */
-    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;
-} UHardwareGpsSvStatus;
+typedef struct UbuntuHardwareGpsSvStatus UHardwareGpsSvStatus;
+
+/**
+ * Invoked for every satellite that is part of a space vehicle visibility update.
+ * \ingroup gps_access
+ */
+typedef void(*UHardwareGpsSvEnumerator)(UHardwareGpsSvInfo*, void*);
+
+/**
+ * @brief u_hardware_gps_sv_status_enumerate_svs invokes enumerator for all space vehicles in status.
+ * \ingroup gps_access
+ */
+UBUNTU_DLL_PUBLIC void u_hardware_gps_sv_status_enumerate_svs(UHardwareGpsSvStatus*, UHardwareGpsSvEnumerator enumerator, void*);
 
 /**
  * Represents the status of AGPS.
@@ -500,6 +531,17 @@
     UHardwareGpsLocation location);
 
 /**
+  * \brief Injects set id information into the GPS chipset.
+  * \param self The instance to apply the change to.
+  * \param type The type of the set_id.
+  * \param set_id The set_id.
+  */
+UBUNTU_DLL_PUBLIC void
+u_hardware_gps_agps_set_set_id(
+        UHardwareGps self,
+        UHardwareGpsAgpsSetIdType type,
+        const char* set_id);
+/**
   * \brief Informs the GPS chipset about wifi ap's or radio cells to be used in AGPS calls.
   * \param self The instance to inform.
   * \param location The reference location, that is a wifi ap or a radio cell.

=== modified file 'src/ubuntu/application/base_module.h'
--- src/ubuntu/application/base_module.h	2015-03-25 23:13:33 +0000
+++ src/ubuntu/application/base_module.h	2016-04-04 06:59:39 +0000
@@ -28,7 +28,7 @@
  */
 
 #define API_VERSION_MAJOR   "3"
-#define API_VERSION_MINOR   "0"
+#define API_VERSION_MINOR   "1"
 #define API_VERSION_PATCH   "0"
 #define SO_SUFFIX ".so." API_VERSION_MAJOR "." API_VERSION_MINOR "." API_VERSION_PATCH
 

=== modified file 'src/ubuntu/application/common/application/location/CMakeLists.txt'
--- src/ubuntu/application/common/application/location/CMakeLists.txt	2014-02-13 09:45:21 +0000
+++ src/ubuntu/application/common/application/location/CMakeLists.txt	2016-04-04 06:59:39 +0000
@@ -20,6 +20,8 @@
 
   heading_update.cpp
   position_update.cpp
+  space_vehicle.cpp
+  space_vehicle_update.cpp
   velocity_update.cpp
 )
 

=== modified file 'src/ubuntu/application/common/application/location/instance.h'
--- src/ubuntu/application/common/application/location/instance.h	2014-08-12 08:23:11 +0000
+++ src/ubuntu/application/common/application/location/instance.h	2016-04-04 06:59:39 +0000
@@ -22,6 +22,9 @@
 #include "ubuntu/visibility.h"
 
 #include "ubuntu/application/location/controller.h"
+#include "ubuntu/application/location/service.h"
+
+#include "space_vehicle_update_p.h"
 
 #include <com/ubuntu/location/service/stub.h>
 
@@ -52,6 +55,14 @@
         changed_handler_context = context;
     }
 
+    void set_space_vehicle_update_handler_with_context(
+            UALocationServiceSpaceVehicleUpdateHandler handler,
+            void* context)
+    {
+        space_vehicle_update_handler = handler;
+        space_vehicle_update_handler_context = context;        
+    }
+
   private:
     Instance()
         : bus(std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::system)),
@@ -97,11 +108,24 @@
                   // And notify change handler if one is set.
                   if (changed_handler)
                       changed_handler(cached_state_flags, changed_handler_context);
+              }),
+              service->visible_space_vehicles().changed().connect([this](const std::map<com::ubuntu::location::SpaceVehicle::Key, com::ubuntu::location::SpaceVehicle>& update) 
+              {
+                  if (space_vehicle_update_handler)
+                  {
+                      std::vector<com::ubuntu::location::SpaceVehicle> svs;
+                      for (const auto& pair: update) svs.push_back(pair.second);
+                      auto upd = new UALocationSpaceVehicleUpdate{svs};
+                      space_vehicle_update_handler(upd, space_vehicle_update_handler_context);
+                      upd->unref();
+                  }
               })
           },
           cached_state_flags{0},
           changed_handler{nullptr},
-          changed_handler_context{nullptr}
+          changed_handler_context{nullptr},
+          space_vehicle_update_handler{nullptr},
+          space_vehicle_update_handler_context{nullptr}
     {
         bus->install_executor(executor);
         worker = std::move(std::thread([&]() { bus->run(); }));
@@ -132,12 +156,17 @@
     {
         core::ScopedConnection on_does_satellite_based_positioning_changed;
         core::ScopedConnection on_is_online_changed;
+        core::ScopedConnection on_space_vehicles_updated;
     } connections;
 
     // All change-handler specifics go here.
     UALocationServiceStatusFlags cached_state_flags;
+
     UALocationServiceStatusChangedHandler changed_handler;
     void* changed_handler_context;
+
+    UALocationServiceSpaceVehicleUpdateHandler space_vehicle_update_handler;
+    void* space_vehicle_update_handler_context;
 };
 
 #endif // INSTANCE_H_

=== modified file 'src/ubuntu/application/common/application/location/service.cpp'
--- src/ubuntu/application/common/application/location/service.cpp	2014-09-15 20:35:52 +0000
+++ src/ubuntu/application/common/application/location/service.cpp	2016-04-04 06:59:39 +0000
@@ -31,6 +31,14 @@
 namespace cul = com::ubuntu::location;
 namespace culs = com::ubuntu::location::service;
 
+void
+ua_location_service_set_space_vehicle_update_handler(
+    UALocationServiceSpaceVehicleUpdateHandler handler,
+    void *context)
+{
+    Instance::instance().set_space_vehicle_update_handler_with_context(handler, context);
+}
+
 UALocationServiceSession*
 ua_location_service_create_session_for_low_accuracy(
     UALocationServiceRequirementsFlags /*flags*/)

=== added file 'src/ubuntu/application/common/application/location/space_vehicle.cpp'
--- src/ubuntu/application/common/application/location/space_vehicle.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/application/common/application/location/space_vehicle.cpp	2016-04-04 06:59:39 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include "space_vehicle_p.h"
+
+void ua_location_space_vehicle_ref(UALocationSpaceVehicle *vehicle)
+{
+    vehicle->ref();
+}
+
+void ua_location_space_vehicle_unref(UALocationSpaceVehicle *vehicle)
+{
+    vehicle->unref();
+}
+
+UALocationSpaceVehicleType ua_location_space_vehicle_get_type(UALocationSpaceVehicle *vehicle)
+{
+    return static_cast<UALocationSpaceVehicleType>(vehicle->sv.key.type);
+}
+
+uint32_t ua_location_space_vehicle_get_id(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.key.id;
+}
+
+float ua_location_space_vehicle_get_snr(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.snr;
+}
+
+bool ua_location_space_vehicle_has_almanac_data(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.has_almanac_data;
+}
+
+bool ua_location_space_vehicle_has_ephimeris_data(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.has_ephimeris_data;
+}
+
+bool ua_location_space_vehicle_is_used_in_fix(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.used_in_fix;
+}
+
+float ua_location_space_vehicle_azimuth_in_radians(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.azimuth.value();
+}
+
+float ua_location_space_vehicle_elevation_in_radians(UALocationSpaceVehicle *vehicle)
+{
+    return vehicle->sv.elevation.value();
+}
+

=== added file 'src/ubuntu/application/common/application/location/space_vehicle_p.h'
--- src/ubuntu/application/common/application/location/space_vehicle_p.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/application/common/application/location/space_vehicle_p.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015 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]>
+ */
+
+#ifndef SPACE_VEHICLE_PRIVATE_H_
+#define SPACE_VEHICLE_PRIVATE_H_
+
+#include "ubuntu/application/location/space_vehicle.h"
+
+#include "ref_counted.h"
+
+#include <com/ubuntu/location/space_vehicle.h>
+
+namespace cul = com::ubuntu::location;
+
+struct UbuntuApplicationLocationSpaceVehicle : public detail::RefCounted
+{
+    UbuntuApplicationLocationSpaceVehicle(const cul::SpaceVehicle& sv) : sv(sv)
+    {
+    }
+
+    cul::SpaceVehicle sv;
+};
+
+#endif  // SPACE_VEHICLE_PRIVATE_H_
+

=== added file 'src/ubuntu/application/common/application/location/space_vehicle_update.cpp'
--- src/ubuntu/application/common/application/location/space_vehicle_update.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/application/common/application/location/space_vehicle_update.cpp	2016-04-04 06:59:39 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include "space_vehicle_p.h"
+#include "space_vehicle_update_p.h"
+
+void ua_location_space_vehicle_update_ref(UALocationSpaceVehicleUpdate *update)
+{
+    update->ref();
+}
+
+void ua_location_space_vehicle_update_unref(UALocationSpaceVehicleUpdate *update)
+{
+    update->unref();
+}
+
+uint32_t ua_location_space_vehicle_update_get_size(UALocationSpaceVehicleUpdate *update)
+{
+    return update->svs.size();
+}
+
+UALocationSpaceVehicle* ua_location_space_vehicle_update_at(uint32_t idx, UALocationSpaceVehicleUpdate* update)
+{
+    if (idx >= update->svs.size())
+        return nullptr;
+
+    return new UbuntuApplicationLocationSpaceVehicle{update->svs[idx]};
+}
+

=== added file 'src/ubuntu/application/common/application/location/space_vehicle_update_p.h'
--- src/ubuntu/application/common/application/location/space_vehicle_update_p.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/application/common/application/location/space_vehicle_update_p.h	2016-04-04 06:59:39 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2015 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]>
+ */
+
+#ifndef SPACE_VEHICLE_UPDATE_PRIVATE_H_
+#define SPACE_VEHICLE_UPDATE_PRIVATE_H_
+
+#include "ubuntu/application/location/space_vehicle_update.h"
+
+#include "ref_counted.h"
+
+#include <com/ubuntu/location/space_vehicle.h>
+
+#include <vector>
+
+namespace cul = com::ubuntu::location;
+
+struct UbuntuApplicationLocationSpaceVehicleUpdate : public detail::RefCounted
+{
+    UbuntuApplicationLocationSpaceVehicleUpdate(const std::vector<cul::SpaceVehicle>& svs) : svs(svs)
+    {
+    }
+
+    std::vector<cul::SpaceVehicle> svs;     
+};
+
+#endif // SPACE_VEHICLE_UPDATE_PRIVATE_H_

=== modified file 'src/ubuntu/application/desktop/module_version.h'
--- src/ubuntu/application/desktop/module_version.h	2015-06-17 21:21:53 +0000
+++ src/ubuntu/application/desktop/module_version.h	2016-04-04 06:59:39 +0000
@@ -1,3 +1,3 @@
 #define MODULE_VERSION_MAJOR  3
-#define MODULE_VERSION_MINOR  0
+#define MODULE_VERSION_MINOR  1
 #define MODULE_VERSION_PATCH  0

=== modified file 'src/ubuntu/application/desktop/ubuntu_application_sensors_desktop.cpp'
--- src/ubuntu/application/desktop/ubuntu_application_sensors_desktop.cpp	2016-04-04 06:59:39 +0000
+++ src/ubuntu/application/desktop/ubuntu_application_sensors_desktop.cpp	2016-04-04 06:59:39 +0000
@@ -22,6 +22,7 @@
 #include <ubuntu/application/sensors/orientation.h>
 #include <ubuntu/application/sensors/gyroscope.h>
 #include <ubuntu/application/sensors/magnetic.h>
+#include <ubuntu/application/sensors/rotation_vector.h>
 
 #include <stddef.h>
 
@@ -558,3 +559,99 @@
 
     return U_STATUS_SUCCESS;
 }
+
+// Gyroscope Sensor
+UASensorsRotationVector* ua_sensors_rotation_vector_new()
+{
+    return NULL;
+}
+
+UStatus ua_sensors_rotation_vector_enable(UASensorsRotationVector*)
+{
+    return (UStatus) 0;
+}
+
+UStatus ua_sensors_rotation_vector_disable(UASensorsRotationVector*)
+{
+    return (UStatus) 0;
+}
+
+uint32_t ua_sensors_rotation_vector_get_min_delay(UASensorsRotationVector*)
+{
+    return 0;
+}
+
+UStatus ua_sensors_rotation_vector_get_min_value(UASensorsRotationVector*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus ua_sensors_rotation_vector_get_max_value(UASensorsRotationVector*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus ua_sensors_rotation_vector_get_resolution(UASensorsRotationVector*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+void ua_sensors_rotation_vector_set_reading_cb(UASensorsRotationVector*, on_rotation_vector_event_cb, void *)
+{
+}
+
+UStatus ua_sensors_rotation_vector_set_event_rate(UASensorsRotationVector*, uint32_t)
+{
+    return U_STATUS_SUCCESS;
+}
+
+// RotationVector Sensor Event
+uint64_t uas_rotation_vector_event_get_timestamp(UASRotationVectorEvent*)
+{
+    return 0;
+}
+
+UStatus uas_rotation_vector_event_get_x_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus uas_rotation_vector_event_get_y_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus uas_rotation_vector_event_get_z_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}

=== modified file 'src/ubuntu/application/testbackend/module_version.h'
--- src/ubuntu/application/testbackend/module_version.h	2015-03-25 23:01:58 +0000
+++ src/ubuntu/application/testbackend/module_version.h	2016-04-04 06:59:39 +0000
@@ -1,3 +1,3 @@
 #define MODULE_VERSION_MAJOR  3
-#define MODULE_VERSION_MINOR  0
+#define MODULE_VERSION_MINOR  1
 #define MODULE_VERSION_PATCH  0

=== modified file 'src/ubuntu/application/testbackend/test_stubs.cpp'
--- src/ubuntu/application/testbackend/test_stubs.cpp	2015-09-29 12:21:55 +0000
+++ src/ubuntu/application/testbackend/test_stubs.cpp	2016-04-04 06:59:39 +0000
@@ -149,6 +149,10 @@
 }
 
 // Location
+void ua_location_service_set_space_vehicle_update_handler(UALocationServiceSpaceVehicleUpdateHandler, void*)
+{
+}
+
 void ua_location_service_controller_ref(UALocationServiceController*)
 {
 }
@@ -317,6 +321,72 @@
     return 0;
 }
 
+void ua_location_space_vehicle_update_ref(UALocationSpaceVehicleUpdate*)
+{
+}
+
+void ua_location_space_vehicle_update_unref(UALocationSpaceVehicleUpdate*)
+{
+}
+
+uint32_t ua_location_space_vehicle_update_get_size(UALocationSpaceVehicleUpdate*)
+{
+    return 0;
+}
+
+UALocationSpaceVehicle* ua_location_space_vehicle_update_at(uint32_t, UALocationSpaceVehicleUpdate*)
+{
+    return nullptr;
+}
+
+void ua_location_space_vehicle_ref(UALocationSpaceVehicle*)
+{
+}
+
+void ua_location_space_vehicle_unref(UALocationSpaceVehicle*)
+{
+}
+
+UALocationSpaceVehicleType ua_location_space_vehicle_get_type(UALocationSpaceVehicle*)
+{
+    return UA_LOCATION_SPACE_VEHICLE_TYPE_UNKNOWN;
+}
+
+uint32_t ua_location_space_vehicle_get_id(UALocationSpaceVehicle*)
+{
+    return 42;
+}
+
+float ua_location_space_vehicle_get_snr(UALocationSpaceVehicle*)
+{
+    return 0;
+}
+
+bool ua_location_space_vehicle_has_almanac_data(UALocationSpaceVehicle*)
+{
+    return false;
+}
+
+bool ua_location_space_vehicle_has_ephimeris_data(UALocationSpaceVehicle*)
+{
+    return false;
+}
+
+bool ua_location_space_vehicle_is_used_in_fix(UALocationSpaceVehicle*)
+{
+    return false;
+}
+
+float ua_location_space_vehicle_azimuth_in_radians(UALocationSpaceVehicle*)
+{
+    return 0;
+}
+
+float ua_location_space_vehicle_elevation_in_radians(UALocationSpaceVehicle*)
+{
+    return 45;
+}
+
 // URL Dispatcher
 
 UAUrlDispatcherSession* ua_url_dispatcher_session()

=== modified file 'src/ubuntu/application/testbackend/ubuntu_application_sensors.cpp'
--- src/ubuntu/application/testbackend/ubuntu_application_sensors.cpp	2016-04-04 06:59:39 +0000
+++ src/ubuntu/application/testbackend/ubuntu_application_sensors.cpp	2016-04-04 06:59:39 +0000
@@ -29,6 +29,7 @@
 #include <ubuntu/application/sensors/haptic.h>
 #include <ubuntu/application/sensors/gyroscope.h>
 #include <ubuntu/application/sensors/magnetic.h>
+#include <ubuntu/application/sensors/rotation_vector.h>
 
 #include <cstddef>
 #include <cstdlib>
@@ -1078,3 +1079,107 @@
 
     return U_STATUS_SUCCESS;
 }
+
+/***************************************
+ *
+ * Rotation Vector API
+ *
+ ***************************************/
+UASensorsRotationVector* ua_sensors_rotation_vector_new()
+{
+    return SensorController::instance().get(ubuntu_sensor_type_rotation_vector);
+}
+
+UStatus ua_sensors_rotation_vector_enable(UASensorsRotationVector* s)
+{
+    static_cast<TestSensor*>(s)->enabled = true;
+    return (UStatus) 0;
+}
+
+UStatus ua_sensors_rotation_vector_disable(UASensorsRotationVector* s)
+{
+    static_cast<TestSensor*>(s)->enabled = true;
+    return (UStatus) 0;}
+
+uint32_t ua_sensors_rotation_vector_get_min_delay(UASensorsRotationVector* s)
+{
+    return static_cast<TestSensor*>(s)->min_delay;
+}
+
+UStatus ua_sensors_rotation_vector_get_min_value(UASensorsRotationVector* s, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = static_cast<TestSensor*>(s)->min_value;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus ua_sensors_rotation_vector_get_max_value(UASensorsRotationVector* s, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = static_cast<TestSensor*>(s)->max_value;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus ua_sensors_rotation_vector_get_resolution(UASensorsRotationVector* s, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = static_cast<TestSensor*>(s)->resolution;
+
+    return U_STATUS_SUCCESS;
+}
+
+void ua_sensors_rotation_vector_set_reading_cb(UASensorsRotationVector* s, on_rotation_vector_event_cb cb, void *ctx)
+{
+    TestSensor* sensor = static_cast<TestSensor*>(s);
+    sensor->on_event_cb = cb;
+    sensor->event_cb_context = ctx;
+}
+
+UStatus ua_sensors_rotation_vector_set_event_rate(UASensorsRotationVector*, uint32_t)
+{
+    return U_STATUS_SUCCESS;
+}
+
+// RotationVector Sensor Event
+uint64_t uas_rotation_vector_event_get_timestamp(UASRotationVectorEvent*)
+{
+    return 0;
+}
+
+UStatus uas_rotation_vector_event_get_x_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus uas_rotation_vector_event_get_y_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}
+
+UStatus uas_rotation_vector_event_get_z_axis(UASRotationVectorEvent*, float* value)
+{
+    if (!value)
+        return U_STATUS_ERROR;
+
+    *value = 0.f;
+
+    return U_STATUS_SUCCESS;
+}

=== modified file 'src/ubuntu/application/touch/hybris/ubuntu_application_sensors_hybris.cpp'
--- src/ubuntu/application/touch/hybris/ubuntu_application_sensors_hybris.cpp	2016-04-04 06:59:39 +0000
+++ src/ubuntu/application/touch/hybris/ubuntu_application_sensors_hybris.cpp	2016-04-04 06:59:39 +0000
@@ -23,6 +23,7 @@
 #include <ubuntu/application/sensors/orientation.h>
 #include <ubuntu/application/sensors/gyroscope.h>
 #include <ubuntu/application/sensors/magnetic.h>
+#include <ubuntu/application/sensors/rotation_vector.h>
 
 #include "hybris_module.h"
 
@@ -103,12 +104,29 @@
 IMPLEMENT_VOID_FUNCTION3(ua_sensors_gyroscope_set_reading_cb, UASensorsGyroscope*, on_gyroscope_event_cb, void*);
 IMPLEMENT_FUNCTION2(UStatus, ua_sensors_gyroscope_set_event_rate, UASensorsGyroscope*, uint32_t);
 
+// Rotation Vector Sensor Event
+IMPLEMENT_CTOR0(UASensorsRotationVector*, ua_sensors_rotation_vector_new);
+IMPLEMENT_FUNCTION1(UStatus, ua_sensors_rotation_vector_enable, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION1(UStatus, ua_sensors_rotation_vector_disable, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION1(uint32_t, ua_sensors_rotation_vector_get_min_delay, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION2(UStatus, ua_sensors_rotation_vector_get_min_value, UASensorsRotationVector*, float*);
+IMPLEMENT_FUNCTION2(UStatus, ua_sensors_rotation_vector_get_max_value, UASensorsRotationVector*, float*);
+IMPLEMENT_FUNCTION2(UStatus, ua_sensors_rotation_vector_get_resolution, UASensorsRotationVector*, float*);
+IMPLEMENT_VOID_FUNCTION3(ua_sensors_rotation_vector_set_reading_cb, UASensorsRotationVector*, on_gyroscope_event_cb, void*);
+IMPLEMENT_FUNCTION2(UStatus, ua_sensors_rotation_vector_set_event_rate, UASensorsRotationVector*, uint32_t);
+
 // Gyroscope Sensor Event
 IMPLEMENT_FUNCTION1(uint64_t, uas_gyroscope_event_get_timestamp, UASGyroscopeEvent*);
 IMPLEMENT_FUNCTION2(UStatus, uas_gyroscope_event_get_rate_of_rotation_around_x, UASGyroscopeEvent*, float*);
 IMPLEMENT_FUNCTION2(UStatus, uas_gyroscope_event_get_rate_of_rotation_around_y, UASGyroscopeEvent*, float*);
 IMPLEMENT_FUNCTION2(UStatus, uas_gyroscope_event_get_rate_of_rotation_around_z, UASGyroscopeEvent*, float*);
 
+// Rotation VectorSensor Event
+IMPLEMENT_FUNCTION1(uint64_t, uas_rotation_vector_event_get_timestamp, UASRotationVectorEvent*);
+IMPLEMENT_FUNCTION2(UStatus, uas_rotation_vector_event_get_x_axis, UASRotationVectorEvent*, float*);
+IMPLEMENT_FUNCTION2(UStatus, uas_rotation_vector_event_get_y_axis, UASRotationVectorEvent*, float*);
+IMPLEMENT_FUNCTION2(UStatus, uas_rotation_vector_event_get_z_axis, UASRotationVectorEvent*, float*);
+
 // Magnetic Field Sensor
 IMPLEMENT_CTOR0(UASensorsMagnetic*, ua_sensors_magnetic_new);
 IMPLEMENT_FUNCTION1(UStatus, ua_sensors_magnetic_enable, UASensorsMagnetic*);

=== modified file 'src/ubuntu/application/touch/module_version.h'
--- src/ubuntu/application/touch/module_version.h	2015-03-25 23:01:58 +0000
+++ src/ubuntu/application/touch/module_version.h	2016-04-04 06:59:39 +0000
@@ -1,3 +1,3 @@
 #define MODULE_VERSION_MAJOR  3
-#define MODULE_VERSION_MINOR  0
+#define MODULE_VERSION_MINOR  1
 #define MODULE_VERSION_PATCH  0

=== modified file 'src/ubuntu/application/ubuntu_application_api.cpp'
--- src/ubuntu/application/ubuntu_application_api.cpp	2016-04-04 06:59:39 +0000
+++ src/ubuntu/application/ubuntu_application_api.cpp	2016-04-04 06:59:39 +0000
@@ -30,6 +30,7 @@
 #include <ubuntu/application/sensors/haptic.h>
 #include <ubuntu/application/sensors/gyroscope.h>
 #include <ubuntu/application/sensors/magnetic.h>
+#include <ubuntu/application/sensors/rotation_vector.h>
 
 #include <ubuntu/application/location/service.h>
 #include <ubuntu/application/location/heading_update.h>
@@ -188,6 +189,22 @@
 IMPLEMENT_FUNCTION2(sensors, UStatus, uas_magnetic_event_get_magnetic_field_y, UASAccelerometerEvent*, float*);
 IMPLEMENT_FUNCTION2(sensors, UStatus, uas_magnetic_event_get_magnetic_field_z, UASAccelerometerEvent*, float*);
 
+// Rotation Vector Sensor Event
+IMPLEMENT_CTOR0(sensors, UASensorsRotationVector*, ua_sensors_rotation_vector_new);
+IMPLEMENT_FUNCTION1(sensors, UStatus, ua_sensors_rotation_vector_enable, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION1(sensors, UStatus, ua_sensors_rotation_vector_disable, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION1(sensors, uint32_t, ua_sensors_rotation_vector_get_min_delay, UASensorsRotationVector*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, ua_sensors_rotation_vector_get_min_value, UASensorsRotationVector*, float*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, ua_sensors_rotation_vector_get_max_value, UASensorsRotationVector*, float*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, ua_sensors_rotation_vector_get_resolution, UASensorsRotationVector*, float*);
+IMPLEMENT_VOID_FUNCTION3(sensors, ua_sensors_rotation_vector_set_reading_cb, UASensorsRotationVector*, on_gyroscope_event_cb, void*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, ua_sensors_rotation_vector_set_event_rate, UASensorsRotationVector*, uint32_t);
+
+IMPLEMENT_FUNCTION1(sensors, uint64_t, uas_rotation_vector_event_get_timestamp, UASRotationVectorEvent*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, uas_rotation_vector_event_get_x_axis, UASRotationVectorEvent*, float*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, uas_rotation_vector_event_get_y_axis, UASRotationVectorEvent*, float*);
+IMPLEMENT_FUNCTION2(sensors, UStatus, uas_rotation_vector_event_get_z_axis, UASRotationVectorEvent*, float*);
+    
 // Location
 
 IMPLEMENT_VOID_FUNCTION1(location, ua_location_service_controller_ref, UALocationServiceController*);
@@ -233,7 +250,21 @@
 IMPLEMENT_VOID_FUNCTION1(location, ua_location_velocity_update_unref, UALocationVelocityUpdate*);
 IMPLEMENT_FUNCTION1(location, uint64_t, ua_location_velocity_update_get_timestamp, UALocationVelocityUpdate*);
 IMPLEMENT_FUNCTION1(location, double, ua_location_velocity_update_get_velocity_in_meters_per_second, UALocationVelocityUpdate*);
-
+IMPLEMENT_VOID_FUNCTION2(location, ua_location_service_set_space_vehicle_update_handler, UALocationServiceSpaceVehicleUpdateHandler, void*);
+IMPLEMENT_VOID_FUNCTION1(location, ua_location_space_vehicle_update_ref, UALocationSpaceVehicleUpdate*)
+IMPLEMENT_VOID_FUNCTION1(location, ua_location_space_vehicle_update_unref, UALocationSpaceVehicleUpdate*)
+IMPLEMENT_FUNCTION1(location, uint32_t, ua_location_space_vehicle_update_get_size, UALocationSpaceVehicleUpdate*)
+IMPLEMENT_FUNCTION2(location, UALocationSpaceVehicle*, ua_location_space_vehicle_update_at, uint32_t, UALocationSpaceVehicleUpdate*)
+IMPLEMENT_VOID_FUNCTION1(location, ua_location_space_vehicle_ref, UALocationSpaceVehicle*)
+IMPLEMENT_VOID_FUNCTION1(location, ua_location_space_vehicle_unref, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, UALocationSpaceVehicleType, ua_location_space_vehicle_get_type, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, uint32_t, ua_location_space_vehicle_get_id, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, float, ua_location_space_vehicle_get_snr, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, bool, ua_location_space_vehicle_has_almanac_data, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, bool, ua_location_space_vehicle_has_ephimeris_data, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, bool, ua_location_space_vehicle_is_used_in_fix, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, float, ua_location_space_vehicle_azimuth_in_radians, UALocationSpaceVehicle*)
+IMPLEMENT_FUNCTION1(location, float, ua_location_space_vehicle_elevation_in_radians, UALocationSpaceVehicle*)
 // URL Dispatcher
 
 IMPLEMENT_CTOR0(url_dispatcher, UAUrlDispatcherSession*, ua_url_dispatcher_session);

=== modified file 'src/ubuntu/hardware/tests/test_gps_api.cpp'
--- src/ubuntu/hardware/tests/test_gps_api.cpp	2014-06-11 12:19:37 +0000
+++ src/ubuntu/hardware/tests/test_gps_api.cpp	2016-04-04 06:59:39 +0000
@@ -67,9 +67,13 @@
     };
 }
 
-void gps_sb_status_cb(UHardwareGpsSvStatus* sv_info, void* context)
+void gps_sb_status_cb(UHardwareGpsSvStatus* status, void* context)
 {
-    printf("gps_sb_status_cb() called, listing %d space vehicles\n", sv_info->num_svs);
+    printf("gps_status_cb() called:\n");
+    u_hardware_gps_sv_status_enumerate_svs(status, [](UHardwareGpsSvInfo* info, void*)
+    {
+        printf("  [%d] snr=%f elevation=%f azimuth=%f flags=%x \n", info->prn, info->snr, info->elevation, info->azimuth, info->flags);
+    }, nullptr);
 }
 
 void gps_nmea_cb(int64_t timestamp, const char* nmea, int length, void* context)

=== modified file 'src/ubuntu/hardware/ubuntu_platform_hardware_api.cpp'
--- src/ubuntu/hardware/ubuntu_platform_hardware_api.cpp	2016-01-26 13:37:51 +0000
+++ src/ubuntu/hardware/ubuntu_platform_hardware_api.cpp	2016-04-04 06:59:39 +0000
@@ -103,6 +103,18 @@
 char*, 
 int);
 
+IMPLEMENT_VOID_FUNCTION3(
+    u_hardware_gps_sv_status_enumerate_svs,
+    UHardwareGpsSvStatus*,
+    UHardwareGpsSvEnumerator,
+    void*);
+
+IMPLEMENT_VOID_FUNCTION3(
+    u_hardware_gps_agps_set_set_id,
+    UHardwareGps,
+    UHardwareGpsAgpsSetIdType,
+    const char*);
+
 IMPLEMENT_OPTIONAL_FUNCTION0(
     UHardwareBooster*,
     u_hardware_booster_new,