GT-3012 changes as decided in 23-July-2014 conference call, step 1: replace TGNSSSpatial with TGNSSPosition and partially remove Extended

8 files changed, 243 insertions, 244 deletions

diff --git a/enhanced-position-service/src/enhanced-position.cpp b/enhanced-position-service/src/enhanced-position.cpp
index 3895909..b440ce7 100644
--- a/enhanced-position-service/src/enhanced-position.cpp
+++ b/enhanced-position-service/src/enhanced-position.cpp
@@ -84,7 +84,7 @@ std::map< uint16_t, ::DBus::Variant > EnhancedPosition::GetData(const std::vecto
 {
   std::map< uint16_t, ::DBus::Variant > Data;
 
-  TGNSSSpatial spatial;
+  TGNSSPosition position;
 
   bool isPosRequested = false;
   bool isCourseRequested = false;
@@ -108,42 +108,42 @@ std::map< uint16_t, ::DBus::Variant > EnhancedPosition::GetData(const std::vecto
 
   if(isPosRequested)
   {
-    if(gnssExtendedGetSpatial(&spatial))
+    if(gnssGetPosition(&position))
     {
-      if (spatial.validityBits & GNSS_SPATIAL_LATITUDE_VALID)
+      if (position.validityBits & GNSS_POSITION_LATITUDE_VALID)
       {
-        Data[POS_LATITUDE] = variant_double(spatial.latitude);
+        Data[POS_LATITUDE] = variant_double(position.latitude);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_LONGITUDE_VALID)
+      if (position.validityBits & GNSS_POSITION_LONGITUDE_VALID)
       {
-        Data[POS_LONGITUDE] = variant_double(spatial.longitude);
+        Data[POS_LONGITUDE] = variant_double(position.longitude);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_ALTITUDEMSL_VALID)
+      if (position.validityBits & GNSS_POSITION_ALTITUDEMSL_VALID)
       {
-        Data[POS_ALTITUDE] = variant_double(spatial.altitudeMSL);
+        Data[POS_ALTITUDE] = variant_double(position.altitudeMSL);
       }
     }
   }
 
   if(isCourseRequested)
   {
-    if(gnssExtendedGetSpatial(&spatial))
+    if(gnssGetPosition(&position))
     {
-      if (spatial.validityBits & GNSS_SPATIAL_HEADING_VALID)
+      if (position.validityBits & GNSS_POSITION_HEADING_VALID)
       {
-        Data[POS_HEADING] = variant_double(spatial.heading);
+        Data[POS_HEADING] = variant_double(position.heading);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_HSPEED_VALID)
+      if (position.validityBits & GNSS_POSITION_HSPEED_VALID)
       {
-        Data[POS_SPEED] = variant_double(spatial.hSpeed);
+        Data[POS_SPEED] = variant_double(position.hSpeed);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_VSPEED_VALID)
+      if (position.validityBits & GNSS_POSITION_VSPEED_VALID)
       {
-        Data[POS_CLIMB] = variant_double(spatial.vSpeed);
+        Data[POS_CLIMB] = variant_double(position.vSpeed);
       }
     }
   }
@@ -154,38 +154,38 @@ std::map< uint16_t, ::DBus::Variant > EnhancedPosition::GetData(const std::vecto
 std::map< uint16_t, ::DBus::Variant > EnhancedPosition::GetPosition()
 {
   std::map< uint16_t, ::DBus::Variant > Position;
-  TGNSSSpatial spatial;
+  TGNSSPosition position;
    
-    if(gnssExtendedGetSpatial(&spatial))
+    if(gnssGetPosition(&position))
     {
-      if (spatial.validityBits & GNSS_SPATIAL_LATITUDE_VALID)
+      if (position.validityBits & GNSS_POSITION_LATITUDE_VALID)
       {
-        Position[POS_LATITUDE] = variant_double(spatial.latitude);
+        Position[POS_LATITUDE] = variant_double(position.latitude);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_LONGITUDE_VALID)
+      if (position.validityBits & GNSS_POSITION_LONGITUDE_VALID)
       {
-        Position[POS_LONGITUDE] = variant_double(spatial.longitude);
+        Position[POS_LONGITUDE] = variant_double(position.longitude);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_ALTITUDEMSL_VALID)
+      if (position.validityBits & GNSS_POSITION_ALTITUDEMSL_VALID)
       {
-        Position[POS_ALTITUDE] = variant_double(spatial.altitudeMSL);
+        Position[POS_ALTITUDE] = variant_double(position.altitudeMSL);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_HEADING_VALID)
+      if (position.validityBits & GNSS_POSITION_HEADING_VALID)
       {
-        Position[POS_HEADING] = variant_double(spatial.heading);
+        Position[POS_HEADING] = variant_double(position.heading);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_HSPEED_VALID)
+      if (position.validityBits & GNSS_POSITION_HSPEED_VALID)
       {
-        Position[POS_SPEED] = variant_double(spatial.hSpeed);
+        Position[POS_SPEED] = variant_double(position.hSpeed);
       }
 
-      if (spatial.validityBits & GNSS_SPATIAL_VSPEED_VALID)
+      if (position.validityBits & GNSS_POSITION_VSPEED_VALID)
       {
-        Position[POS_CLIMB] = variant_double(spatial.vSpeed);
+        Position[POS_CLIMB] = variant_double(position.vSpeed);
       }      
     }
 
@@ -237,7 +237,7 @@ std::map< uint16_t, ::DBus::Variant > EnhancedPosition::GetTime()
   return Time;
 }
 
-void EnhancedPosition::sigPositionUpdate(const TGNSSSpatial spatial[], uint16_t numElements)
+void EnhancedPosition::sigPositionUpdate(const TGNSSPosition position[], uint16_t numElements)
 {
   bool latChanged = false;
   bool lonChanged = false;
@@ -245,10 +245,9 @@ void EnhancedPosition::sigPositionUpdate(const TGNSSSpatial spatial[], uint16_t
   bool speedChanged = false;
   bool headingChanged = false;
   bool climbChanged = false;
-  
-  std::vector< uint16_t > position;
 
-  if (spatial == NULL || numElements < 1)
+
+  if (position == NULL || numElements < 1)
   {
     LOG_ERROR_MSG(gCtx,"sigPositionUpdate failed!");
     return;
@@ -259,38 +258,38 @@ void EnhancedPosition::sigPositionUpdate(const TGNSSSpatial spatial[], uint16_t
     LOG_INFO(gCtx,"Position Update[%d/%d]: lat=%f lon=%f alt=%f",
              i+1,
              numElements,
-             spatial[i].latitude, 
-             spatial[i].longitude,
-             spatial[i].altitudeMSL);
+             position[i].latitude, 
+             position[i].longitude,
+             position[i].altitudeMSL);
         
     if (latChanged == false)
     {
-      latChanged = (spatial[i].validityBits & GNSS_SPATIAL_LATITUDE_VALID);
+      latChanged = (position[i].validityBits & GNSS_POSITION_LATITUDE_VALID);
     }
 
     if (lonChanged == false)
     {
-      lonChanged = (spatial[i].validityBits & GNSS_SPATIAL_LONGITUDE_VALID);
+      lonChanged = (position[i].validityBits & GNSS_POSITION_LONGITUDE_VALID);
     }
 
     if (altChanged == false)
     {
-      altChanged = (spatial[i].validityBits & GNSS_SPATIAL_ALTITUDEMSL_VALID);
+      altChanged = (position[i].validityBits & GNSS_POSITION_ALTITUDEMSL_VALID);
     }
 
     if (speedChanged == false)
     {
-      speedChanged = (spatial[i].validityBits & GNSS_SPATIAL_HSPEED_VALID);
+      speedChanged = (position[i].validityBits & GNSS_POSITION_HSPEED_VALID);
     }
 
     if (headingChanged == false)
     {
-      headingChanged = (spatial[i].validityBits & GNSS_SPATIAL_HEADING_VALID);
+      headingChanged = (position[i].validityBits & GNSS_POSITION_HEADING_VALID);
     }
 
     if (climbChanged == false)
     {
-      climbChanged = (spatial[i].validityBits & GNSS_SPATIAL_VSPEED_VALID);
+      climbChanged = (position[i].validityBits & GNSS_POSITION_VSPEED_VALID);
     }
 
   }
@@ -344,7 +343,7 @@ void EnhancedPosition::sigPositionUpdate(const TGNSSSpatial spatial[], uint16_t
 
 }
 
-void EnhancedPosition::sigAccuracyUpdate(const TGNSSSpatial spatial[], uint16_t numElements)
+void EnhancedPosition::sigAccuracyUpdate(const TGNSSPosition position[], uint16_t numElements)
 { 
   bool pdopChanged = false;
   bool hdopChanged = false;
@@ -352,7 +351,7 @@ void EnhancedPosition::sigAccuracyUpdate(const TGNSSSpatial spatial[], uint16_t
   bool sigmaHPosChanged = false;
   bool sigmaAltitudeChanged = false;
 
-  if (spatial == NULL || numElements < 1)
+  if (position == NULL || numElements < 1)
   {
       LOG_ERROR_MSG(gCtx,"sigAccuracyUpdate failed!");
       return;
@@ -364,35 +363,35 @@ void EnhancedPosition::sigAccuracyUpdate(const TGNSSSpatial spatial[], uint16_t
                sigmaHPosition=%f sigmaAltitude=%f",
                i+1,
                numElements,
-               spatial[i].pdop, 
-               spatial[i].hdop,
-               spatial[i].vdop,
-               spatial[i].sigmaHPosition,
-               spatial[i].sigmaAltitude);
+               position[i].pdop, 
+               position[i].hdop,
+               position[i].vdop,
+               position[i].sigmaHPosition,
+               position[i].sigmaAltitude);
 
     if (pdopChanged == false)
     {
-      pdopChanged = (spatial[i].validityBits & GNSS_SPATIAL_PDOP_VALID);
+      pdopChanged = (position[i].validityBits & GNSS_POSITION_PDOP_VALID);
     }
 
     if (hdopChanged == false)
     {
-      hdopChanged = (spatial[i].validityBits & GNSS_SPATIAL_HDOP_VALID);
+      hdopChanged = (position[i].validityBits & GNSS_POSITION_HDOP_VALID);
     }
 
     if (vdopChanged == false)
     {
-      vdopChanged = (spatial[i].validityBits & GNSS_SPATIAL_VDOP_VALID);
+      vdopChanged = (position[i].validityBits & GNSS_POSITION_VDOP_VALID);
     }
 
     if (sigmaHPosChanged == false)
     {
-      sigmaHPosChanged = (spatial[i].validityBits & GNSS_SPATIAL_SHPOS_VALID);
+      sigmaHPosChanged = (position[i].validityBits & GNSS_POSITION_SHPOS_VALID);
     }
 
     if (sigmaAltitudeChanged == false)
     {
-      sigmaAltitudeChanged = (spatial[i].validityBits & GNSS_SPATIAL_SALT_VALID);
+      sigmaAltitudeChanged = (position[i].validityBits & GNSS_POSITION_SALT_VALID);
     }
   }
 
@@ -441,13 +440,13 @@ void EnhancedPosition::sigAccuracyUpdate(const TGNSSSpatial spatial[], uint16_t
   mpSelf->AccuracyUpdate(changedAccuracyValues);
 }
 
-void EnhancedPosition::sigStatusUpdate(const TGNSSSpatial spatial[], uint16_t numElements)
+void EnhancedPosition::sigStatusUpdate(const TGNSSPosition position[], uint16_t numElements)
 { 
 
   bool fixStatusChanged = false;
   bool fixTypeBitsChanged = false;
 
-  if (spatial == NULL || numElements < 1)
+  if (position == NULL || numElements < 1)
   {
       LOG_ERROR_MSG(gCtx,"sigStatusUpdate failed!");
       return;
@@ -458,17 +457,17 @@ void EnhancedPosition::sigStatusUpdate(const TGNSSSpatial spatial[], uint16_t nu
       LOG_INFO(gCtx,"Status Update[%d/%d]: fixStatus=%d fixTypeBits=0x%08X",
                i+1,
                numElements,
-               spatial[i].fixStatus,
-               spatial[i].fixTypeBits);
+               position[i].fixStatus,
+               position[i].fixTypeBits);
                
     if (fixStatusChanged == false)
     {
-      fixStatusChanged = (spatial[i].validityBits & GNSS_SPATIAL_STAT_VALID);
+      fixStatusChanged = (position[i].validityBits & GNSS_POSITION_STAT_VALID);
     }
 
     if (fixTypeBitsChanged == false)
     {
-      fixTypeBitsChanged = (spatial[i].validityBits & GNSS_SPATIAL_TYPE_VALID);
+      fixTypeBitsChanged = (position[i].validityBits & GNSS_POSITION_TYPE_VALID);
     }
 
   }
@@ -497,7 +496,7 @@ void EnhancedPosition::sigStatusUpdate(const TGNSSSpatial spatial[], uint16_t nu
 
 
 
-void EnhancedPosition::sigSatelliteInfoUpdate(const TGNSSSpatial spatial[], uint16_t numElements)
+void EnhancedPosition::sigSatelliteInfoUpdate(const TGNSSPosition position[], uint16_t numElements)
 { 
   //satellite info
   bool usedSatellitesChanged = false;
@@ -506,7 +505,7 @@ void EnhancedPosition::sigSatelliteInfoUpdate(const TGNSSSpatial spatial[], uint
   
 
   
-  if (spatial == NULL || numElements < 1)
+  if (position == NULL || numElements < 1)
   {
       LOG_ERROR_MSG(gCtx,"sigSatelliteInfoUpdate failed!");
       return;
@@ -517,23 +516,23 @@ void EnhancedPosition::sigSatelliteInfoUpdate(const TGNSSSpatial spatial[], uint
       LOG_INFO(gCtx,"SatelliteInfo Update[%d/%d]: usedSatellites=%d trackedSatellites=%d visibleSatellites=%d",
                i+1,
                numElements,
-               spatial[i].usedSatellites, 
-               spatial[i].trackedSatellites,
-               spatial[i].visibleSatellites);
+               position[i].usedSatellites, 
+               position[i].trackedSatellites,
+               position[i].visibleSatellites);
 
     if (usedSatellitesChanged == false)
     {
-      usedSatellitesChanged = (spatial[i].validityBits & GNSS_SPATIAL_USAT_VALID);
+      usedSatellitesChanged = (position[i].validityBits & GNSS_POSITION_USAT_VALID);
     }
 
     if (trackedSatellitesChanged == false)
     {
-      trackedSatellitesChanged = (spatial[i].validityBits & GNSS_SPATIAL_TSAT_VALID);
+      trackedSatellitesChanged = (position[i].validityBits & GNSS_POSITION_TSAT_VALID);
     }
 
     if (visibleSatellitesChanged == false)
     {
-      visibleSatellitesChanged = (spatial[i].validityBits & GNSS_SPATIAL_VSAT_VALID);
+      visibleSatellitesChanged = (position[i].validityBits & GNSS_POSITION_VSAT_VALID);
     }
 
   }
@@ -573,12 +572,12 @@ void EnhancedPosition::sigSatelliteInfoUpdate(const TGNSSSpatial spatial[], uint
 
 }
 
-void EnhancedPosition::cbSpatial(const TGNSSSpatial spatial[], uint16_t numElements)
+void EnhancedPosition::cbPosition(const TGNSSPosition position[], uint16_t numElements)
 {
-    sigPositionUpdate(spatial, numElements);
-    sigAccuracyUpdate(spatial, numElements);
-    sigStatusUpdate(spatial, numElements);
-    sigSatelliteInfoUpdate(spatial, numElements);
+    sigPositionUpdate(position, numElements);
+    sigAccuracyUpdate(position, numElements);
+    sigStatusUpdate(position, numElements);
+    sigSatelliteInfoUpdate(position, numElements);
 }
 
 
@@ -641,24 +640,24 @@ void EnhancedPosition::run()
     exit(EXIT_FAILURE);
   }
 
-  if(!gnssExtendedInit())
+  if(!gnssInit())
   {
     exit(EXIT_FAILURE);
   }
 
   LOG_INFO_MSG(gCtx,"Starting EnhancedPosition dispatcher...");
 
-  gnssExtendedRegisterSpatialCallback(&cbSpatial);
-  gnssExtendedRegisterSatelliteDetailCallback(&cbSatelliteDetail);
+  gnssRegisterPositionCallback(&cbPosition);
+  gnssRegisterSatelliteDetailCallback(&cbSatelliteDetail);
 }
 
 void EnhancedPosition::shutdown()
 {
   LOG_INFO_MSG(gCtx,"Shutting down EnhancedPosition dispatcher...");
 
-  gnssExtendedDeregisterSpatialCallback(&cbSpatial);
-  gnssExtendedDeregisterSatelliteDetailCallback(&cbSatelliteDetail);
-  gnssExtendedDestroy();
+  gnssDeregisterPositionCallback(&cbPosition);
+  gnssDeregisterSatelliteDetailCallback(&cbSatelliteDetail);
+  gnssDestroy();
   gnssDestroy();
 }
 
diff --git a/enhanced-position-service/src/enhanced-position.h b/enhanced-position-service/src/enhanced-position.h
index ed24641..a9ec84f 100644
--- a/enhanced-position-service/src/enhanced-position.h
+++ b/enhanced-position-service/src/enhanced-position.h
@@ -61,11 +61,11 @@ private:
 
   static void cbSatelliteDetail(const TGNSSSatelliteDetail satelliteDetail[], uint16_t numElements);
 
-  static void cbSpatial(const TGNSSSpatial spatial[], uint16_t numElements);
-  static void sigPositionUpdate(const TGNSSSpatial spatial[], uint16_t numElements);
-  static void sigAccuracyUpdate(const TGNSSSpatial spatial[], uint16_t numElements);
-  static void sigStatusUpdate(const TGNSSSpatial spatial[], uint16_t numElements);  
-  static void sigSatelliteInfoUpdate(const TGNSSSpatial spatial[], uint16_t numElements);
+  static void cbPosition(const TGNSSPosition position[], uint16_t numElements);
+  static void sigPositionUpdate(const TGNSSPosition position[], uint16_t numElements);
+  static void sigAccuracyUpdate(const TGNSSPosition position[], uint16_t numElements);
+  static void sigStatusUpdate(const TGNSSPosition position[], uint16_t numElements);  
+  static void sigSatelliteInfoUpdate(const TGNSSPosition position[], uint16_t numElements);
   
   
   
diff --git a/gnss-service/api/gnss-ext.h b/gnss-service/api/gnss-ext.h
index 500ef1e..ef47d6e 100644
--- a/gnss-service/api/gnss-ext.h
+++ b/gnss-service/api/gnss-ext.h
@@ -183,46 +183,46 @@ typedef struct {
 } TGNSSSatelliteDetail;
 
 /**
- * TGNSSSpatial::validityBits provides information about the currently valid signals 
+ * TGNSSPosition::validityBits provides information about the currently valid signals 
  * of the GNSS position and velocity including status and accuracy data.
- * It is a or'ed bitmask of the EGNSSLocationValidityBits values.
+ * It is a or'ed bitmask of the EGNSSPositionValidityBits values.
  */
 typedef enum {
     //position
-    GNSS_SPATIAL_LATITUDE_VALID        = 0x00000001,    /**< Validity bit for field TGNSSSpatial::latitude. */
-    GNSS_SPATIAL_LONGITUDE_VALID       = 0x00000002,    /**< Validity bit for field TGNSSSpatial::longitude. */
-    GNSS_SPATIAL_ALTITUDEMSL_VALID     = 0x00000004,    /**< Validity bit for field TGNSSSpatial::altitudeMSL. */
-    GNSS_SPATIAL_ALTITUDEELL_VALID     = 0x00000008,    /**< Validity bit for field TGNSSSpatial::altitudeEll. */
+    GNSS_POSITION_LATITUDE_VALID        = 0x00000001,    /**< Validity bit for field TGNSSPosition::latitude. */
+    GNSS_POSITION_LONGITUDE_VALID       = 0x00000002,    /**< Validity bit for field TGNSSPosition::longitude. */
+    GNSS_POSITION_ALTITUDEMSL_VALID     = 0x00000004,    /**< Validity bit for field TGNSSPosition::altitudeMSL. */
+    GNSS_POSITION_ALTITUDEELL_VALID     = 0x00000008,    /**< Validity bit for field TGNSSPosition::altitudeEll. */
     //velocity
-    GNSS_SPATIAL_HSPEED_VALID          = 0x00000010,    /**< Validity bit for field TGNSSSpatial::hSpeed. */
-    GNSS_SPATIAL_VSPEED_VALID          = 0x00000020,    /**< Validity bit for field TGNSSSpatial::vSpeed. */
-    GNSS_SPATIAL_HEADING_VALID         = 0x00000040,    /**< Validity bit for field TGNSSSpatial::heading. */
+    GNSS_POSITION_HSPEED_VALID          = 0x00000010,    /**< Validity bit for field TGNSSPosition::hSpeed. */
+    GNSS_POSITION_VSPEED_VALID          = 0x00000020,    /**< Validity bit for field TGNSSPosition::vSpeed. */
+    GNSS_POSITION_HEADING_VALID         = 0x00000040,    /**< Validity bit for field TGNSSPosition::heading. */
     //quality parameters: satellite constellation
-    GNSS_SPATIAL_PDOP_VALID            = 0x00000080,    /**< Validity bit for field TGNSSSpatial::pdop. */
-    GNSS_SPATIAL_HDOP_VALID            = 0x00000100,    /**< Validity bit for field TGNSSSpatial::hdop. */
-    GNSS_SPATIAL_VDOP_VALID            = 0x00000200,    /**< Validity bit for field TGNSSSpatial::vdop. */
+    GNSS_POSITION_PDOP_VALID            = 0x00000080,    /**< Validity bit for field TGNSSPosition::pdop. */
+    GNSS_POSITION_HDOP_VALID            = 0x00000100,    /**< Validity bit for field TGNSSPosition::hdop. */
+    GNSS_POSITION_VDOP_VALID            = 0x00000200,    /**< Validity bit for field TGNSSPosition::vdop. */
     
-    GNSS_SPATIAL_USAT_VALID            = 0x00000400,    /**< Validity bit for field TGNSSSpatial::usedSatellites. */
-    GNSS_SPATIAL_TSAT_VALID            = 0x00000800,    /**< Validity bit for field TGNSSSpatial::trackedSatellites. */
-    GNSS_SPATIAL_VSAT_VALID            = 0x00001000,    /**< Validity bit for field TGNSSSpatial::visibleSatellites. */
+    GNSS_POSITION_USAT_VALID            = 0x00000400,    /**< Validity bit for field TGNSSPosition::usedSatellites. */
+    GNSS_POSITION_TSAT_VALID            = 0x00000800,    /**< Validity bit for field TGNSSPosition::trackedSatellites. */
+    GNSS_POSITION_VSAT_VALID            = 0x00001000,    /**< Validity bit for field TGNSSPosition::visibleSatellites. */
     //quality parameters: error estimates
-    GNSS_SPATIAL_SHPOS_VALID           = 0x00002000,    /**< Validity bit for field TGNSSSpatial::sigmaHPosition. */
-    GNSS_SPATIAL_SALT_VALID            = 0x00004000,    /**< Validity bit for field TGNSSSpatial::sigmaAltitude. */
-    GNSS_SPATIAL_SHSPEED_VALID         = 0x00008000,    /**< Validity bit for field TGNSSSpatial::sigmaHSpeed. */
-    GNSS_SPATIAL_SVSPEED_VALID         = 0x00010000,    /**< Validity bit for field TGNSSSpatial::sigmaVSpeed. */
-    GNSS_SPATIAL_SHEADING_VALID        = 0x00020000,    /**< Validity bit for field TGNSSSpatial::sigmaHeading. */
+    GNSS_POSITION_SHPOS_VALID           = 0x00002000,    /**< Validity bit for field TGNSSPosition::sigmaHPosition. */
+    GNSS_POSITION_SALT_VALID            = 0x00004000,    /**< Validity bit for field TGNSSPosition::sigmaAltitude. */
+    GNSS_POSITION_SHSPEED_VALID         = 0x00008000,    /**< Validity bit for field TGNSSPosition::sigmaHSpeed. */
+    GNSS_POSITION_SVSPEED_VALID         = 0x00010000,    /**< Validity bit for field TGNSSPosition::sigmaVSpeed. */
+    GNSS_POSITION_SHEADING_VALID        = 0x00020000,    /**< Validity bit for field TGNSSPosition::sigmaHeading. */
     //quality parameters: overall GNSS fix status
-    GNSS_SPATIAL_STAT_VALID            = 0x00040000,    /**< Validity bit for field TGNSSSpatial::fixStatus. */
-    GNSS_SPATIAL_TYPE_VALID            = 0x00080000,    /**< Validity bit for field TGNSSSpatial::fixTypeBits. */    
-} EGNSSSpatialValidityBits;
+    GNSS_POSITION_STAT_VALID            = 0x00040000,    /**< Validity bit for field TGNSSPosition::fixStatus. */
+    GNSS_POSITION_TYPE_VALID            = 0x00080000,    /**< Validity bit for field TGNSSPosition::fixTypeBits. */    
+} EGNSSPositionValidityBits;
 
 /**
- * GNSS spatial data: position and velocity including status and accuracy.
+ * GNSS position data including velocity, status and accuracy.
  * This data structure provides all GNSS information which is typically needed 
  * for positioning applications such as GNSS/Dead Reckoning sensor fusion.
  */
 typedef struct {
-    uint64_t timestamp;             /**< Timestamp of the acquisition of the location data. [ms] */ 
+    uint64_t timestamp;             /**< Timestamp of the acquisition of the GNSS data. [ms] */ 
     //position
     double latitude;                /**< Latitude in WGS84 in degrees. */ 
     double longitude;               /**< Longitude in WGS84 in degrees. */ 
@@ -251,15 +251,15 @@ typedef struct {
                                          [bitwise or'ed @ref EGNSSFixType values]. */
 
     uint32_t validityBits;          /**< Bit mask indicating the validity of each corresponding value.
-                                         [bitwise or'ed @ref EGNSSSpatialValidityBits values].
+                                         [bitwise or'ed @ref EGNSSPositionValidityBits values].
                                          Must be checked before usage. */                                         
-} TGNSSSpatial;
+} TGNSSPosition;
 
 
 
 /**
- * Callback type for extended GNSS UTC date and time.
- * Use this type of callback if you want to register for extended GNSS UTC time data.
+ * Callback type for GNSS UTC date and time.
+ * Use this type of callback if you want to register for GNSS UTC time data.
  * This callback may return buffered data (numElements >1) for different reasons
  *   for (large) portions of data buffered at startup
  *   for data buffered during regular operation e.g. for performance optimization (reduction of callback invocation frequency)
@@ -282,16 +282,16 @@ typedef void (*GNSSTimeCallback)(const TGNSSTime time[], uint16_t numElements);
 typedef void (*GNSSSatelliteDetailCallback)(const TGNSSSatelliteDetail satelliteDetail[], uint16_t numElements);
 
 /**
- * Callback type for GNSS spatial data: position and velocity including status and accuracy
- * Use this type of callback if you want to register for GNSS spatial data.
+ * Callback type for GNSS position data
+ * Use this type of callback if you want to register for GNSS position data.
  * This callback may return buffered data (numElements >1) for different reasons
  *   for (large) portions of data buffered at startup
  *   for data buffered during regular operation e.g. for performance optimization (reduction of callback invocation frequency)
  * If the array contains (numElements >1), the elements will be ordered with rising timestamps 
- * @param time pointer to an array of TGNSSSpatial with size numElements 
+ * @param position pointer to an array of TGNSSPosition with size numElements 
  * @param numElements: allowed range: >=1. If numElements >1, buffered data are provided.  
  */
-typedef void (*GNSSSpatialCallback)(const TGNSSSpatial location[], uint16_t numElements);
+typedef void (*GNSSPositionCallback)(const TGNSSPosition position[], uint16_t numElements);
 
 /**
  * Initialization of the extended GNSS service.
@@ -313,7 +313,7 @@ bool gnssExtendedDestroy();
  * @param data Meta data content about the sensor service.
  * @return True if meta data is available.
  */
-bool gnssExtendedGetMetaData(TGnssMetaData *data);
+bool gnssGetMetaData(TGnssMetaData *data);
 
 /**
  * Accessing static configuration information about the antenna position.
@@ -325,15 +325,15 @@ bool gnssExtendedGetMetaData(TGnssMetaData *data);
  * The reference coordinate system is the car reference system as provided in the documentation.
  * See https://collab.genivi.org/wiki/display/genivi/LBSSensorServiceRequirementsBorg#LBSSensorServiceRequirementsBorg-ReferenceSystem
  */
-bool gnssExtendedGetAntennaPosition(TGNSSDistance3D *distance);
+bool gnssGetAntennaPosition(TGNSSDistance3D *distance);
 
 /**
  * Method to get the UTC date / time data of the GNSS receiver at a specific point in time.
- * The valid flag is updated. The data is only guaranteed to be updated when the valid flag is true.
+ * The valid flags is updated. The data is only guaranteed to be updated when the valid flag is true.
  * @param time After calling the method the current GNSS UTC date / time is written into this parameter.
  * @return Is true if data can be provided and false otherwise, e.g. missing initialization
  */
-bool gnssExtendedGetTime(TGNSSTime *utc);
+bool gnssGetTime(TGNSSTime *utc);
 
 /**
  * Register extended GNSS UTC time callback.
@@ -342,7 +342,7 @@ bool gnssExtendedGetTime(TGNSSTime *utc);
  * @param callback The callback which should be registered.
  * @return True if callback has been registered successfully.
  */
-bool gnssExtendedRegisterTimeCallback(GNSSTimeCallback callback);
+bool gnssRegisterTimeCallback(GNSSTimeCallback callback);
 
 /**
  * Deregister extended GNSS UTC time callback.
@@ -350,7 +350,7 @@ bool gnssExtendedRegisterTimeCallback(GNSSTimeCallback callback);
  * @param callback The callback which should be deregistered.
  * @return True if callback has been deregistered successfully.
  */
-bool gnssExtendedDeregisterTimeCallback(GNSSTimeCallback callback);
+bool gnssDeregisterTimeCallback(GNSSTimeCallback callback);
 
 /**
  * Method to get the GNSS satellite details at a specific point in time.
@@ -360,7 +360,7 @@ bool gnssExtendedDeregisterTimeCallback(GNSSTimeCallback callback);
  * @param numSatelliteDetails Number of elements written to the array *satelliteDetails.
  * @return Is true if data can be provided and false otherwise, e.g. missing initialization
  */
-bool gnssExtendedGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uint16_t count, uint16_t* numSatelliteDetails);
+bool gnssGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uint16_t count, uint16_t* numSatelliteDetails);
 
 /**
  * Register GNSS satellite detail callback.
@@ -369,7 +369,7 @@ bool gnssExtendedGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uin
  * @param callback The callback which should be registered.
  * @return True if callback has been registered successfully.
  */
-bool gnssExtendedRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback);
+bool gnssRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback);
 
 /**
  * Deregister GNSS satellite detail callback.
@@ -377,32 +377,32 @@ bool gnssExtendedRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback cal
  * @param callback The callback which should be deregistered.
  * @return True if callback has been deregistered successfully.
  */
-bool gnssExtendedDeregisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback);
+bool gnssDeregisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback);
 
 /**
- * Method to get the GNSS spatial data (position, velocity, accuracy) at a specific point in time.
+ * Method to get the GNSS position data at a specific point in time.
  * All valid flags are updated. The data is only guaranteed to be updated when the valid flag is true.
- * @param positionVelocityAccuracy After calling the method current GNSS position, velocity, accuracy are written into this parameter.
+ * @param position After calling the method current GNSS position, velocity, accuracy are written into this parameter.
  * @return Is true if data can be provided and false otherwise, e.g. missing initialization
  */
-bool gnssExtendedGetSpatial(TGNSSSpatial* spatial);
+bool gnssGetPosition(TGNSSPosition* position);
 
 /**
- * Register GNSS spatial data (position, velocity, accuracy) callback.
- * The callback will be invoked when new spatial data data is available from the GNSS receiver.
+ * Register GNSS position callback.
+ * The callback will be invoked when new position data data is available from the GNSS receiver.
  * The valid flags is updated. The data is only guaranteed to be updated when the valid flag is true.
  * @param callback The callback which should be registered.
  * @return True if callback has been registered successfully.
  */
-bool gnssExtendedRegisterSpatialCallback(GNSSSpatialCallback callback);
+bool gnssRegisterPositionCallback(GNSSPositionCallback callback);
 
 /**
- * Deregister GNSS spatial data (position, velocity, accuracy) callback.
+ * Deregister GNSS position callback.
  * After calling this method no new data will be delivered to the client.
  * @param callback The callback which should be deregistered.
  * @return True if callback has been deregistered successfully.
  */
-bool gnssExtendedDeregisterSpatialCallback(GNSSSpatialCallback callback);
+bool gnssDeregisterPositionCallback(GNSSPositionCallback callback);
 
 
 /**
@@ -418,10 +418,10 @@ bool gnssExtendedDeregisterSpatialCallback(GNSSSpatialCallback callback);
  *              maximum values are written to this parameter and the return value will be false.
  * @return      True if the precision timing is available and fits in the range which can be represented by the delta parameter.
  */
-bool gnssExtendedGetPrecisionTimingOffset(int32_t *delta);
+bool gnssGetPrecisionTimingOffset(int32_t *delta);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* INCLUDE_GENIVI_SNS_GNSS_EXT */
+#endif /* INCLUDE_GENIVI_GNSS_EXT */
diff --git a/gnss-service/src/globals.h b/gnss-service/src/globals.h
index ee25efe..c3b9afd 100644
--- a/gnss-service/src/globals.h
+++ b/gnss-service/src/globals.h
@@ -31,14 +31,14 @@ extern pthread_mutex_t mutexCb;
 extern pthread_mutex_t mutexData;
 
 extern TGNSSSatelliteDetail gSatelliteDetail; //TODO: buffer full set of satellite details for one point in time
-extern TGNSSSpatial gSpatial;
+extern TGNSSPosition gPosition;
 extern TGNSSTime gTime;
 
 
 extern const TGnssMetaData gMetaData;
 
 extern GNSSSatelliteDetailCallback cbSatelliteDetail;
-extern GNSSSpatialCallback cbSpatial;
+extern GNSSPositionCallback cbPosition;
 extern GNSSTimeCallback cbTime;
 
 #endif /* GLOBALS_H */
diff --git a/gnss-service/src/gnss-ext.c b/gnss-service/src/gnss-ext.c
index b17c1a7..4260f01 100644
--- a/gnss-service/src/gnss-ext.c
+++ b/gnss-service/src/gnss-ext.c
@@ -22,8 +22,8 @@
 TGNSSSatelliteDetail gSatelliteDetail; //TODO: buffer full set of satellite details for one point in time
 GNSSSatelliteDetailCallback cbSatelliteDetail = 0;
 
-TGNSSSpatial gSpatial;
-GNSSSpatialCallback cbSpatial = 0;
+TGNSSPosition gPosition;
+GNSSPositionCallback cbPosition = 0;
 
 TGNSSTime gTime;
 GNSSTimeCallback cbTime = 0;
@@ -39,7 +39,7 @@ bool gnssExtendedDestroy()
 }
 
 
-bool gnssExtendedRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback)
+bool gnssRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback)
 {
     if(cbSatelliteDetail != 0) 
     {
@@ -53,7 +53,7 @@ bool gnssExtendedRegisterSatelliteDetailCallback(GNSSSatelliteDetailCallback cal
     return true;
 }
 
-bool gnssExtendedDeregisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback)
+bool gnssDeregisterSatelliteDetailCallback(GNSSSatelliteDetailCallback callback)
 {
     if(cbSatelliteDetail == callback && callback != 0)
     {
@@ -67,7 +67,7 @@ bool gnssExtendedDeregisterSatelliteDetailCallback(GNSSSatelliteDetailCallback c
     return false;
 }
 
-bool gnssExtendedGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uint16_t count, uint16_t* numSatelliteDetails)
+bool gnssGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uint16_t count, uint16_t* numSatelliteDetails)
 {
     if(!satelliteDetails || !count)
     {
@@ -83,26 +83,26 @@ bool gnssExtendedGetSatelliteDetails(TGNSSSatelliteDetail* satelliteDetails, uin
     return true;
 }
 
-bool gnssExtendedRegisterSpatialCallback(GNSSSpatialCallback callback)
+bool gnssRegisterPositionCallback(GNSSPositionCallback callback)
 {
-    if(cbSpatial != 0) 
+    if(cbPosition != 0) 
     {
         return false; //if already registered
     }
 
     pthread_mutex_lock(&mutexCb);
-    cbSpatial = callback;
+    cbPosition = callback;
     pthread_mutex_unlock(&mutexCb);
 
     return true;
 }
 
-bool gnssExtendedDeregisterSpatialCallback(GNSSSpatialCallback callback)
+bool gnssDeregisterPositionCallback(GNSSPositionCallback callback)
 {
-    if(cbSpatial == callback && callback != 0)
+    if(cbPosition == callback && callback != 0)
     {
         pthread_mutex_lock(&mutexCb);
-        cbSpatial = 0;
+        cbPosition = 0;
         pthread_mutex_unlock(&mutexCb);
 
         return true;
@@ -111,22 +111,22 @@ bool gnssExtendedDeregisterSpatialCallback(GNSSSpatialCallback callback)
     return false;
 }
 
-bool gnssExtendedGetSpatial(TGNSSSpatial* spatial)
+bool gnssGetPosition(TGNSSPosition* position)
 {
-    if(!spatial)
+    if(!position)
     {
         return false;
     }
 
     pthread_mutex_lock(&mutexData);
-    *spatial = gSpatial;
+    *position = gPosition;
     pthread_mutex_unlock(&mutexData);
 
     return true;
 }
 
 
-bool gnssExtendedRegisterTimeCallback(GNSSTimeCallback callback)
+bool gnssRegisterTimeCallback(GNSSTimeCallback callback)
 {
     if(cbTime != 0) 
     {
@@ -140,7 +140,7 @@ bool gnssExtendedRegisterTimeCallback(GNSSTimeCallback callback)
     return true;
 }
 
-bool gnssExtendedDeregisterTimeCallback(GNSSTimeCallback callback)
+bool gnssDeregisterTimeCallback(GNSSTimeCallback callback)
 {
     if(cbTime == callback && callback != 0)
     {
@@ -154,7 +154,7 @@ bool gnssExtendedDeregisterTimeCallback(GNSSTimeCallback callback)
     return false;
 }
 
-bool gnssExtendedGetTime(TGNSSTime* time)
+bool gnssGetTime(TGNSSTime* time)
 {
     if(!time)
     {
diff --git a/gnss-service/src/gnss-use-gpsd.c b/gnss-service/src/gnss-use-gpsd.c
index eee655e..39a6112 100644
--- a/gnss-service/src/gnss-use-gpsd.c
+++ b/gnss-service/src/gnss-use-gpsd.c
@@ -113,7 +113,7 @@ static EGNSSFixStatus convertToFixStatus(int fixMode)
     return status;
 }
 
-bool extractSpatial(struct gps_data_t* pGpsData, TGNSSSpatial* pSpatial)
+bool extractPosition(struct gps_data_t* pGpsData, TGNSSPosition* pPosition)
 {
     static float oldHSpeed = 0;
     static float oldVSpeed = 0;
@@ -127,14 +127,14 @@ bool extractSpatial(struct gps_data_t* pGpsData, TGNSSSpatial* pSpatial)
     bool fixStatusChanged = false;
     bool satellitesChanged = false;
 
-    if(!pGpsData || !pSpatial)
+    if(!pGpsData || !pPosition)
     {
         return false;
     }
 
-    pSpatial->validityBits = 0;
+    pPosition->validityBits = 0;
 
-    pSpatial->timestamp = pGpsData->fix.time;
+    pPosition->timestamp = pGpsData->fix.time;
 
     if( ((pGpsData->set & LATLON_SET) || (pGpsData->set & ALTITUDE_SET)) &&
        (pGpsData->set & MODE_SET) && 
@@ -144,22 +144,22 @@ bool extractSpatial(struct gps_data_t* pGpsData, TGNSSSpatial* pSpatial)
  
        if(pGpsData->set & LATLON_SET)
        {
-           pSpatial->validityBits |= GNSS_SPATIAL_LATITUDE_VALID;
-           pSpatial->latitude = pGpsData->fix.latitude;
+           pPosition->validityBits |= GNSS_POSITION_LATITUDE_VALID;
+           pPosition->latitude = pGpsData->fix.latitude;
 
-           pSpatial->validityBits |= GNSS_SPATIAL_LONGITUDE_VALID;
-           pSpatial->longitude = pGpsData->fix.longitude;
+           pPosition->validityBits |= GNSS_POSITION_LONGITUDE_VALID;
+           pPosition->longitude = pGpsData->fix.longitude;
 
-           LOG_DEBUG(gContext,"Latitude: %lf", pSpatial->latitude);
-           LOG_DEBUG(gContext,"Longitude: %lf", pSpatial->longitude);
+           LOG_DEBUG(gContext,"Latitude: %lf", pPosition->latitude);
+           LOG_DEBUG(gContext,"Longitude: %lf", pPosition->longitude);
        }
 
        if((pGpsData->set & ALTITUDE_SET) && (pGpsData->fix.mode == MODE_3D))
        {
-           pSpatial->validityBits |= GNSS_SPATIAL_ALTITUDEMSL_VALID;
-           pSpatial->altitudeMSL = (float)pGpsData->fix.altitude;
+           pPosition->validityBits |= GNSS_POSITION_ALTITUDEMSL_VALID;
+           pPosition->altitudeMSL = (float)pGpsData->fix.altitude;
 
-           LOG_DEBUG(gContext,"Altitude: %lf", pSpatial->altitudeMSL);
+           LOG_DEBUG(gContext,"Altitude: %lf", pPosition->altitudeMSL);
        }
     }
 
@@ -172,26 +172,26 @@ bool extractSpatial(struct gps_data_t* pGpsData, TGNSSSpatial* pSpatial)
         
         if(pGpsData->set & SPEED_SET)
         {
-            oldHSpeed = pSpatial->hSpeed;
-            pSpatial->hSpeed = (float)pGpsData->fix.speed; 
-            pSpatial->validityBits |= GNSS_SPATIAL_HSPEED_VALID;
-            LOG_DEBUG(gContext,"Speed: %lf", pSpatial->hSpeed);
+            oldHSpeed = pPosition->hSpeed;
+            pPosition->hSpeed = (float)pGpsData->fix.speed; 
+            pPosition->validityBits |= GNSS_POSITION_HSPEED_VALID;
+            LOG_DEBUG(gContext,"Speed: %lf", pPosition->hSpeed);
         }
 
         if(pGpsData->set & CLIMB_SET)
         {
-            oldVSpeed = pSpatial->vSpeed;
-            pSpatial->vSpeed = (float)pGpsData->fix.climb;
-            pSpatial->validityBits |= GNSS_SPATIAL_VSPEED_VALID;
-            LOG_DEBUG(gContext,"Climb: %lf", pSpatial->vSpeed);
+            oldVSpeed = pPosition->vSpeed;
+            pPosition->vSpeed = (float)pGpsData->fix.climb;
+            pPosition->validityBits |= GNSS_POSITION_VSPEED_VALID;
+            LOG_DEBUG(gContext,"Climb: %lf", pPosition->vSpeed);
         }
             		
         if(pGpsData->set & TRACK_SET)
         {
-            oldHeading = pSpatial->heading;
-            pSpatial->heading = (float)pGpsData->fix.track;
-            pSpatial->validityBits |= GNSS_SPATIAL_HEADING_VALID;
-            LOG_DEBUG(gContext,"Heading: %lf", pSpatial->heading);
+            oldHeading = pPosition->heading;
+            pPosition->heading = (float)pGpsData->fix.track;
+            pPosition->validityBits |= GNSS_POSITION_HEADING_VALID;
+            LOG_DEBUG(gContext,"Heading: %lf", pPosition->heading);
         }
     }
 
@@ -204,61 +204,61 @@ bool extractSpatial(struct gps_data_t* pGpsData, TGNSSSpatial* pSpatial)
        (pGpsData->set & DOP_SET) ||
        ((pGpsData->set & SATELLITE_SET) && satellitesChanged))
     {
-        oldFixStatus = pSpatial->fixStatus;
-        pSpatial->fixStatus = convertToFixStatus(pGpsData->fix.mode);
-        pSpatial->validityBits |= GNSS_SPATIAL_STAT_VALID;
-        LOG_DEBUG(gContext,"FixStatus: %d", (int)pSpatial->fixStatus);
+        oldFixStatus = pPosition->fixStatus;
+        pPosition->fixStatus = convertToFixStatus(pGpsData->fix.mode);
+        pPosition->validityBits |= GNSS_POSITION_STAT_VALID;
+        LOG_DEBUG(gContext,"FixStatus: %d", (int)pPosition->fixStatus);
         
         //fixTypeBits: hardcoded
-        pSpatial->fixTypeBits |= GNSS_FIX_TYPE_SINGLE_FREQUENCY;
-        pSpatial->validityBits |= GNSS_SPATIAL_TYPE_VALID;
+        pPosition->fixTypeBits |= GNSS_FIX_TYPE_SINGLE_FREQUENCY;
+        pPosition->validityBits |= GNSS_POSITION_TYPE_VALID;
         
-        pSpatial->pdop = (float)pGpsData->dop.pdop;
-        pSpatial->validityBits |= GNSS_SPATIAL_PDOP_VALID;
-        LOG_DEBUG(gContext,"pdop: %lf", pSpatial->pdop);
+        pPosition->pdop = (float)pGpsData->dop.pdop;
+        pPosition->validityBits |= GNSS_POSITION_PDOP_VALID;
+        LOG_DEBUG(gContext,"pdop: %lf", pPosition->pdop);
 
-        pSpatial->hdop = (float)pGpsData->dop.hdop;
-        pSpatial->validityBits |= GNSS_SPATIAL_HDOP_VALID;
-        LOG_DEBUG(gContext,"hdop: %lf", pSpatial->hdop);
+        pPosition->hdop = (float)pGpsData->dop.hdop;
+        pPosition->validityBits |= GNSS_POSITION_HDOP_VALID;
+        LOG_DEBUG(gContext,"hdop: %lf", pPosition->hdop);
 
-        pSpatial->vdop = (float)pGpsData->dop.vdop;
-        pSpatial->validityBits |= GNSS_SPATIAL_VDOP_VALID;
-        LOG_DEBUG(gContext,"vdop: %lf", pSpatial->vdop);
+        pPosition->vdop = (float)pGpsData->dop.vdop;
+        pPosition->validityBits |= GNSS_POSITION_VDOP_VALID;
+        LOG_DEBUG(gContext,"vdop: %lf", pPosition->vdop);
 
-        pSpatial->sigmaHPosition = (float)pGpsData->fix.epx;
-        pSpatial->validityBits |= GNSS_SPATIAL_SHPOS_VALID;
-        LOG_DEBUG(gContext,"sigmaHorPosition: %lf", pSpatial->sigmaHPosition);
+        pPosition->sigmaHPosition = (float)pGpsData->fix.epx;
+        pPosition->validityBits |= GNSS_POSITION_SHPOS_VALID;
+        LOG_DEBUG(gContext,"sigmaHorPosition: %lf", pPosition->sigmaHPosition);
 
-        pSpatial->sigmaHSpeed = (float)pGpsData->fix.eps;
-        pSpatial->validityBits |= GNSS_SPATIAL_SHSPEED_VALID;
-        LOG_DEBUG(gContext,"sigmaHorSpeed: %lf", pSpatial->sigmaHSpeed);
+        pPosition->sigmaHSpeed = (float)pGpsData->fix.eps;
+        pPosition->validityBits |= GNSS_POSITION_SHSPEED_VALID;
+        LOG_DEBUG(gContext,"sigmaHorSpeed: %lf", pPosition->sigmaHSpeed);
 
-        pSpatial->sigmaHeading = (float)pGpsData->fix.epd;
-        pSpatial->validityBits |= GNSS_SPATIAL_SHEADING_VALID;
-        LOG_DEBUG(gContext,"sigmaHeading: %lf", pSpatial->sigmaHeading);
+        pPosition->sigmaHeading = (float)pGpsData->fix.epd;
+        pPosition->validityBits |= GNSS_POSITION_SHEADING_VALID;
+        LOG_DEBUG(gContext,"sigmaHeading: %lf", pPosition->sigmaHeading);
 
         if(pGpsData->satellites_used >= 0)
         {
-            oldUsedSatellites = pSpatial->usedSatellites;
-            pSpatial->usedSatellites = (uint16_t)pGpsData->satellites_used;      
-            pSpatial->validityBits |= GNSS_SPATIAL_USAT_VALID;
-            LOG_DEBUG(gContext,"Used Satellites: %d", pSpatial->usedSatellites);
+            oldUsedSatellites = pPosition->usedSatellites;
+            pPosition->usedSatellites = (uint16_t)pGpsData->satellites_used;      
+            pPosition->validityBits |= GNSS_POSITION_USAT_VALID;
+            LOG_DEBUG(gContext,"Used Satellites: %d", pPosition->usedSatellites);
         }
         
         if(pGpsData->satellites_visible >= 0)
         {
-            oldVisibleSatellites = pSpatial->visibleSatellites; 
-            pSpatial->visibleSatellites = (uint16_t)pGpsData->satellites_visible;
-            pSpatial->validityBits |= GNSS_SPATIAL_VSAT_VALID;
-            LOG_DEBUG(gContext,"Visible Satellites: %d", pSpatial->visibleSatellites);
+            oldVisibleSatellites = pPosition->visibleSatellites; 
+            pPosition->visibleSatellites = (uint16_t)pGpsData->satellites_visible;
+            pPosition->validityBits |= GNSS_POSITION_VSAT_VALID;
+            LOG_DEBUG(gContext,"Visible Satellites: %d", pPosition->visibleSatellites);
         }
     }
    
     if (positionAvailable || velocityAvailable || fixStatusChanged || satellitesChanged)
     {
-        if(cbSpatial != 0)
+        if(cbPosition != 0)
         {
-            cbSpatial(pSpatial,1);
+            cbPosition(pPosition,1);
         }
     }
     
@@ -352,9 +352,9 @@ void *listen( void *ptr )
                 pthread_mutex_lock(&mutexData);
 
 
-                if(!extractSpatial(&gpsdata,&gSpatial))
+                if(!extractPosition(&gpsdata,&gPosition))
                 {
-                    LOG_ERROR_MSG(gContext,"error extracting spatial data");
+                    LOG_ERROR_MSG(gContext,"error extracting position data");
                 }
 
                 if(!extractTime(&gpsdata,&gTime))
diff --git a/gnss-service/test/compliance-test/gnss-service-compliance-test.c b/gnss-service/test/compliance-test/gnss-service-compliance-test.c
index 6212095..5f9661d 100644
--- a/gnss-service/test/compliance-test/gnss-service-compliance-test.c
+++ b/gnss-service/test/compliance-test/gnss-service-compliance-test.c
@@ -32,18 +32,18 @@ DLT_DECLARE_CONTEXT(gCtx);
 #define TEST_PASSED EXIT_SUCCESS
 
 static int testResult = TEST_PASSED;
-static int cbSpatialSuccess = 0;
+static int cbPositionSuccess = 0;
 
-static void cbSpatial(const TGNSSSpatial spatial[], uint16_t numElements)
+static void cbPosition(const TGNSSPosition position[], uint16_t numElements)
 {
     int i;    
-    if(spatial == NULL || numElements < 1)
+    if(position == NULL || numElements < 1)
     {
-        LOG_ERROR_MSG(gCtx,"cbSpatial failed!");
+        LOG_ERROR_MSG(gCtx,"cbPosition failed!");
         testResult = TEST_FAILED;
         return;
     }
-    cbSpatialSuccess++;
+    cbPositionSuccess++;
     
     
 }
@@ -100,7 +100,7 @@ int main()
     if(init())
     {
         //register for GNSS
-        gnssExtendedRegisterSpatialCallback(&cbSpatial);        
+        gnssRegisterPositionCallback(&cbPosition);        
 
         //listen for events for about 10 seconds
         for(i = 0; i < 10; i++)
@@ -109,7 +109,7 @@ int main()
         }
 
         //deregister
-        gnssExtendedDeregisterSpatialCallback(&cbSpatial);        
+        gnssDeregisterPositionCallback(&cbPosition);        
 
         gnssExtendedDestroy();
         gnssDestroy();
@@ -122,7 +122,7 @@ int main()
          return EXIT_FAILURE;
     }
 
-    LOG_INFO(gCtx,"TEST_PASSED with %d successful callbacks", cbSpatialSuccess);
+    LOG_INFO(gCtx,"TEST_PASSED with %d successful callbacks", cbPositionSuccess);
 
     return EXIT_SUCCESS;
 }
diff --git a/gnss-service/test/gnss-service-client.c b/gnss-service/test/gnss-service-client.c
index eddbf28..67c0b6e 100644
--- a/gnss-service/test/gnss-service-client.c
+++ b/gnss-service/test/gnss-service-client.c
@@ -29,12 +29,12 @@
 DLT_DECLARE_CONTEXT(gCtx);
 
 
-static void cbSpatial(const TGNSSSpatial spatial[], uint16_t numElements)
+static void cbPosition(const TGNSSPosition position[], uint16_t numElements)
 {
     int i;    
-    if(spatial == NULL || numElements < 1)
+    if(position == NULL || numElements < 1)
     {
-        LOG_ERROR_MSG(gCtx,"cbSpatial failed!");
+        LOG_ERROR_MSG(gCtx,"cbPosition failed!");
         return;
     }
 
@@ -43,19 +43,19 @@ static void cbSpatial(const TGNSSSpatial spatial[], uint16_t numElements)
         LOG_INFO(gCtx,"Location Update[%d/%d]: timestamp=%llu latitude=%.5f longitude=%.5f altitudeMSL=%.1f hSpeed=%.1f heading=%.1f\n hdop=%.1f usedSatellites=%d sigmaHPosition=%.1f sigmaHSpeed=%.1f sigmaHeading=%.1f fixStatus=%d fixTypeBits=0x%08X",
                  i+1,
                  numElements,
-                 spatial[i].timestamp, 
-                 spatial[i].latitude,
-                 spatial[i].longitude,
-                 spatial[i].altitudeMSL,
-                 spatial[i].hSpeed,
-                 spatial[i].heading,
-                 spatial[i].hdop,
-                 spatial[i].usedSatellites,
-                 spatial[i].sigmaHPosition,
-                 spatial[i].sigmaHSpeed,
-                 spatial[i].sigmaHeading,
-                 spatial[i].fixStatus,
-                 spatial[i].fixTypeBits);
+                 position[i].timestamp, 
+                 position[i].latitude,
+                 position[i].longitude,
+                 position[i].altitudeMSL,
+                 position[i].hSpeed,
+                 position[i].heading,
+                 position[i].hdop,
+                 position[i].usedSatellites,
+                 position[i].sigmaHPosition,
+                 position[i].sigmaHSpeed,
+                 position[i].sigmaHeading,
+                 position[i].fixStatus,
+                 position[i].fixTypeBits);
     }
 }
 
@@ -126,8 +126,8 @@ int main()
     LOG_INFO_MSG(gCtx,"Starting gnss-service-client...");
 
     // register for GNSS
-    gnssExtendedRegisterSatelliteDetailCallback(&cbSatelliteDetail);
-    gnssExtendedRegisterSpatialCallback(&cbSpatial);
+    gnssRegisterSatelliteDetailCallback(&cbSatelliteDetail);
+    gnssRegisterPositionCallback(&cbPosition);
 
     // enter endless loop
     while(1)
@@ -136,8 +136,8 @@ int main()
     }
 
     // deregister
-    gnssExtendedDeregisterSatelliteDetailCallback(&cbSatelliteDetail);
-    gnssExtendedDeregisterSpatialCallback(&cbSpatial);
+    gnssDeregisterSatelliteDetailCallback(&cbSatelliteDetail);
+    gnssDeregisterPositionCallback(&cbPosition);
 
     gnssExtendedDestroy();
     gnssDestroy();