BOBtheBlinker/android_device_motorola_sm6375-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sm8250-common: import location from LA.UM.9.12.r1-13500.01-SMxx50.QSSI12.0

Browse source 
Change-Id: If93ba9b50dc3bb07a4ba81694187e99f58dd172c
This commit is contained in:
SGCMarkus 2022-03-23 21:42:45 +01:00
parent 72410cf795
commit 64ab05b033
103 changed files with 92521 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

44
location/client_api_testapp/Makefile.am Normal file
View file

@ -0,0 +1,44 @@
AM_CFLAGS = \
-DDEBUG \
-I./ \
$(GPSUTILS_CFLAGS) \
$(LOCUTILS_CFLAGS) \
$(LOCCLIENTAPI_CFLAGS) \
$(LOCINTEGRATIONAPI_CFLAGS) \
-std=c++11
# HALDAEMON is requird only for msg.h
ACLOCAL_AMFLAGS = -I m4
AM_CPPFLAGS = -std=c++11
requiredlibs = \
$(GPSUTILS_LIBS) \
$(LOCCLIENTAPI_LIBS) \
$(LOCINTEGRATIONAPI_LIBS)
h_sources =
c_sources = \
main.cpp
location_client_api_testapp_SOURCES = \
$(c_sources) $(h_sources)
######################
# Build location_client_api_testapp
######################
if USE_GLIB
location_client_api_testapp_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
location_client_api_testapp_LDFLAGS = -lstdc++ -g -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
location_client_api_testapp_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
location_client_api_testapp_CFLAGS = $(AM_CFLAGS)
location_client_api_testapp_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0
location_client_api_testapp_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
location_client_api_testapp_LDADD = $(requiredlibs) -lstdc++ -lc -ldl
bin_PROGRAMS = location_client_api_testapp

88
location/client_api_testapp/configure.ac Normal file
View file

@ -0,0 +1,88 @@
# configure.ac -- Autoconf script for gps location_client_api_testapp
#
# Process this file with autoconf to produce a configure script
# Requires autoconf tool later than 2.61
AC_PREREQ(2.61)
# Initialize the location_client_api_testapp package version 1.0.0
AC_INIT([location_client_api_testapp],1.0.0)
# Does not strictly follow GNU Coding standards
AM_INIT_AUTOMAKE([foreign subdir-objects])
# Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([Makefile.am])
# defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4])
# Checks for programs.
AC_PROG_LIBTOOL
AC_PROG_CXX
AC_PROG_CC
AM_PROG_CC_C_O
AC_PROG_AWK
AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG
# Checks for libraries.
PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
AC_SUBST([GPSUTILS_CFLAGS])
AC_SUBST([GPSUTILS_LIBS])
PKG_CHECK_MODULES([LOCCLIENTAPI], [location-client-api])
AC_SUBST([LOCCLIENTAPI_CFLAGS])
AC_SUBST([LOCCLIENTAPI_LIBS])
PKG_CHECK_MODULES([LOCINTEGRATIONAPI], [location-integration-api])
AC_SUBST([LOCINTEGRATIONAPI_CFLAGS])
AC_SUBST([LOCINTEGRATIONAPI_LIBS])
AC_ARG_WITH([external_ap],
AC_HELP_STRING([--with-external_ap=@<:@dir@:>@],
[Using External Application Processor]),
[],
with_external_ap=no)
if test "x$with_external_ap" != "xno"; then
CPPFLAGS="${CPPFLAGS} -DFEATURE_EXTERNAL_AP"
fi
AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib],
[enable glib, building HLOS systems which use glib]))
if (test "x${with_glib}" = "xyes"); then
AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GThread >= 2.16 is required))
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GLib >= 2.16 is required))
GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
fi
AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_ARG_WITH([core_includes],
AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
[Specify the location of the core headers]),
[core_incdir=$withval],
with_core_includes=no)
if (test "x$with_core_includes" != "xno"); then
CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
fi
AC_CONFIG_FILES([ \
Makefile \
location_client_api_testapp.pc
])
AC_OUTPUT

10
location/client_api_testapp/location_client_api_testapp.pc.in Normal file
View file

@ -0,0 +1,10 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: location_client_api_testapp
Description: location_client_api_tesetapp
Version: @VERSION@
Libs: -L${libdir} -llocation_client_api
Cflags: -I${includedir}

918
location/client_api_testapp/main.cpp Normal file
View file

@ -0,0 +1,918 @@
/* Copyright (c) 2019-2020 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation, nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <string.h>
#include <sstream>
#include <grp.h>
#include <sys/types.h>
#include <sys/prctl.h>
#include <sys/capability.h>
#include <semaphore.h>
#include <loc_pla.h>
#include <loc_cfg.h>
#include <loc_misc_utils.h>
#ifdef NO_UNORDERED_SET_OR_MAP
#include <map>
#else
#include <unordered_map>
#endif
#include <LocationClientApi.h>
#include <LocationIntegrationApi.h>
using namespace location_client;
using namespace location_integration;
static bool outputEnabled = true;
// debug events counter
static uint32_t numLocationCb = 0;
static uint32_t numGnssLocationCb = 0;
static uint32_t numEngLocationCb = 0;
static uint32_t numGnssSvCb = 0;
static uint32_t numGnssNmeaCb = 0;
static uint32_t numDataCb = 0;
static uint32_t numGnssMeasurementsCb = 0;
#define DISABLE_REPORT_OUTPUT "disableReportOutput"
#define ENABLE_REPORT_OUTPUT "enableReportOutput"
#define DISABLE_TUNC "disableTunc"
#define ENABLE_TUNC "enableTunc"
#define DISABLE_PACE "disablePACE"
#define ENABLE_PACE "enablePACE"
#define RESET_SV_CONFIG "resetSVConfig"
#define CONFIG_SV "configSV"
#define CONFIG_SECONDARY_BAND "configSecondaryBand"
#define GET_SECONDARY_BAND_CONFIG "getSecondaryBandConfig"
#define MULTI_CONFIG_SV "multiConfigSV"
#define DELETE_ALL "deleteAll"
#define DELETE_AIDING_DATA "deleteAidingData"
#define CONFIG_LEVER_ARM "configLeverArm"
#define CONFIG_ROBUST_LOCATION "configRobustLocation"
#define GET_ROBUST_LOCATION_CONFIG "getRobustLocationConfig"
#define CONFIG_MIN_GPS_WEEK "configMinGpsWeek"
#define GET_MIN_GPS_WEEK "getMinGpsWeek"
#define CONFIG_DR_ENGINE "configDrEngine"
#define CONFIG_MIN_SV_ELEVATION "configMinSvElevation"
#define GET_MIN_SV_ELEVATION "getMinSvElevation"
#define CONFIG_ENGINE_RUN_STATE "configEngineRunState"
#define SET_USER_CONSENT "setUserConsentForTerrestrialPositioning"
#define GET_SINGLE_GTP_WWAN_FIX "getSingleGtpWwanFix"
// debug utility
static uint64_t getTimestamp() {
struct timespec ts;
clock_gettime(CLOCK_BOOTTIME, &ts);
uint64_t absolute_micro =
((uint64_t)(ts.tv_sec)) * 1000000ULL + ((uint64_t)(ts.tv_nsec)) / 1000ULL;
return absolute_micro;
}
/******************************************************************************
Callback functions
******************************************************************************/
static void onCapabilitiesCb(location_client::LocationCapabilitiesMask mask) {
printf("<<< onCapabilitiesCb mask=0x%" PRIx64 "\n", mask);
printf("<<< onCapabilitiesCb mask string=%s",
LocationClientApi::capabilitiesToString(mask).c_str());
}
static void onResponseCb(location_client::LocationResponse response) {
printf("<<< onResponseCb err=%u\n", response);
}
static void onLocationCb(const location_client::Location& location) {
numLocationCb++;
if (!outputEnabled) {
return;
}
printf("<<< onLocationCb cnt=%u time=%" PRIu64" mask=0x%x lat=%f lon=%f alt=%f\n",
numLocationCb,
location.timestamp,
location.flags,
location.latitude,
location.longitude,
location.altitude);
}
static void onGtpResponseCb(location_client::LocationResponse response) {
printf("<<< onGtpResponseCb err=%u\n", response);
}
static void onGtpLocationCb(const location_client::Location& location) {
numLocationCb++;
if (!outputEnabled) {
return;
}
printf("<<< onGtpLocationCb cnt=%u time=%" PRIu64" mask=0x%x lat=%f lon=%f alt=%f\n",
numLocationCb,
location.timestamp,
location.flags,
location.latitude,
location.longitude,
location.altitude);
}
static void onGnssLocationCb(const location_client::GnssLocation& location) {
numGnssLocationCb++;
if (!outputEnabled) {
return;
}
printf("<<< onGnssLocationCb cnt=%u time=%" PRIu64" mask=0x%x lat=%f lon=%f alt=%f\n",
numGnssLocationCb,
location.timestamp,
location.flags,
location.latitude,
location.longitude,
location.altitude);
}
static void onEngLocationsCb(const std::vector<location_client::GnssLocation>& locations) {
numEngLocationCb++;
if (!outputEnabled) {
return;
}
for (auto gnssLocation : locations) {
printf("<<< onEngLocationsCb: cnt=%u time=%" PRIu64" mask=0x%x lat=%f lon=%f alt=%f\n"
"info mask=0x%" PRIx64 ", nav solution maks = 0x%x, eng type %d, eng mask 0x%x, "
"session status %d",
numEngLocationCb,
gnssLocation.timestamp,
gnssLocation.flags,
gnssLocation.latitude,
gnssLocation.longitude,
gnssLocation.altitude,
gnssLocation.gnssInfoFlags,
gnssLocation.navSolutionMask,
gnssLocation.locOutputEngType,
gnssLocation.locOutputEngMask,
gnssLocation.sessionStatus);
}
}
static void onGnssSvCb(const std::vector<location_client::GnssSv>& gnssSvs) {
numGnssSvCb++;
if (!outputEnabled) {
return;
}
std::stringstream ss;
ss << "<<< onGnssSvCb c=" << numGnssSvCb << " s=" << gnssSvs.size();
for (auto sv : gnssSvs) {
ss << " " << sv.type << ":" << sv.svId << "/" << (uint32_t)sv.cN0Dbhz;
}
printf("%s\n", ss.str().c_str());
}
static void onGnssNmeaCb(uint64_t timestamp, const std::string& nmea) {
numGnssNmeaCb++;
if (!outputEnabled) {
return;
}
printf("<<< onGnssNmeaCb cnt=%u time=%" PRIu64" nmea=%s",
numGnssNmeaCb, timestamp, nmea.c_str());
}
static void onGnssDataCb(const location_client::GnssData& gnssData) {
numDataCb++;
if (!outputEnabled) {
return;
}
printf("<<< gnssDataCb cnt=%u, %s ", numDataCb, gnssData.toString().c_str());
}
static void onGnssMeasurementsCb(const location_client::GnssMeasurements& gnssMeasurements) {
numGnssMeasurementsCb++;
if (!outputEnabled) {
return;
}
printf("<<< onGnssMeasurementsCb cnt=%u, num of meas %d\n", numGnssMeasurementsCb,
gnssMeasurements.measurements.size());
}
static void onConfigResponseCb(location_integration::LocConfigTypeEnum requestType,
location_integration::LocIntegrationResponse response) {
printf("<<< onConfigResponseCb, type %d, err %d\n", requestType, response);
}
static void onGetRobustLocationConfigCb(RobustLocationConfig robustLocationConfig) {
printf("<<< onGetRobustLocationConfigCb, valid flags 0x%x, enabled %d, enabledForE911 %d, "
"version (major %u, minor %u)\n",
robustLocationConfig.validMask, robustLocationConfig.enabled,
robustLocationConfig.enabledForE911, robustLocationConfig.version.major,
robustLocationConfig.version.minor);
}
static void onGetMinGpsWeekCb(uint16_t minGpsWeek) {
printf("<<< onGetMinGpsWeekCb, minGpsWeek %d\n", minGpsWeek);
}
static void onGetMinSvElevationCb(uint8_t minSvElevation) {
printf("<<< onGetMinSvElevationCb, minSvElevationAngleSetting: %d\n", minSvElevation);
}
static void onGetSecondaryBandConfigCb(const ConstellationSet& secondaryBandDisablementSet) {
for (GnssConstellationType disabledSecondaryBand : secondaryBandDisablementSet) {
printf("<<< disabled secondary band for constellation %d\n", disabledSecondaryBand);
}
}
static void printHelp() {
printf("\n************* options *************\n");
printf("e: Concurrent engine report session with 100 ms interval\n");
printf("g: Gnss report session with 100 ms interval\n");
printf("u: Update a session with 2000 ms interval\n");
printf("m: Interleaving fix session with 1000 and 2000 ms interval, change every 3 seconds\n");
printf("s: Stop a session \n");
printf("p: Ping test\n");
printf("q: Quit\n");
printf("r: delete client\n");
printf("%s supress output from various reports: disable output\n", DISABLE_REPORT_OUTPUT);
printf("%s enable output from various reports: disable output\n", ENABLE_REPORT_OUTPUT);
printf("%s tuncThreshold energyBudget: enable tunc\n", ENABLE_TUNC);
printf("%s: disable tunc\n", DISABLE_TUNC);
printf("%s: enable PACE\n", ENABLE_PACE);
printf("%s: disable PACE\n", DISABLE_PACE);
printf("%s: reset sv config to default\n", RESET_SV_CONFIG);
printf("%s: configure sv \n", CONFIG_SV);
printf("%s: configure secondary band\n", CONFIG_SECONDARY_BAND);
printf("%s: get secondary band configure \n", GET_SECONDARY_BAND_CONFIG);
printf("%s: mulitple config SV \n", MULTI_CONFIG_SV);
printf("%s: delete all aiding data\n", DELETE_ALL);
printf("%s: delete ephemeris/calibration data\n", DELETE_AIDING_DATA);
printf("%s: config lever arm\n", CONFIG_LEVER_ARM);
printf("%s: config robust location\n", CONFIG_ROBUST_LOCATION);
printf("%s: get robust location config\n", GET_ROBUST_LOCATION_CONFIG);
printf("%s: set min gps week\n", CONFIG_MIN_GPS_WEEK);
printf("%s: get min gps week\n", GET_MIN_GPS_WEEK);
printf("%s: config DR engine\n", CONFIG_DR_ENGINE);
printf("%s: set min sv elevation angle\n", CONFIG_MIN_SV_ELEVATION);
printf("%s: get min sv elevation angle\n", GET_MIN_SV_ELEVATION);
printf("%s: config engine run state\n", CONFIG_ENGINE_RUN_STATE);
printf("%s: set user consent for terrestrial positioning 0/1\n", SET_USER_CONSENT);
printf("%s: get single shot wwan fix\n", GET_SINGLE_GTP_WWAN_FIX);
}
void setRequiredPermToRunAsLocClient() {
#ifdef USE_GLIB
if (0 == getuid()) {
char groupNames[LOC_MAX_PARAM_NAME] = "diag locclient";
printf("group ids: diag locclient\n");
gid_t groupIds[LOC_PROCESS_MAX_NUM_GROUPS] = {};
char *splitGrpString[LOC_PROCESS_MAX_NUM_GROUPS];
int numGrps = loc_util_split_string(groupNames, splitGrpString,
LOC_PROCESS_MAX_NUM_GROUPS, ' ');
int numGrpIds=0;
for (int i = 0; i < numGrps; i++) {
struct group* grp = getgrnam(splitGrpString[i]);
if (grp) {
groupIds[numGrpIds] = grp->gr_gid;
printf("Group %s = %d\n", splitGrpString[i], groupIds[numGrpIds]);
numGrpIds++;
}
}
if (0 != numGrpIds) {
if (-1 == setgroups(numGrpIds, groupIds)) {
printf("Error: setgroups failed %s", strerror(errno));
}
}
// Set the group id first and then set the effective userid, to locclient.
if (-1 == setgid(GID_LOCCLIENT)) {
printf("Error: setgid failed. %s", strerror(errno));
}
// Set user id to locclient
if (-1 == setuid(UID_LOCCLIENT)) {
printf("Error: setuid failed. %s", strerror(errno));
}
// Set capabilities
struct __user_cap_header_struct cap_hdr = {};
cap_hdr.version = _LINUX_CAPABILITY_VERSION;
cap_hdr.pid = getpid();
if (prctl(PR_SET_KEEPCAPS, 1) < 0) {
printf("Error: prctl failed. %s", strerror(errno));
}
// Set access to CAP_NET_BIND_SERVICE
struct __user_cap_data_struct cap_data = {};
cap_data.permitted = (1 << CAP_NET_BIND_SERVICE);
cap_data.effective = cap_data.permitted;
printf("cap_data.permitted: %d", (int)cap_data.permitted);
if (capset(&cap_hdr, &cap_data)) {
printf("Error: capset failed. %s", strerror(errno));
}
} else {
printf("Test app started as user: %d", getuid());
}
#endif// USE_GLIB
}
void parseSVConfig(char* buf, bool & resetConstellation,
LocConfigBlacklistedSvIdList &svList) {
static char *save = nullptr;
char* token = strtok_r(buf, " ", &save); // skip first one of "configSV"
token = strtok_r(NULL, " ", &save);
if (token == nullptr) {
printf("empty sv blacklist\n");
return;
}
if (strncmp(token, "reset", strlen("reset")) == 0) {
resetConstellation = true;
printf("reset sv constellation\n");
return;
}
while (token != nullptr) {
GnssSvIdInfo svIdInfo = {};
svIdInfo.constellation = (GnssConstellationType) atoi(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
break;
}
svIdInfo.svId = atoi(token);
svList.push_back(svIdInfo);
token = strtok_r(NULL, " ", &save);
}
printf("parse sv config:\n");
for (GnssSvIdInfo it : svList) {
printf("\t\tblacklisted SV: %d, sv id %d\n", (int) it.constellation, it.svId);
}
}
void parseSecondaryBandConfig(char* buf, bool &nullSecondaryBandConfig,
ConstellationSet& secondaryBandDisablementSet) {
static char *save = nullptr;
char* token = strtok_r(buf, " ", &save); // skip first one of "configSeconaryBand"
token = strtok_r(NULL, " ", &save);
if (token == nullptr) {
printf("empty secondary band disablement set\n");
return;
}
if (strncmp(token, "null", strlen("null")) == 0) {
nullSecondaryBandConfig = true;
printf("null secondary band disablement set\n");
return;
}
while (token != nullptr) {
GnssConstellationType secondaryBandDisabled = (GnssConstellationType) atoi(token);
secondaryBandDisablementSet.emplace(secondaryBandDisabled);
token = strtok_r(NULL, " ", &save);
}
printf("\t\tnull SecondaryBandConfig %d\n", nullSecondaryBandConfig);
for (GnssConstellationType disabledSecondaryBand : secondaryBandDisablementSet) {
printf("\t\tdisabled secondary constellation %d\n", disabledSecondaryBand);
}
}
void parseLeverArm (char* buf, LeverArmParamsMap &leverArmMap) {
static char *save = nullptr;
char* token = strtok_r(buf, " ", &save); // skip first one of "configLeverArm"
token = strtok_r(NULL, " ", &save);
while (token != nullptr) {
LeverArmParams leverArm = {};
LeverArmType type = (LeverArmType) 0;
if (strcmp(token, "vrp") == 0) {
type = location_integration::LEVER_ARM_TYPE_GNSS_TO_VRP;
} else if (strcmp(token, "drimu") == 0) {
type = location_integration::LEVER_ARM_TYPE_DR_IMU_TO_GNSS;
} else if (strcmp(token, "veppimu") == 0) {
type = location_integration::LEVER_ARM_TYPE_VEPP_IMU_TO_GNSS;
} else {
break;
}
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
break;
}
leverArm.forwardOffsetMeters = atof(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
break;
}
leverArm.sidewaysOffsetMeters = atof(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
break;
}
leverArm.upOffsetMeters = atof(token);
printf("type %d, %f %f %f\n", type, leverArm.forwardOffsetMeters,
leverArm.sidewaysOffsetMeters, leverArm.upOffsetMeters);
leverArmMap.emplace(type, leverArm);
token = strtok_r(NULL, " ", &save);
}
}
void parseDreConfig (char* buf, DeadReckoningEngineConfig& dreConfig) {
static char *save = nullptr;
char* token = strtok_r(buf, " ", &save); // skip first one of "configDrEngine"
printf("Usage: configDrEngine b2s roll pitch yaw unc speed scaleFactor scaleFactorUnc "
"gyro scaleFactor ScaleFactorUnc\n");
uint32_t validMask = 0;
do {
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing key word b2s, speed, or gyro\n");
break;
}
if (strncmp(token, "b2s", strlen("b2s"))==0) {
token = strtok_r(NULL, " ", &save); // skip the token of "b2s"
if (token == NULL) {
printf("missing roll offset\n");
break;
}
dreConfig.bodyToSensorMountParams.rollOffset = atof(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing pitch offset\n");
break;
}
dreConfig.bodyToSensorMountParams.pitchOffset = atof(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing yaw offset\n");
break;
}
dreConfig.bodyToSensorMountParams.yawOffset = atof(token);
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing offset uncertainty\n");
break;
}
dreConfig.bodyToSensorMountParams.offsetUnc = atof(token);
validMask |= BODY_TO_SENSOR_MOUNT_PARAMS_VALID;
} else if (strncmp(token, "speed", strlen("speed"))==0) {
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing speed scale factor\n");
break;
}
dreConfig.vehicleSpeedScaleFactor = atof(token);
validMask |= VEHICLE_SPEED_SCALE_FACTOR_VALID;
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing speed scale factor uncertainty\n");
break;
}
dreConfig.vehicleSpeedScaleFactorUnc = atof(token);
validMask |= VEHICLE_SPEED_SCALE_FACTOR_UNC_VALID;
} else if (strncmp(token, "gyro", strlen("gyro"))==0) {
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing gyro scale factor\n");
break;
}
dreConfig.gyroScaleFactor = atof(token);
validMask |= GYRO_SCALE_FACTOR_VALID;
token = strtok_r(NULL, " ", &save);
if (token == NULL) {
printf("missing gyro scale factor uncertainty\n");
break;
}
dreConfig.gyroScaleFactorUnc = atof(token);
validMask |= GYRO_SCALE_FACTOR_UNC_VALID;
}
} while (1);
dreConfig.validMask = (DeadReckoningEngineConfigValidMask)validMask;
}
/******************************************************************************
Main function
******************************************************************************/
static void checkForAutoStart(int argc, char *argv[]) {
// check for auto-start option
if (argc >= 2) {
if (strncmp (argv[1], "auto", strlen("auto")) == 0) {
printf("usage: location_clientapi_test_app auto");
uint32_t pid = (uint32_t)getpid();
LocationClientApi* pClient = new LocationClientApi(onCapabilitiesCb);
if (nullptr == pClient) {
printf("can not create Location client API");
exit(1);
}
bool cleanup = false;
if (argc >= 3) {
if (strncmp (argv[2], "clean", strlen("clean")) == 0) {
cleanup = true;
}
}
// wait for capability to come
sleep(1);
EngineReportCbs reportcbs;
reportcbs.engLocationsCallback = EngineLocationsCb(onEngLocationsCb);
reportcbs.gnssSvCallback = GnssSvCb(onGnssSvCb);
reportcbs.gnssNmeaCallback = GnssNmeaCb(onGnssNmeaCb);
LocReqEngineTypeMask reqEngMask = (LocReqEngineTypeMask)
(LOC_REQ_ENGINE_FUSED_BIT|LOC_REQ_ENGINE_SPE_BIT|
LOC_REQ_ENGINE_PPE_BIT);
pClient->startPositionSession(100, reqEngMask, reportcbs, onResponseCb);
// wait for fix report to come
sleep(2);
while (numEngLocationCb < 10) {
sleep(3);
printf("pid %u, recevied %d report\n", pid, numEngLocationCb);
}
printf("pid %u, recevied %d report\n", pid, numEngLocationCb);
if (pClient && cleanup) {
printf("calling stopPosition and delete client \n");
pClient->stopPositionSession();
delete pClient;
sleep(1);
}
exit(0);
}
}
}
int main(int argc, char *argv[]) {
setRequiredPermToRunAsLocClient();
checkForAutoStart(argc, argv);
// create Location client API
LocationClientApi* pClient = new LocationClientApi(onCapabilitiesCb);
if (!pClient) {
printf("failed to create client, return");
return -1;;
}
// callbacks
GnssReportCbs reportcbs;
reportcbs.gnssLocationCallback = GnssLocationCb(onGnssLocationCb);
reportcbs.gnssSvCallback = GnssSvCb(onGnssSvCb);
reportcbs.gnssNmeaCallback = GnssNmeaCb(onGnssNmeaCb);
// callbacks
EngineReportCbs enginecbs;
enginecbs.engLocationsCallback = EngineLocationsCb(onEngLocationsCb);
enginecbs.gnssSvCallback = GnssSvCb(onGnssSvCb);
enginecbs.gnssNmeaCallback = GnssNmeaCb(onGnssNmeaCb);
enginecbs.gnssMeasurementsCallback = GnssMeasurementsCb(onGnssMeasurementsCb);
enginecbs.gnssDataCallback = GnssDataCb(onGnssDataCb);
// create location integratin API
LocIntegrationCbs intCbs;
intCbs.configCb = LocConfigCb(onConfigResponseCb);
intCbs.getRobustLocationConfigCb =
LocConfigGetRobustLocationConfigCb(onGetRobustLocationConfigCb);
intCbs.getMinGpsWeekCb = LocConfigGetMinGpsWeekCb(onGetMinGpsWeekCb);
intCbs.getMinSvElevationCb = LocConfigGetMinSvElevationCb(onGetMinSvElevationCb);
intCbs.getConstellationSecondaryBandConfigCb =
LocConfigGetConstellationSecondaryBandConfigCb(onGetSecondaryBandConfigCb);
LocConfigPriorityMap priorityMap;
location_integration::LocationIntegrationApi* pIntClient =
new LocationIntegrationApi(priorityMap, intCbs);
printHelp();
sleep(1); // wait for capability callback if you don't like sleep
// main loop
while (1) {
char buf[300];
memset (buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), stdin);
printf("execute command %s\n", buf);
if (!pIntClient) {
pIntClient =
new LocationIntegrationApi(priorityMap, intCbs);
if (nullptr == pIntClient) {
printf("failed to create integration client\n");
break;
}
sleep(1); // wait for capability callback if you don't like sleep
}
if (strncmp(buf, ENABLE_REPORT_OUTPUT, strlen(ENABLE_REPORT_OUTPUT)) == 0) {
outputEnabled = true;
} else if (strncmp(buf, DISABLE_REPORT_OUTPUT, strlen(DISABLE_REPORT_OUTPUT)) == 0) {
outputEnabled = false;
} else if (strncmp(buf, DISABLE_TUNC, strlen(DISABLE_TUNC)) == 0) {
pIntClient->configConstrainedTimeUncertainty(false);
} else if (strncmp(buf, ENABLE_TUNC, strlen(ENABLE_TUNC)) == 0) {
// get tuncThreshold and energyBudget from the command line
static char *save = nullptr;
float tuncThreshold = 0.0;
int energyBudget = 0;
char* token = strtok_r(buf, " ", &save); // skip first one
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
tuncThreshold = atof(token);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
energyBudget = atoi(token);
}
}
printf("tuncThreshold %f, energyBudget %d\n", tuncThreshold, energyBudget);
pIntClient->configConstrainedTimeUncertainty(
true, tuncThreshold, energyBudget);
} else if (strncmp(buf, DISABLE_PACE, strlen(DISABLE_TUNC)) == 0) {
pIntClient->configPositionAssistedClockEstimator(false);
} else if (strncmp(buf, ENABLE_PACE, strlen(ENABLE_TUNC)) == 0) {
pIntClient->configPositionAssistedClockEstimator(true);
} else if (strncmp(buf, DELETE_ALL, strlen(DELETE_ALL)) == 0) {
pIntClient->deleteAllAidingData();
} else if (strncmp(buf, DELETE_AIDING_DATA, strlen(DELETE_AIDING_DATA)) == 0) {
uint32_t aidingDataMask = 0;
printf("deleteAidingData 1 (eph) 2 (qdr calibration data) 3 (eph+calibraiton dat)\n");
static char *save = nullptr;
char* token = strtok_r(buf, " ", &save); // skip first one
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
aidingDataMask = atoi(token);
}
pIntClient->deleteAidingData((AidingDataDeletionMask) aidingDataMask);
} else if (strncmp(buf, RESET_SV_CONFIG, strlen(RESET_SV_CONFIG)) == 0) {
pIntClient->configConstellations(nullptr);
} else if (strncmp(buf, CONFIG_SV, strlen(CONFIG_SV)) == 0) {
bool resetConstellation = false;
LocConfigBlacklistedSvIdList svList;
LocConfigBlacklistedSvIdList* svListPtr = &svList;
parseSVConfig(buf, resetConstellation, svList);
if (resetConstellation) {
svListPtr = nullptr;
}
pIntClient->configConstellations(svListPtr);
} else if (strncmp(buf, CONFIG_SECONDARY_BAND, strlen(CONFIG_SECONDARY_BAND)) == 0) {
bool nullSecondaryConfig = false;
ConstellationSet secondaryBandDisablementSet;
ConstellationSet* secondaryBandDisablementSetPtr = &secondaryBandDisablementSet;
parseSecondaryBandConfig(buf, nullSecondaryConfig, secondaryBandDisablementSet);
if (nullSecondaryConfig) {
secondaryBandDisablementSetPtr = nullptr;
printf("setting secondary band config to null\n");
}
pIntClient->configConstellationSecondaryBand(secondaryBandDisablementSetPtr);
} else if (strncmp(buf, GET_SECONDARY_BAND_CONFIG,
strlen(GET_SECONDARY_BAND_CONFIG)) == 0) {
pIntClient->getConstellationSecondaryBandConfig();
} else if (strncmp(buf, MULTI_CONFIG_SV, strlen(MULTI_CONFIG_SV)) == 0) {
// reset
pIntClient->configConstellations(nullptr);
// disable GAL
LocConfigBlacklistedSvIdList galSvList;
GnssSvIdInfo svIdInfo = {};
svIdInfo.constellation = GNSS_CONSTELLATION_TYPE_GALILEO;
svIdInfo.svId = 0;
galSvList.push_back(svIdInfo);
pIntClient->configConstellations(&galSvList);
// disable SBAS
LocConfigBlacklistedSvIdList sbasSvList;
svIdInfo.constellation = GNSS_CONSTELLATION_TYPE_SBAS;
svIdInfo.svId = 0;
sbasSvList.push_back(svIdInfo);
pIntClient->configConstellations(&sbasSvList);
} else if (strncmp(buf, CONFIG_LEVER_ARM, strlen(CONFIG_LEVER_ARM)) == 0) {
LeverArmParamsMap configInfo;
parseLeverArm(buf, configInfo);
pIntClient->configLeverArm(configInfo);
} else if (strncmp(buf, CONFIG_ROBUST_LOCATION, strlen(CONFIG_ROBUST_LOCATION)) == 0) {
// get enable and enableForE911
static char *save = nullptr;
bool enable = false;
bool enableForE911 = false;
// skip first argument of configRobustLocation
char* token = strtok_r(buf, " ", &save);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
enable = (atoi(token) == 1);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
enableForE911 = (atoi(token) == 1);
}
}
printf("enable %d, enableForE911 %d\n", enable, enableForE911);
pIntClient->configRobustLocation(enable, enableForE911);
} else if (strncmp(buf, GET_ROBUST_LOCATION_CONFIG,
strlen(GET_ROBUST_LOCATION_CONFIG)) == 0) {
pIntClient->getRobustLocationConfig();
} else if (strncmp(buf, CONFIG_MIN_GPS_WEEK, strlen(CONFIG_MIN_GPS_WEEK)) == 0) {
static char *save = nullptr;
uint16_t gpsWeekNum = 0;
// skip first argument of configMinGpsWeek
char* token = strtok_r(buf, " ", &save);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
gpsWeekNum = (uint16_t) atoi(token);
}
printf("gps week num %d\n", gpsWeekNum);
pIntClient->configMinGpsWeek(gpsWeekNum);
} else if (strncmp(buf, GET_MIN_GPS_WEEK, strlen(GET_MIN_GPS_WEEK)) == 0) {
pIntClient->getMinGpsWeek();
} else if (strncmp(buf, CONFIG_DR_ENGINE, strlen(CONFIG_DR_ENGINE)) == 0) {
DeadReckoningEngineConfig dreConfig = {};
parseDreConfig(buf, dreConfig);
printf("mask 0x%x, roll %f, speed %f, yaw %f\n", dreConfig.validMask,
dreConfig.bodyToSensorMountParams.rollOffset, dreConfig.vehicleSpeedScaleFactor,
dreConfig.gyroScaleFactor);
pIntClient->configDeadReckoningEngineParams(dreConfig);
} else if (strncmp(buf, CONFIG_MIN_SV_ELEVATION, strlen(CONFIG_MIN_SV_ELEVATION)) == 0) {
static char *save = nullptr;
uint8_t minSvElevation = 0;
// skip first argument of configMinSvElevation
char* token = strtok_r(buf, " ", &save);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
minSvElevation = (uint16_t) atoi(token);
}
printf("min Sv elevation %d\n", minSvElevation);
pIntClient->configMinSvElevation(minSvElevation);
} else if (strncmp(buf, GET_MIN_SV_ELEVATION, strlen(GET_MIN_SV_ELEVATION)) == 0) {
pIntClient->getMinSvElevation();
} else if (strncmp(buf, CONFIG_ENGINE_RUN_STATE, strlen(CONFIG_ENGINE_RUN_STATE)) == 0) {
printf("%s 3(DRE) 1(pause)/2(resume)", CONFIG_ENGINE_RUN_STATE);
static char *save = nullptr;
LocIntegrationEngineType engType = (LocIntegrationEngineType)0;
LocIntegrationEngineRunState engState = (LocIntegrationEngineRunState) 0;
// skip first argument of configEngineRunState
char* token = strtok_r(buf, " ", &save);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
engType = (LocIntegrationEngineType) atoi(token);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
engState = (LocIntegrationEngineRunState) atoi(token);
}
}
printf("eng type %d, eng state %d\n", engType, engState);
bool retVal = pIntClient->configEngineRunState(engType, engState);
printf("configEngineRunState returned %d\n", retVal);
} else if (strncmp(buf, SET_USER_CONSENT, strlen(SET_USER_CONSENT)) == 0) {
static char *save = nullptr;
bool userConsent = false;
char* token = strtok_r(buf, " ", &save);
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
userConsent = (atoi(token) != 0);
}
printf("userConsent %d\n", userConsent);
pIntClient->setUserConsentForTerrestrialPositioning(userConsent);
} else if (strncmp(buf, GET_SINGLE_GTP_WWAN_FIX, strlen(GET_SINGLE_GTP_WWAN_FIX)) == 0) {
static char *save = nullptr;
uint32_t timeoutMsec = 0;
float horQoS = 0.0;
uint32_t techMask = 0x0;
// skip first argument
char* token = strtok_r(buf, " ", &save);
// get timeout
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
timeoutMsec = atoi(token);
}
// get qos
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
horQoS = atof(token);
}
// tech mask
token = strtok_r(NULL, " ", &save);
if (token != NULL) {
techMask = atoi(token);
}
printf("timeout msec %d, horQoS %f, techMask 0x%x\n", timeoutMsec, horQoS, techMask);
if (!pClient) {
pClient = new LocationClientApi(onCapabilitiesCb);
}
pClient->getSingleTerrestrialPosition(timeoutMsec, (TerrestrialTechnologyMask) techMask,
horQoS, onGtpLocationCb, onGtpResponseCb);
} else {
int command = buf[0];
switch(command) {
case 'e':
if (!pClient) {
pClient = new LocationClientApi(onCapabilitiesCb);
}
if (pClient) {
LocReqEngineTypeMask reqEngMask = (LocReqEngineTypeMask)
(LOC_REQ_ENGINE_FUSED_BIT|LOC_REQ_ENGINE_SPE_BIT|
LOC_REQ_ENGINE_PPE_BIT);
pClient->startPositionSession(100, reqEngMask, enginecbs, onResponseCb);
}
break;
case 'g':
if (!pClient) {
pClient = new LocationClientApi(onCapabilitiesCb);
}
if (pClient) {
pClient->startPositionSession(100, reportcbs, onResponseCb);
}
break;
case 'u':
if (!pClient) {
pClient = new LocationClientApi(onCapabilitiesCb);
}
if (pClient) {
pClient->startPositionSession(2000, reportcbs, onResponseCb);
}
break;
case 's':
if (pClient) {
pClient->stopPositionSession();
delete pClient;
pClient = NULL;
}
break;
case 'm':
if (!pClient) {
pClient = new LocationClientApi(onCapabilitiesCb);
}
if (pClient) {
int i = 0;
do {
if (i%2 == 0) {
pClient->startPositionSession(2000, reportcbs, onResponseCb);
} else {
pClient->startPositionSession(1000, reportcbs, onResponseCb);
}
i++;
sleep(3);
} while (1);
}
break;
case 'r':
if (nullptr != pClient) {
delete pClient;
pClient = nullptr;
}
if (nullptr != pIntClient) {
delete pIntClient;
pIntClient = nullptr;
}
break;
case 'q':
goto EXIT;
break;
default:
printf("unknown command %s\n", buf);
break;
}
}
}//while(1)
EXIT:
if (nullptr != pClient) {
delete pClient;
}
if (nullptr != pIntClient) {
delete pIntClient;
}
printf("Done\n");
return 0;
}