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

Merge location.lnx.3.0-180201 to location.lnx.3.9

Browse source 
Catchup merge from tag location.lnx.3.0-18201
CRs-fixed: 2212182
Change-Id: I47f5f9eb06cb6a6ee6be337a2dc43e0d2386113b
This commit is contained in:
Dante Russo 2018-04-03 15:10:07 -07:00
commit ab95d2dc2e
88 changed files with 1128 additions and 1649 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Android.mk
View file

@ -1,5 +1,6 @@
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
LOCAL_PATH := $(call my-dir) LOCAL_PATH := $(call my-dir)
include $(LOCAL_PATH)/build/target_specific_features.mk
include $(call all-makefiles-under,$(LOCAL_PATH)) include $(call all-makefiles-under,$(LOCAL_PATH))
endif endif

2
Makefile.am
View file

@ -3,7 +3,7 @@
ACLOCAL_AMFLAGS = -I m4 ACLOCAL_AMFLAGS = -I m4
SUBDIRS = core location gnss SUBDIRS = gnss
pkgconfigdir = $(libdir)/pkgconfig pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-hal.pc pkgconfig_DATA = loc-hal.pc

1
android/Android.mk
View file

@ -43,7 +43,6 @@ LOCAL_SHARED_LIBRARIES += \
libloc_core \ libloc_core \
libgps.utils \ libgps.utils \
libdl \ libdl \
libloc_pla \
liblocation_api \ liblocation_api \
LOCAL_CFLAGS += $(GNSS_CFLAGS) LOCAL_CFLAGS += $(GNSS_CFLAGS)

17
build/target_specific_features.mk Normal file
View file

@ -0,0 +1,17 @@
GNSS_CFLAGS := \
-Werror \
-Wno-error=unused-parameter \
-Wno-error=format \
-Wno-error=macro-redefined \
-Wno-error=reorder \
-Wno-error=missing-braces \
-Wno-error=self-assign \
-Wno-error=enum-conversion \
-Wno-error=logical-op-parentheses \
-Wno-error=null-arithmetic \
-Wno-error=null-conversion \
-Wno-error=parentheses-equality \
-Wno-error=undefined-bool-conversion \
-Wno-error=tautological-compare \
-Wno-error=switch \
-Wno-error=date-time

34
configure.ac
View file

@ -11,7 +11,7 @@ AM_INIT_AUTOMAKE([foreign])
# Disables auto rebuilding of configure, Makefile.ins # Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path # Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([utils/loc_cfg.cpp]) AC_CONFIG_SRCDIR([Makefile.am])
# defines some macros variable to be included by source # defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h]) AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_MACRO_DIR([m4])
@ -29,26 +29,14 @@ AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG PKG_PROG_PKG_CONFIG
# Checks for libraries. # Checks for libraries.
PKG_CHECK_MODULES([QMI], [qmi])
AC_SUBST([QMI_CFLAGS])
AC_SUBST([QMI_LIBS])
PKG_CHECK_MODULES([QMIF], [qmi-framework])
AC_SUBST([QMIF_CFLAGS])
AC_SUBST([QMIF_LIBS])
PKG_CHECK_MODULES([DATA], [data])
AC_SUBST([DATA_CFLAGS])
AC_SUBST([DATA_LIBS])
PKG_CHECK_MODULES([LOCPLA], [loc-pla])
AC_SUBST([LOCPLA_CFLAGS])
AC_SUBST([LOCPLA_LIBS])
PKG_CHECK_MODULES([GPSUTILS], [gps-utils]) PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
AC_SUBST([GPSUTILS_CFLAGS]) AC_SUBST([GPSUTILS_CFLAGS])
AC_SUBST([GPSUTILS_LIBS]) AC_SUBST([GPSUTILS_LIBS])
PKG_CHECK_MODULES([LOCCORE], [loc-core])
AC_SUBST([LOCCORE_CFLAGS])
AC_SUBST([LOCCORE_LIBS])
AC_ARG_WITH([core_includes], AC_ARG_WITH([core_includes],
AC_HELP_STRING([--with-core-includes=@<:@dir@:>@], AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
[Specify the location of the core headers]), [Specify the location of the core headers]),
@ -59,6 +47,16 @@ if test "x$with_core_includes" != "xno"; then
CPPFLAGS="${CPPFLAGS} -I${core_incdir}" CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
fi fi
AC_ARG_WITH([locpla_includes],
AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
[specify the path to locpla-includes in loc-pla_git.bb]),
[locpla_incdir=$withval],
with_locpla_includes=no)
if test "x$with_locpla_includes" != "xno"; then
AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
fi
AC_SUBST([CPPFLAGS]) AC_SUBST([CPPFLAGS])
AC_ARG_WITH([glib], AC_ARG_WITH([glib],
@ -82,8 +80,6 @@ AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_CONFIG_FILES([ \ AC_CONFIG_FILES([ \
Makefile \ Makefile \
core/Makefile \
location/Makefile \
gnss/Makefile \ gnss/Makefile \
loc-hal.pc \ loc-hal.pc \
]) ])

3
core/Android.mk
View file

@ -22,8 +22,7 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \ libcutils \
libgps.utils \ libgps.utils \
libdl \ libdl \
liblog \ liblog
libloc_pla
LOCAL_SRC_FILES += \ LOCAL_SRC_FILES += \
LocApiBase.cpp \ LocApiBase.cpp \

2
core/ContextBase.cpp
View file

@ -35,7 +35,7 @@
#include <ContextBase.h> #include <ContextBase.h>
#include <msg_q.h> #include <msg_q.h>
#include <loc_target.h> #include <loc_target.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
#include <loc_log.h> #include <loc_log.h>
namespace loc_core { namespace loc_core {

2
core/LocAdapterBase.cpp
View file

@ -32,7 +32,7 @@
#include <dlfcn.h> #include <dlfcn.h>
#include <LocAdapterBase.h> #include <LocAdapterBase.h>
#include <loc_target.h> #include <loc_target.h>
#include <platform_lib_log_util.h> #include <log_util.h>
#include <LocAdapterProxyBase.h> #include <LocAdapterProxyBase.h>
namespace loc_core { namespace loc_core {

2
core/LocApiBase.cpp
View file

@ -33,7 +33,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <LocApiBase.h> #include <LocApiBase.h>
#include <LocAdapterBase.h> #include <LocAdapterBase.h>
#include <platform_lib_log_util.h> #include <log_util.h>
#include <LocDualContext.h> #include <LocDualContext.h>
namespace loc_core { namespace loc_core {

2
core/LocApiBase.h
View file

@ -34,7 +34,7 @@
#include <gps_extended.h> #include <gps_extended.h>
#include <LocationAPI.h> #include <LocationAPI.h>
#include <MsgTask.h> #include <MsgTask.h>
#include <platform_lib_log_util.h> #include <log_util.h>
namespace loc_core { namespace loc_core {
class ContextBase; class ContextBase;

2
core/LocDualContext.cpp
View file

@ -33,7 +33,7 @@
#include <unistd.h> #include <unistd.h>
#include <LocDualContext.h> #include <LocDualContext.h>
#include <msg_q.h> #include <msg_q.h>
#include <platform_lib_log_util.h> #include <log_util.h>
#include <loc_log.h> #include <loc_log.h>
namespace loc_core { namespace loc_core {

19
core/Makefile.am
View file

@ -1,12 +1,11 @@
ACLOCAL_AMFLAGS = -I m4
AM_CFLAGS = -I./ \ AM_CFLAGS = -I./ \
-I../utils \
-I../gnss \
-I../location \
-I./data-items \
-I./data-items/common \
-I./observer \
$(LOCPLA_CFLAGS) \ $(LOCPLA_CFLAGS) \
$(GPSUTILS_CFLAGS) \ $(GPSUTILS_CFLAGS) \
-I./data-items/ \
-I./data-items/common \
-I./observer \
-I$(WORKSPACE)/gps-noship/flp \ -I$(WORKSPACE)/gps-noship/flp \
-D__func__=__PRETTY_FUNCTION__ \ -D__func__=__PRETTY_FUNCTION__ \
-fno-short-enums \ -fno-short-enums \
@ -44,7 +43,7 @@ libloc_core_la_c_sources = \
SystemStatusOsObserver.cpp \ SystemStatusOsObserver.cpp \
SystemStatus.cpp SystemStatus.cpp
library_includedir = $(pkgincludedir)/core library_includedir = $(pkgincludedir)
library_include_HEADERS = $(libloc_core_la_h_sources) library_include_HEADERS = $(libloc_core_la_h_sources)
@ -60,7 +59,11 @@ libloc_core_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_core_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) libloc_core_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif endif
libloc_core_la_LIBADD = -lstdc++ -ldl $(LOCPLA_LIBS) $(GPSUTILS_LIBS) libloc_core_la_LIBADD = -ldl $(GPSUTILS_LIBS)
#Create and Install libraries #Create and Install libraries
lib_LTLIBRARIES = libloc_core.la lib_LTLIBRARIES = libloc_core.la
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-core.pc
EXTRA_DIST = $(pkgconfig_DATA)

4
core/SystemStatus.cpp
View file

@ -34,8 +34,8 @@
#include <string.h> #include <string.h>
#include <sys/time.h> #include <sys/time.h>
#include <pthread.h> #include <pthread.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <MsgTask.h> #include <log_util.h>
#include <loc_nmea.h> #include <loc_nmea.h>
#include <DataItemsFactoryProxy.h> #include <DataItemsFactoryProxy.h>
#include <SystemStatus.h> #include <SystemStatus.h>

5
core/SystemStatus.h
View file

@ -30,9 +30,10 @@
#define __SYSTEM_STATUS__ #define __SYSTEM_STATUS__
#include <stdint.h> #include <stdint.h>
#include <string> #include <sys/time.h>
#include <vector> #include <vector>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
#include <MsgTask.h> #include <MsgTask.h>
#include <IDataItemCore.h> #include <IDataItemCore.h>
#include <IOsObserver.h> #include <IOsObserver.h>

3
core/SystemStatusOsObserver.h
View file

@ -39,7 +39,8 @@
#include <MsgTask.h> #include <MsgTask.h>
#include <DataItemId.h> #include <DataItemId.h>
#include <IOsObserver.h> #include <IOsObserver.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
namespace loc_core namespace loc_core
{ {

41
utils/platform_lib_abstractions/loc_stub/configure.ac → core/configure.ac
View file

@ -1,17 +1,17 @@
# configure.ac -- Autoconf script for gps loc-stub # configure.ac -- Autoconf script for gps loc-core
# #
# Process this file with autoconf to produce a configure script # Process this file with autoconf to produce a configure script
# Requires autoconf tool later than 2.61 # Requires autoconf tool later than 2.61
AC_PREREQ(2.61) AC_PREREQ(2.61)
# Initialize the gps loc-stub package version 1.0.0 # Initialize the gps loc-hal package version 1.0.0
AC_INIT([loc-stub],1.0.0) AC_INIT([loc-core],1.0.0)
# Does not strictly follow GNU Coding standards # Does not strictly follow GNU Coding standards
AM_INIT_AUTOMAKE([foreign]) AM_INIT_AUTOMAKE([foreign])
# Disables auto rebuilding of configure, Makefile.ins # Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path # Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([Makefile.am]) AC_CONFIG_SRCDIR([loc-core.pc.in])
# defines some macros variable to be included by source # defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h]) AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_MACRO_DIR([m4])
@ -29,16 +29,32 @@ AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG PKG_PROG_PKG_CONFIG
# Checks for libraries. # Checks for libraries.
AC_ARG_WITH([hardware_include], PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
AC_HELP_STRING([--with-hardware-include=@<:@dir@:>@], AC_SUBST([GPSUTILS_CFLAGS])
[Specify the location of the hardware headers]), AC_SUBST([GPSUTILS_LIBS])
[hardware_incdir=$withval],
with_hardware_include=no)
if test "x$with_hardware_include" != "xno"; then AC_ARG_WITH([core_includes],
CPPFLAGS="${CPPFLAGS} -I${hardware_incdir}" 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 fi
AC_ARG_WITH([locpla_includes],
AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
[specify the path to locpla-includes in loc-pla_git.bb]),
[locpla_incdir=$withval],
with_locpla_includes=no)
if test "x$with_locpla_includes" != "xno"; then
AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
fi
AC_SUBST([CPPFLAGS])
AC_ARG_WITH([glib], AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib], AC_HELP_STRING([--with-glib],
[enable glib, building HLOS systems which use glib])) [enable glib, building HLOS systems which use glib]))
@ -60,8 +76,7 @@ AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_CONFIG_FILES([ \ AC_CONFIG_FILES([ \
Makefile \ Makefile \
src/Makefile \ loc-core.pc \
loc-stub.pc
]) ])
AC_OUTPUT AC_OUTPUT

3
core/data-items/DataItemsFactoryProxy.cpp
View file

@ -32,7 +32,8 @@
#include <DataItemId.h> #include <DataItemId.h>
#include <IDataItemCore.h> #include <IDataItemCore.h>
#include <DataItemsFactoryProxy.h> #include <DataItemsFactoryProxy.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
namespace loc_core namespace loc_core
{ {

3
core/data-items/common/ClientIndex.cpp
View file

@ -29,7 +29,8 @@
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
#include <string> #include <string>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
#include <ClientIndex.h> #include <ClientIndex.h>
#include <IDataItemObserver.h> #include <IDataItemObserver.h>
#include <DataItemId.h> #include <DataItemId.h>

3
core/data-items/common/DataItemIndex.cpp
View file

@ -31,7 +31,8 @@
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
#include <DataItemIndex.h> #include <DataItemIndex.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
#include <IDataItemObserver.h> #include <IDataItemObserver.h>
#include <DataItemId.h> #include <DataItemId.h>

10
core/loc-core.pc.in Normal file
View file

@ -0,0 +1,10 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: loc-core
Description: QTI GPS Loc Core
Version: @VERSION@
Libs: -L${libdir} -lloc_core
Cflags: -I${includedir}/loc-core

3
core/loc_core_log.cpp
View file

@ -30,9 +30,10 @@
#define LOG_NDEBUG 0 #define LOG_NDEBUG 0
#define LOG_TAG "LocSvc_core_log" #define LOG_TAG "LocSvc_core_log"
#include <log_util.h>
#include <loc_log.h> #include <loc_log.h>
#include <loc_core_log.h> #include <loc_core_log.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
void LocPosMode::logv() const void LocPosMode::logv() const
{ {

2
gnss/Agps.cpp
View file

@ -30,7 +30,7 @@
#define LOG_TAG "LocSvc_Agps" #define LOG_TAG "LocSvc_Agps"
#include <Agps.h> #include <Agps.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
#include <ContextBase.h> #include <ContextBase.h>
#include <loc_timer.h> #include <loc_timer.h>

3
gnss/Agps.h
View file

@ -34,7 +34,8 @@
#include <list> #include <list>
#include <MsgTask.h> #include <MsgTask.h>
#include <gps_extended_c.h> #include <gps_extended_c.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
/* ATL callback function pointers /* ATL callback function pointers
* Passed in by Adapter to AgpsManager */ * Passed in by Adapter to AgpsManager */

3
gnss/GnssAdapter.cpp
View file

@ -75,7 +75,7 @@ GnssAdapter::GnssAdapter() :
mAgpsManager(), mAgpsManager(),
mAgpsCbInfo(), mAgpsCbInfo(),
mSystemStatus(SystemStatus::getInstance(mMsgTask)), mSystemStatus(SystemStatus::getInstance(mMsgTask)),
mServerUrl(""), mServerUrl(":"),
mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask) mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask)
{ {
LOC_LOGD("%s]: Constructor %p", __func__, this); LOC_LOGD("%s]: Constructor %p", __func__, this);
@ -600,7 +600,6 @@ GnssAdapter::setSuplHostServer(const char* server, int port)
(strncasecmp(noHost, server, sizeof(noHost)) == 0)) { (strncasecmp(noHost, server, sizeof(noHost)) == 0)) {
serverUrl[0] = '\0'; serverUrl[0] = '\0';
length = 0; length = 0;
mServerUrl.clear();
} else if (port > 0) { } else if (port > 0) {
length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", server, port); length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", server, port);
} }

85
gnss/Makefile.am
View file

@ -1,11 +1,11 @@
AM_CFLAGS = \ AM_CFLAGS = \
$(LOCPLA_CFLAGS) \ $(LOCPLA_CFLAGS) \
$(LOCHAL_CFLAGS) \ $(LOCHAL_CFLAGS) \
$(GPSUTILS_CFLAGS) \
$(LOCCORE_CFLAGS) \
-I./ \ -I./ \
-I../utils \ -I../utils \
-I../core \ -I$(WORKSPACE)/hardware/qcom/gps/core/data-items \
-I../core/data-items \
-I../core/observer \
-I../location \ -I../location \
-std=c++11 -std=c++11
@ -17,86 +17,15 @@ libgnss_la_SOURCES = \
if USE_GLIB if USE_GLIB
libgnss_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ libgnss_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libgnss_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -avoid-version libgnss_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -avoid-version
libgnss_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ libgnss_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else else
libgnss_la_CFLAGS = $(AM_CFLAGS) libgnss_la_CFLAGS = $(AM_CFLAGS)
libgnss_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 libgnss_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libgnss_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) libgnss_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif endif
libgnss_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(LOCHAL_LIBS) libgnss_la_LIBADD = -lstdc++ $(GPSUTILS_LIBS) $(LOCCORE_LIBS)
#Create and Install libraries #Create and Install libraries
#lib_LTLIBRARIES = libgnss.la lib_LTLIBRARIES = libgnss.la
#library_includedir = $(pkgincludedir)
#pkgconfigdir = $(libdir)/pkgconfig
#pkgconfig_DATA = location-api.pc
#EXTRA_DIST = $(pkgconfig_DATA)
libloc_ds_api_CFLAGS = \
$(QMIF_CFLAGS) \
$(QMI_CFLAGS) \
$(DATA_CFLAGS) \
$(GPSUTILS_CFLAGS) \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api
libloc_ds_api_la_SOURCES = \
$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c
if USE_GLIB
libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@
libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS)
libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0
libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS)
endif
libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(GPSUTILS_LIBS) $(LOCPLA_LIBS)
libloc_api_v02_CFLAGS = \
$(QMIF_CFLAGS) \
$(GPSUTILS_CFLAGS) \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02
libloc_api_v02_la_SOURCES = \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c
if USE_GLIB
libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@
libloc_api_v02_la_LDFLAGS = -lstdc++ -g -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS)
libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS)
endif
libloc_api_v02_la_CXXFLAGS = -std=c++0x
libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(GPSUTILS_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la libloc_ds_api.la
library_include_HEADERS = \
$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h
library_includedir = $(pkgincludedir)
#Create and Install libraries
lib_LTLIBRARIES = libgnss.la libloc_ds_api.la libloc_api_v02.la

4
loc-hal.pc.in
View file

@ -6,5 +6,5 @@ includedir=@includedir@
Name: loc-hal Name: loc-hal
Description: QTI GPS Loc HAL Description: QTI GPS Loc HAL
Version: @VERSION Version: @VERSION
Libs: -L${libdir} -lloc_core -llocation_api -lgnss -lloc_ds_api -lloc_api_v02 Libs: -L${libdir} -lgnss
Cflags: -I${includedir} -I${includedir}/loc-hal -I${includedir}/loc-hal/location -I${includedir}/loc-hal/gnss -I${includedir}/loc-hal/core Cflags: -I${includedir} -I${includedir}/utils -I${includedir}/core -I${includedir}/loc-hal

3
location/Android.mk
View file

@ -15,8 +15,7 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \ libcutils \
libgps.utils \ libgps.utils \
libdl \ libdl \
liblog \ liblog
libloc_pla
LOCAL_SRC_FILES += \ LOCAL_SRC_FILES += \
LocationAPI.cpp \ LocationAPI.cpp \

3
location/LocationAPI.cpp
View file

@ -29,7 +29,8 @@
#include <location_interface.h> #include <location_interface.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
#include <pthread.h> #include <pthread.h>
#include <map> #include <map>

4
location/LocationAPIClientBase.cpp
View file

@ -29,8 +29,8 @@
#define LOG_NDDEBUG 0 #define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_APIClientBase" #define LOG_TAG "LocSvc_APIClientBase"
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <platform_lib_macros.h> #include <log_util.h>
#include <inttypes.h> #include <inttypes.h>
#include <loc_cfg.h> #include <loc_cfg.h>
#include "LocationAPIClientBase.h" #include "LocationAPIClientBase.h"

3
location/LocationAPIClientBase.h
View file

@ -36,7 +36,8 @@
#include <map> #include <map>
#include "LocationAPI.h" #include "LocationAPI.h"
#include "platform_lib_log_util.h" #include <loc_pla.h>
#include <log_util.h>
enum SESSION_MODE { enum SESSION_MODE {
SESSION_MODE_NONE = 0, SESSION_MODE_NONE = 0,

22
location/Makefile.am
View file

@ -1,9 +1,10 @@
ACLOCAL_AMFLAGS = -I m4
AM_CFLAGS = \ AM_CFLAGS = \
$(LOCPLA_CFLAGS) \
$(GPSUTILS_CFLAGS) \
$(LOCHAL_CFLAGS) \
-I./ \ -I./ \
-I../utils \ -I../utils \
$(LOCPLA_CFLAGS) \
$(GPSUTILS_CFLAGS) \
-std=c++11 -std=c++11
liblocation_api_la_SOURCES = \ liblocation_api_la_SOURCES = \
@ -12,15 +13,15 @@ liblocation_api_la_SOURCES = \
if USE_GLIB if USE_GLIB
liblocation_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ liblocation_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
liblocation_api_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 liblocation_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
liblocation_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ liblocation_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else else
liblocation_api_la_CFLAGS = $(AM_CFLAGS) liblocation_api_la_CFLAGS = $(AM_CFLAGS)
liblocation_api_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 liblocation_api_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
liblocation_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) liblocation_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif endif
liblocation_api_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(GPSUTILS_LIBS) $(LOCHAL_LIBS) liblocation_api_la_LIBADD = -lstdc++ -ldl $(GPSUTILS_LIBS)
library_include_HEADERS = \ library_include_HEADERS = \
LocationAPI.h \ LocationAPI.h \
@ -31,10 +32,7 @@ library_include_HEADERS = \
lib_LTLIBRARIES = liblocation_api.la lib_LTLIBRARIES = liblocation_api.la
library_includedir = $(pkgincludedir) library_includedir = $(pkgincludedir)
#pkgconfigdir = $(libdir)/pkgconfig
#pkgconfig_DATA = location-api.pc
#EXTRA_DIST = $(pkgconfig_DATA)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = location-api.pc
EXTRA_DIST = $(pkgconfig_DATA)

39
utils/platform_lib_abstractions/loc_pla/configure.ac → location/configure.ac
View file

@ -1,17 +1,17 @@
# configure.ac -- Autoconf script for gps loc-pla # configure.ac -- Autoconf script for gps location-api-iface
# #
# Process this file with autoconf to produce a configure script # Process this file with autoconf to produce a configure script
# Requires autoconf tool later than 2.61 # Requires autoconf tool later than 2.61
AC_PREREQ(2.61) AC_PREREQ(2.61)
# Initialize the gps loc-pla package version 1.0.0 # Initialize the gps location-api-iface package version 1.0.0
AC_INIT([loc-pla],1.0.0) AC_INIT([location-api-iface],1.0.0)
# Does not strictly follow GNU Coding standards # Does not strictly follow GNU Coding standards
AM_INIT_AUTOMAKE([foreign]) AM_INIT_AUTOMAKE([foreign])
# Disables auto rebuilding of configure, Makefile.ins # Disables auto rebuilding of configure, Makefile.ins
AM_MAINTAINER_MODE AM_MAINTAINER_MODE
# Verifies the --srcdir is correct by checking for the path # Verifies the --srcdir is correct by checking for the path
AC_CONFIG_SRCDIR([include/platform_lib_includes.h]) AC_CONFIG_SRCDIR([location-api.pc.in])
# defines some macros variable to be included by source # defines some macros variable to be included by source
AC_CONFIG_HEADERS([config.h]) AC_CONFIG_HEADERS([config.h])
AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_MACRO_DIR([m4])
@ -29,9 +29,31 @@ AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG PKG_PROG_PKG_CONFIG
# Checks for libraries. # Checks for libraries.
PKG_CHECK_MODULES([LOCSTUB], [loc-stub]) PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
AC_SUBST([LOCSTUB_CFLAGS]) AC_SUBST([GPSUTILS_CFLAGS])
AC_SUBST([LOCSTUB_LIBS]) AC_SUBST([GPSUTILS_LIBS])
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_ARG_WITH([locpla_includes],
AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
[Specify the path to locpla-includes in loc-pla_git.bb]),
[locpla_incdir=$withval],
with_locpla_includes=no)
if test "x${with_locpla_includes}" != "xno"; then
AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
fi
AC_SUBST([CPPFLAGS])
AC_ARG_WITH([glib], AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib], AC_HELP_STRING([--with-glib],
@ -54,8 +76,7 @@ AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
AC_CONFIG_FILES([ \ AC_CONFIG_FILES([ \
Makefile \ Makefile \
src/Makefile \ location-api.pc \
loc-pla.pc \
]) ])
AC_OUTPUT AC_OUTPUT

10
location/location-api.pc.in Normal file
View file

@ -0,0 +1,10 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: location-api
Description: Location API
Version: @VERSION
Libs: -L${libdir} -llocation_api
Cflags: -I${includedir}/location-api

30
pla/Android.mk Normal file
View file

@ -0,0 +1,30 @@
GNSS_CFLAGS := \
-Werror \
-Wno-error=unused-parameter \
-Wno-error=format \
-Wno-error=macro-redefined \
-Wno-error=reorder \
-Wno-error=missing-braces \
-Wno-error=self-assign \
-Wno-error=enum-conversion \
-Wno-error=logical-op-parentheses \
-Wno-error=null-arithmetic \
-Wno-error=null-conversion \
-Wno-error=parentheses-equality \
-Wno-error=undefined-bool-conversion \
-Wno-error=tautological-compare \
-Wno-error=switch \
-Wno-error=date-time
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
ifneq ($(BUILD_TINY_ANDROID),true)
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_pla_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/android
include $(BUILD_HEADER_LIBRARY)
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

26
utils/platform_lib_abstractions/loc_stub/include/loc_stub_gettid.h → pla/android/loc_pla.h
View file

@ -26,19 +26,33 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __LOC_STUB_GETTID_H__ #ifndef __LOC_PLA__
#define __LOC_STUB_GETTID_H__ #define __LOC_PLA__
#include <pthread.h> #ifdef __cplusplus
#include <utils/SystemClock.h>
#define uptimeMillis android::uptimeMillis
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
pid_t gettid(void); #include <cutils/properties.h>
#include <cutils/threads.h>
#include <cutils/sched_policy.h>
#define LOC_PATH_GPS_CONF_STR "/vendor/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/vendor/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/vendor/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/vendor/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/vendor/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/vendor/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/vendor/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/vendor/etc/quipc.conf"
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif /*__cplusplus */
#endif /* __LOC_STUB_GETTID_H__ */ #endif /* __LOC_PLA__ */

37
utils/platform_lib_abstractions/loc_pla/include/platform_lib_property_service.h → pla/oe/loc_pla.h
View file

@ -26,19 +26,42 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __PLATFORM_LIB_PROPERTY_SERVICE_H__ #ifndef __LOC_PLA__
#define __PLATFORM_LIB_PROPERTY_SERVICE_H__ #define __LOC_PLA__
#ifdef __cplusplus #ifdef __cplusplus
#include <utils/SystemClock.h>
#define uptimeMillis android::uptimeMillis
extern "C" { extern "C" {
#endif #endif
#ifndef PROPERTY_VALUE_MAX
#define PROPERTY_VALUE_MAX 92 #include <cutils/properties.h>
#include <cutils/threads.h>
#include <cutils/sched_policy.h>
#include <sys/time.h>
#include <string.h>
#include <stdlib.h>
#ifndef OFF_TARGET
#include <glib.h>
#define strlcat g_strlcat
#define strlcpy g_strlcpy
#else
#define strlcat strncat
#define strlcpy strncpy
#endif #endif
int platform_lib_abstraction_property_get(const char *key, char *value, const char *default_value);
#define LOC_PATH_GPS_CONF_STR "/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/etc/quipc.conf"
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /*__cplusplus */
#endif /* __PLATFORM_LIB_PROPERTY_SERVICE_H__ */ #endif /* __LOC_PLA__ */

5
utils/Android.mk
View file

@ -11,8 +11,7 @@ include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := \ LOCAL_SHARED_LIBRARIES := \
libutils \ libutils \
libcutils \ libcutils \
liblog \ liblog
libloc_pla
LOCAL_SRC_FILES += \ LOCAL_SRC_FILES += \
loc_log.cpp \ loc_log.cpp \
@ -20,7 +19,6 @@ LOCAL_SRC_FILES += \
msg_q.c \ msg_q.c \
linked_list.c \ linked_list.c \
loc_target.cpp \ loc_target.cpp \
platform_lib_abstractions/elapsed_millis_since_boot.cpp \
LocHeap.cpp \ LocHeap.cpp \
LocTimer.cpp \ LocTimer.cpp \
LocThread.cpp \ LocThread.cpp \
@ -61,6 +59,5 @@ LOCAL_MODULE := libgps.utils_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
include $(BUILD_HEADER_LIBRARY) include $(BUILD_HEADER_LIBRARY)
include $(addsuffix /Android.mk, $(addprefix $(LOCAL_PATH)/, platform_lib_abstractions))
endif # not BUILD_TINY_ANDROID endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

3
utils/LocIpc.cpp
View file

@ -36,7 +36,8 @@
#include <unistd.h> #include <unistd.h>
#include <stdlib.h> #include <stdlib.h>
#include <array> #include <array>
#include <platform_lib_log_util.h> #include <loc_pla.h>
#include <log_util.h>
#include <string> #include <string>
#include <vector> #include <vector>
#include "gps_extended_c.h" #include "gps_extended_c.h"

3
utils/LocIpc.h
View file

@ -131,8 +131,7 @@ public:
inline bool send(const uint8_t data[], uint32_t length) { inline bool send(const uint8_t data[], uint32_t length) {
bool rtv = false; bool rtv = false;
if (nullptr != mSocket && nullptr != data) { if (nullptr != mSocket && nullptr != data) {
ssize_t rv = LocIpc::sendData(*mSocket, mDestAddr, data, length); rtv = LocIpc::sendData(*mSocket, mDestAddr, data, length);
rtv = (rv == (int)length);
} }
return rtv; return rtv;
} }

2
utils/LocThread.cpp
View file

@ -29,7 +29,7 @@
#include <LocThread.h> #include <LocThread.h>
#include <string.h> #include <string.h>
#include <pthread.h> #include <pthread.h>
#include <platform_lib_macros.h> #include <loc_pla.h>
class LocThreadDelegate { class LocThreadDelegate {
LocRunnable* mRunnable; LocRunnable* mRunnable;

4
utils/LocTimer.cpp
View file

@ -27,13 +27,15 @@
* *
*/ */
#include <unistd.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <errno.h> #include <errno.h>
#include <loc_timer.h>
#include <sys/timerfd.h> #include <sys/timerfd.h>
#include <sys/epoll.h> #include <sys/epoll.h>
#include <log_util.h>
#include <loc_timer.h>
#include <LocTimer.h> #include <LocTimer.h>
#include <LocHeap.h> #include <LocHeap.h>
#include <LocThread.h> #include <LocThread.h>

2
utils/LocTimer.h
View file

@ -31,7 +31,7 @@
#define __LOC_TIMER_CPP_H__ #define __LOC_TIMER_CPP_H__
#include <stddef.h> #include <stddef.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
// opaque class to provide service implementation. // opaque class to provide service implementation.
class LocTimerDelegate; class LocTimerDelegate;

42
utils/Makefile.am
View file

@ -1,15 +1,17 @@
ACLOCAL_AMFLAGS = -I m4
AM_CFLAGS = -Wundef \ AM_CFLAGS = -Wundef \
-I./ \ -MD \
-I$(WORKSPACE)/system/core/include \ -Wno-trigraphs \
-std=c++11 \ -g -O0 \
$(LOCPLA_CFLAGS) -fno-inline \
-fno-short-enums \
AM_CPPFLAGS = -Wundef \ -fpic \
-I./ \ -I./ \
-std=c++11 \ -std=c++11 \
$(LOCPLA_CFLAGS) $(LOCPLA_CFLAGS)
libgps_utils_so_la_h_sources = \ libgps_utils_la_h_sources = \
msg_q.h \ msg_q.h \
linked_list.h \ linked_list.h \
loc_cfg.h \ loc_cfg.h \
@ -28,7 +30,7 @@ libgps_utils_so_la_h_sources = \
loc_gps.h \ loc_gps.h \
log_util.h log_util.h
libgps_utils_so_la_c_sources = \ libgps_utils_la_c_sources = \
linked_list.c \ linked_list.c \
msg_q.c \ msg_q.c \
loc_cfg.cpp \ loc_cfg.cpp \
@ -42,27 +44,27 @@ libgps_utils_so_la_c_sources = \
loc_misc_utils.cpp \ loc_misc_utils.cpp \
loc_nmea.cpp loc_nmea.cpp
library_includedir = $(pkgincludedir)
library_include_HEADERS = $(libgps_utils_so_la_h_sources) library_include_HEADERS = $(libgps_utils_la_h_sources)
libgps_utils_so_la_SOURCES = $(libgps_utils_so_la_c_sources) libgps_utils_la_SOURCES = $(libgps_utils_la_c_sources)
if USE_GLIB if USE_GLIB
libgps_utils_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ libgps_utils_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libgps_utils_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 libgps_utils_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ libgps_utils_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else else
libgps_utils_so_la_CFLAGS = $(AM_CFLAGS) libgps_utils_la_CFLAGS = $(AM_CFLAGS)
libgps_utils_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0 libgps_utils_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) libgps_utils_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif endif
libgps_utils_so_la_LIBADD = -lcutils -lstdc++ -llog $(LOCPLA_LIBS) libgps_utils_la_LIBADD = $(CUTILS_LIBS)
#Create and Install libraries #Create and Install libraries
lib_LTLIBRARIES = libgps_utils_so.la lib_LTLIBRARIES = libgps_utils.la
library_includedir = $(pkgincludedir)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = gps-utils.pc pkgconfig_DATA = gps-utils.pc
EXTRA_DIST = $(pkgconfig_DATA) EXTRA_DIST = $(pkgconfig_DATA)

5
utils/MsgTask.cpp
View file

@ -32,8 +32,9 @@
#include <unistd.h> #include <unistd.h>
#include <MsgTask.h> #include <MsgTask.h>
#include <msg_q.h> #include <msg_q.h>
#include <log_util.h>
#include <loc_log.h> #include <loc_log.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
static void LocMsgDestroy(void* msg) { static void LocMsgDestroy(void* msg) {
delete (LocMsg*)msg; delete (LocMsg*)msg;
@ -82,7 +83,7 @@ void MsgTask::sendMsg(const LocMsg* msg) const {
void MsgTask::prerun() { void MsgTask::prerun() {
// make sure we do not run in background scheduling group // make sure we do not run in background scheduling group
platform_lib_abstraction_set_sched_policy(platform_lib_abstraction_gettid(), PLA_SP_FOREGROUND); set_sched_policy(gettid(), SP_FOREGROUND);
} }
bool MsgTask::run() { bool MsgTask::run() {

29
utils/configure.ac
View file

@ -28,9 +28,32 @@ AC_PROG_LN_S
AC_PROG_MAKE_SET AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG PKG_PROG_PKG_CONFIG
PKG_CHECK_MODULES([LOCPLA], [loc-pla]) # Checks for libraries.
AC_SUBST([LOCPLA_CFLAGS]) PKG_CHECK_MODULES([CUTILS], [libcutils])
AC_SUBST([LOCPLA_LIBS]) AC_SUBST([CUTILS_CFLAGS])
AC_SUBST([CUTILS_LIBS])
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_ARG_WITH([locpla_includes],
AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
[specify the path to locpla-includes in loc-pla_git.bb]),
[locpla_incdir=$withval],
with_locpla_includes=no)
if test "x$with_locpla_includes" != "xno"; then
AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
fi
AC_SUBST([CPPFLAGS])
AC_ARG_WITH([glib], AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib], AC_HELP_STRING([--with-glib],

2
utils/gps-utils.pc.in
View file

@ -6,5 +6,5 @@ includedir=@includedir@
Name: gps-utils Name: gps-utils
Description: QTI GPS Location utils Description: QTI GPS Location utils
Version: @VERSION Version: @VERSION
Libs: -L${libdir} -lgps_utils_so Libs: -L${libdir} -lgps_utils
Cflags: -I${includedir}/gps-utils Cflags: -I${includedir}/gps-utils

7
utils/linked_list.c
View file

@ -26,14 +26,15 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#define LOG_TAG "LocSvc_utils_ll"
#include "linked_list.h" #include "linked_list.h"
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#define LOG_TAG "LocSvc_utils_ll"
#include <platform_lib_includes.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <loc_pla.h>
#include <log_util.h>
typedef struct list_element { typedef struct list_element {
struct list_element* next; struct list_element* next;

745
utils/loc_cfg.cpp
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. /* Copyright (c) 2011-2015, 2018 The Linux Foundation. All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are * modification, are permitted provided that the following conditions are
@ -37,13 +37,16 @@
#include <ctype.h> #include <ctype.h>
#include <unistd.h> #include <unistd.h>
#include <time.h> #include <time.h>
#include <pwd.h>
#include <errno.h>
#include <loc_cfg.h> #include <loc_cfg.h>
#include <platform_lib_includes.h> #include <loc_pla.h>
#include <loc_target.h>
#include <loc_misc_utils.h> #include <loc_misc_utils.h>
#ifdef USE_GLIB #ifdef USE_GLIB
#include <glib.h> #include <glib.h>
#endif #endif
#include "platform_lib_includes.h" #include "log_util.h"
/*============================================================================= /*=============================================================================
* *
@ -71,6 +74,17 @@ typedef struct loc_param_v_type
double param_double_value; double param_double_value;
}loc_param_v_type; }loc_param_v_type;
// Reference below arrays wherever needed to avoid duplicating
// same conf path string over and again in location code.
const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR;
const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR;
const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR;
const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR;
const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR;
const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR;
const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR;
const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR;
/*=========================================================================== /*===========================================================================
FUNCTION loc_set_config_entry FUNCTION loc_set_config_entry
@ -395,3 +409,728 @@ void loc_read_conf(const char* conf_file_name, const loc_param_s_type* config_ta
/* Initialize logging mechanism with parsed data */ /* Initialize logging mechanism with parsed data */
loc_logger_init(DEBUG_LEVEL, TIMESTAMP); loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
} }
/*=============================================================================
*
* Define and Structures for Parsing Location Process Configuration File
*
*============================================================================*/
#define MAX_NUM_STRINGS 20
//We can have 8 masks for now
#define CONFIG_MASK_TARGET_ALL 0X01
#define CONFIG_MASK_TARGET_FOUND 0X02
#define CONFIG_MASK_TARGET_CHECK 0X03
#define CONFIG_MASK_BASEBAND_ALL 0X04
#define CONFIG_MASK_BASEBAND_FOUND 0X08
#define CONFIG_MASK_BASEBAND_CHECK 0x0c
#define CONFIG_MASK_AUTOPLATFORM_ALL 0x10
#define CONFIG_MASK_AUTOPLATFORM_FOUND 0x20
#define CONFIG_MASK_AUTOPLATFORM_CHECK 0x30
#define LOC_FEATURE_MASK_GTP_WIFI_BASIC 0x01
#define LOC_FEATURE_MASK_GTP_WIFI_PREMIUM 0X02
#define LOC_FEATURE_MASK_GTP_CELL_BASIC 0X04
#define LOC_FEATURE_MASK_GTP_CELL_PREMIUM 0X08
#define LOC_FEATURE_MASK_GTP_AP_CELL_BASIC LOC_FEATURE_MASK_GTP_CELL_BASIC
#define LOC_FEATURE_MASK_GTP_AP_CELL_PREMIUM LOC_FEATURE_MASK_GTP_CELL_PREMIUM
#define LOC_FEATURE_MASK_SAP_BASIC 0x40
#define LOC_FEATURE_MASK_SAP_PREMIUM 0X80
#define LOC_FEATURE_MASK_GTP_WAA_BASIC 0X100
#define LOC_FEATURE_MASK_GTP_WAA_PREMIUM 0x200
#define LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC 0X400
#define LOC_FEATURE_MASK_GTP_MODEM_CELL_PREMIUM 0X800
#define LOC_FEATURE_MASK_ODCPI 0x1000
#define LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT 0x2000
#define LOC_FEATURE_MASK_SUPL_WIFI 0x4000
#define LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO 0x8000
typedef struct {
char proc_name[LOC_MAX_PARAM_STRING];
char proc_argument[LOC_MAX_PARAM_STRING];
char proc_status[LOC_MAX_PARAM_STRING];
char group_list[LOC_MAX_PARAM_STRING];
unsigned int premium_feature;
unsigned int loc_feature_mask;
char platform_list[LOC_MAX_PARAM_STRING];
char baseband[LOC_MAX_PARAM_STRING];
char lean_targets[LOC_MAX_PARAM_STRING];
unsigned int sglte_target;
char feature_gtp_cell_proc[LOC_MAX_PARAM_STRING];
char feature_gtp_waa[LOC_MAX_PARAM_STRING];
char feature_gtp_cell[LOC_MAX_PARAM_STRING];
char feature_gtp_wifi[LOC_MAX_PARAM_STRING];
char feature_sap[LOC_MAX_PARAM_STRING];
char feature_odcpi[LOC_MAX_PARAM_STRING];
char feature_free_wifi_scan_inject[LOC_MAX_PARAM_STRING];
char feature_supl_wifi[LOC_MAX_PARAM_STRING];
char feature_wifi_supplicant_info[LOC_MAX_PARAM_STRING];
char auto_platform[LOC_MAX_PARAM_STRING];
} loc_launcher_conf;
/* process configuration parameters */
static loc_launcher_conf conf;
/* gps.conf Parameter spec table */
static const loc_param_s_type gps_conf_parameter_table[] = {
{"SGLTE_TARGET", &conf.sglte_target, NULL, 'n'},
};
/* location feature conf, e.g.: izat.conf feature mode table*/
static const loc_param_s_type loc_feature_conf_table[] = {
{"GTP_CELL_PROC", &conf.feature_gtp_cell_proc, NULL, 's'},
{"GTP_CELL", &conf.feature_gtp_cell, NULL, 's'},
{"GTP_WIFI", &conf.feature_gtp_wifi, NULL, 's'},
{"GTP_WAA", &conf.feature_gtp_waa, NULL, 's'},
{"SAP", &conf.feature_sap, NULL, 's'},
{"ODCPI", &conf.feature_odcpi, NULL, 's'},
{"FREE_WIFI_SCAN_INJECT", &conf.feature_free_wifi_scan_inject, NULL, 's'},
{"SUPL_WIFI", &conf.feature_supl_wifi, NULL, 's'},
{"WIFI_SUPPLICANT_INFO", &conf.feature_wifi_supplicant_info, NULL, 's'},
};
/* location process conf, e.g.: izat.conf Parameter spec table */
static const loc_param_s_type loc_process_conf_parameter_table[] = {
{"PROCESS_NAME", &conf.proc_name, NULL, 's'},
{"PROCESS_ARGUMENT", &conf.proc_argument, NULL, 's'},
{"PROCESS_STATE", &conf.proc_status, NULL, 's'},
{"PROCESS_GROUPS", &conf.group_list, NULL, 's'},
{"PREMIUM_FEATURE", &conf.premium_feature, NULL, 'n'},
{"IZAT_FEATURE_MASK", &conf.loc_feature_mask, NULL, 'n'},
{"PLATFORMS", &conf.platform_list, NULL, 's'},
{"BASEBAND", &conf.baseband, NULL, 's'},
{"LEAN_TARGETS", &conf.lean_targets, NULL, 's'},
{"HARDWARE_TYPE", &conf.auto_platform, NULL, 's'},
};
/*===========================================================================
FUNCTION loc_read_process_conf
DESCRIPTION
Parse the specified conf file and return info for the processes defined.
The format of the file should conform with izat.conf.
PARAMETERS:
conf_file_name: configuration file to read
process_count_ptr: pointer to store number of processes defined in the conf file.
process_info_table_ptr: pointer to store the process info table.
DEPENDENCIES
The file must be in izat.conf format.
RETURN VALUE
0: success
none-zero: failure
SIDE EFFECTS
N/A
NOTES:
On success, memory pointed by (*process_info_table_ptr) must be freed.
===========================================================================*/
int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_ptr,
loc_process_info_s_type** process_info_table_ptr) {
loc_process_info_s_type *child_proc = nullptr;
volatile int i=0;
unsigned int j=0;
gid_t gid_list[LOC_PROCESS_MAX_NUM_GROUPS];
char *split_strings[MAX_NUM_STRINGS];
int name_length=0, group_list_length=0, platform_length=0, baseband_length=0, ngroups=0, ret=0;
int auto_platform_length = 0;
int group_index=0, nstrings=0, status_length=0;
FILE* conf_fp = nullptr;
char platform_name[PROPERTY_VALUE_MAX], baseband_name[PROPERTY_VALUE_MAX];
char autoplatform_name[PROPERTY_VALUE_MAX];
int lean_target=0;
unsigned int loc_service_mask=0;
char config_mask = 0;
unsigned char proc_list_length=0;
int gtp_cell_ap_enabled = 0;
char arg_gtp_waa[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_ap_cell[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_modem_cell[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_gtp_wifi[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_sap[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
char arg_disabled[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_DISABLED;
char arg_basic[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_BASIC;
char arg_premium[LOC_PROCESS_MAX_ARG_STR_LENGTH] = LOC_FEATURE_MODE_PREMIUM;
if (process_count_ptr == NULL || process_info_table_ptr == NULL) {
return -1;
}
//Read gps.conf and fill parameter table
UTIL_READ_CONF(LOC_PATH_GPS_CONF, gps_conf_parameter_table);
//Form argument strings
strlcat(arg_gtp_waa, LOC_FEATURE_GTP_WAA, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_ap_cell, LOC_FEATURE_GTP_AP_CELL, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_modem_cell, LOC_FEATURE_GTP_MODEM_CELL, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_gtp_wifi, LOC_FEATURE_GTP_WIFI, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
strlcat(arg_sap, LOC_FEATURE_SAP, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
//Get platform name from ro.board.platform property
loc_get_platform_name(platform_name, sizeof(platform_name));
//Get baseband name from ro.baseband property
loc_get_target_baseband(baseband_name, sizeof(baseband_name));
lean_target = loc_identify_lean_target();
LOC_LOGD("%s:%d]: lean target:%d", __func__, __LINE__, lean_target);
//Identify if this is an automotive platform
loc_get_auto_platform_name(autoplatform_name,sizeof(autoplatform_name));
UTIL_READ_CONF(conf_file_name, loc_feature_conf_table);
//Set service mask for GTP_WIFI
if(strcmp(conf.feature_gtp_wifi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP WIFI DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_gtp_wifi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP WIFI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC;
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP WIFI Mode."\
" Setting GTP WIFI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC;
}
//Set service mask for GTP_CELL
//Using a temp variable here to indicate wheter GTP cell is
//enabled on the AP or modem. This variable will be used in
//further checks below. An alternative was to compare the
//string again in each place which would've been more expensive
if(strcmp(conf.feature_gtp_cell_proc, "AP") == 0) {
gtp_cell_ap_enabled = 1;
}
if(strcmp(conf.feature_gtp_cell, "PREMIUM") == 0) {
LOC_LOGE("%s:%d]: Error: location feature GTP CELL does not support PREMIUM mode" \
" available modes are BASIC and DISABLED. Starting feature in BASIC mode",
__func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
else if(strcmp(conf.feature_gtp_cell, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP CELL to mode: BASIC", __func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
else if(strcmp(conf.feature_gtp_cell, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP CELL DISABLED", __func__, __LINE__);
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP CELL Mode." \
" Setting GTP CELL to default mode: BASIC", __func__, __LINE__);
if(gtp_cell_ap_enabled) {
loc_service_mask |= LOC_FEATURE_MASK_GTP_AP_CELL_BASIC;
}
else {
loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC;
}
}
//Set service mask for GTP_WAA
if(strcmp(conf.feature_gtp_waa, "PREMIUM") == 0) {
LOC_LOGE("%s:%d]: Error: location feature GTP WAA does not support PREMIUM mode" \
" available modes are BASIC and DISABLED. Starting feature in BASIC mode",
__func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC;
}
else if(strcmp(conf.feature_gtp_waa, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting GTP WAA to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC;
}
else if(strcmp(conf.feature_gtp_waa, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: GTP WAA DISABLED", __func__, __LINE__);
}
//conf file has a garbage value
else {
LOC_LOGE("%s:%d]: Unrecognized value for GTP WAA Mode."\
" Setting GTP WAA to default mode: DISABLED", __func__, __LINE__);
}
//Set service mask for SAP
if(strcmp(conf.feature_sap, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: PREMIUM", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_PREMIUM;
}
else if(strcmp(conf.feature_sap, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC;
}
else if(strcmp(conf.feature_sap, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting SAP to mode: DISABLED", __func__, __LINE__);
}
else {
LOC_LOGE("%s:%d]: Unrecognized value for SAP Mode."\
" Setting SAP to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC;
}
// Set service mask for ODCPI
if(strcmp(conf.feature_odcpi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting ODCPI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_ODCPI;
}
else if(strcmp(conf.feature_odcpi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting ODCPI to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_odcpi, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for ODCPI mode."\
"Setting ODCPI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_ODCPI;
}
// Set service mask for FREE_WIFI_SCAN_INJECT
if(strcmp(conf.feature_free_wifi_scan_inject, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT;
}
else if(strcmp(conf.feature_free_wifi_scan_inject, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_free_wifi_scan_inject, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for FREE_WIFI_SCAN_INJECT mode."\
"Setting FREE_WIFI_SCAN_INJECT to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT;
}
// Set service mask for SUPL_WIFI
if(strcmp(conf.feature_supl_wifi, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI;
}
else if(strcmp(conf.feature_supl_wifi, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_supl_wifi, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for SUPL_WIFI mode."\
"Setting SUPL_WIFI to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI;
}
// Set service mask for WIFI_SUPPLICANT_INFO
if(strcmp(conf.feature_wifi_supplicant_info, "BASIC") == 0) {
LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO;
}
else if(strcmp(conf.feature_wifi_supplicant_info, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: DISABLED", __func__, __LINE__);
}
else if(strcmp(conf.feature_wifi_supplicant_info, "PREMIUM") == 0) {
LOC_LOGD("%s:%d]: Unrecognized value for WIFI_SUPPLICANT_INFO mode."\
"Setting LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO to default mode: BASIC", __func__, __LINE__);
loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO;
}
LOC_LOGD("%s:%d]: loc_service_mask: %x\n", __func__, __LINE__, loc_service_mask);
if((conf_fp = fopen(conf_file_name, "r")) == NULL) {
LOC_LOGE("%s:%d]: Error opening %s %s\n", __func__,
__LINE__, conf_file_name, strerror(errno));
ret = -1;
goto err;
}
//Parse through the file to find out how many processes are to be launched
proc_list_length = 0;
do {
conf.proc_name[0] = 0;
//Here note that the 3rd parameter is passed as 1.
//This is so that only the first parameter in the table which is "PROCESS_NAME"
//is read. We do not want to read the entire block of parameters at this time
//since we are only counting the number of processes to launch.
//Therefore, only counting the occurrences of PROCESS_NAME parameter
//should suffice
if(loc_read_conf_r(conf_fp, loc_process_conf_parameter_table, 1)) {
LOC_LOGE("%s:%d]: Unable to read conf file. Failing\n", __func__, __LINE__);
ret = -1;
goto err;
}
name_length=(int)strlen(conf.proc_name);
if(name_length) {
proc_list_length++;
LOC_LOGD("Process name:%s", conf.proc_name);
}
} while(name_length);
LOC_LOGD("Process cnt = %d", proc_list_length);
child_proc = (loc_process_info_s_type *)calloc(proc_list_length, sizeof(loc_process_info_s_type));
if(child_proc == NULL) {
LOC_LOGE("%s:%d]: ERROR: Malloc returned NULL\n", __func__, __LINE__);
ret = -1;
goto err;
}
//Move file descriptor to the beginning of the file
//so that the parameters can be read
rewind(conf_fp);
for(j=0; j<proc_list_length; j++) {
//Set defaults for all the child process structs
child_proc[j].proc_status = DISABLED;
memset(child_proc[j].group_list, 0, sizeof(child_proc[j].group_list));
config_mask=0;
if(loc_read_conf_r(conf_fp, loc_process_conf_parameter_table,
sizeof(loc_process_conf_parameter_table)/sizeof(loc_process_conf_parameter_table[0]))) {
LOC_LOGE("%s:%d]: Unable to read conf file. Failing\n", __func__, __LINE__);
ret = -1;
goto err;
}
name_length=(int)strlen(conf.proc_name);
group_list_length=(int)strlen(conf.group_list);
platform_length = (int)strlen(conf.platform_list);
baseband_length = (int)strlen(conf.baseband);
status_length = (int)strlen(conf.proc_status);
auto_platform_length = (int)strlen(conf.auto_platform);
if(!name_length || !group_list_length || !platform_length ||
!baseband_length || !status_length || !auto_platform_length) {
LOC_LOGE("%s:%d]: Error: i: %d; One of the parameters not specified in conf file",
__func__, __LINE__, i);
continue;
}
if(strcmp(conf.proc_status, "DISABLED") == 0) {
LOC_LOGD("%s:%d]: Process %s is disabled in conf file",
__func__, __LINE__, conf.proc_name);
child_proc[j].proc_status = DISABLED_FROM_CONF;
continue;
}
else if(strcmp(conf.proc_status, "ENABLED") == 0) {
LOC_LOGD("%s:%d]: Process %s is enabled in conf file",
__func__, __LINE__, conf.proc_name);
}
//Since strlcpy copies length-1 characters, we add 1 to name_length
if((name_length+1) > LOC_MAX_PARAM_STRING) {
LOC_LOGE("%s:%d]: i: %d; Length of name parameter too long. Max length: %d",
__func__, __LINE__, i, LOC_MAX_PARAM_STRING);
continue;
}
strlcpy(child_proc[j].name[0], conf.proc_name, sizeof (child_proc[j].name[0]));
child_proc[j].num_groups = 0;
ngroups = loc_util_split_string(conf.group_list, split_strings, MAX_NUM_STRINGS, ' ');
#ifdef __ANDROID__
for(i=0; i<ngroups; i++) {
struct passwd* pwd = getpwnam(split_strings[i]);
if (pwd) {
child_proc[j].group_list[i] = pwd->pw_gid;
child_proc[j].num_groups++;
LOC_LOGD("%s:%d]:Group %s = %d matches child_group: %d\n",
__func__, __LINE__, split_strings[i],
pwd->pw_gid,child_proc[j].group_list[i]);
}
}
#endif
nstrings = loc_util_split_string(conf.platform_list, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
if (nstrings == 1 || (nstrings == 2 && (strcmp("exclude", split_strings[1]) == 0))) {
LOC_LOGD("%s:%d]: Enabled for all targets\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_TARGET_ALL;
}
else if (nstrings > 2 && (strcmp("exclude", split_strings[1]) == 0)) {
config_mask |= CONFIG_MASK_TARGET_FOUND;
for (i=2; i<nstrings; i++) {
if(strcmp(platform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Disabled platform %s\n", __func__, __LINE__, platform_name);
config_mask &= ~CONFIG_MASK_TARGET_FOUND;
break;
}
}
}
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(platform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched platform: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_TARGET_FOUND;
break;
}
}
}
nstrings = loc_util_split_string(conf.baseband, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
if (nstrings == 1 || (nstrings == 2 && (strcmp("exclude", split_strings[1]) == 0))) {
LOC_LOGD("%s:%d]: Enabled for all basebands\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_BASEBAND_ALL;
}
else if (nstrings > 2 && (strcmp("exclude", split_strings[1]) == 0)) {
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
for (i=2; i<nstrings; i++) {
if(strcmp(baseband_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Disabled band %s\n", __func__, __LINE__, baseband_name);
config_mask &= ~CONFIG_MASK_BASEBAND_FOUND;
break;
}
}
}
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(baseband_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched baseband: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
break;
}
//Since ro.baseband is not a reliable source for detecting sglte
//the alternative is to read the SGLTE_TARGET parameter from gps.conf
//this parameter is read into conf_sglte_target
else if((strcmp("sglte", split_strings[i]) == 0 ) && conf.sglte_target) {
LOC_LOGD("%s:%d]: Matched baseband SGLTE\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_BASEBAND_FOUND;
break;
}
}
}
nstrings = loc_util_split_string(conf.auto_platform, split_strings, MAX_NUM_STRINGS, ' ');
if(strcmp("all", split_strings[0]) == 0) {
LOC_LOGD("%s:%d]: Enabled for all auto platforms\n", __func__, __LINE__);
config_mask |= CONFIG_MASK_AUTOPLATFORM_ALL;
}
else {
for(i=0; i<nstrings; i++) {
if(strcmp(autoplatform_name, split_strings[i]) == 0) {
LOC_LOGD("%s:%d]: Matched auto platform: %s\n",
__func__, __LINE__, split_strings[i]);
config_mask |= CONFIG_MASK_AUTOPLATFORM_FOUND;
break;
}
}
}
nstrings = loc_util_split_string(conf.lean_targets, split_strings, MAX_NUM_STRINGS, ' ');
if(!strcmp("DISABLED", split_strings[0]) && lean_target) {
LOC_LOGD("%s:%d]: Disabled for lean targets\n", __func__, __LINE__);
child_proc[j].proc_status = DISABLED;
continue;
}
if((config_mask & CONFIG_MASK_TARGET_CHECK) &&
(config_mask & CONFIG_MASK_BASEBAND_CHECK) &&
(config_mask & CONFIG_MASK_AUTOPLATFORM_CHECK) &&
(child_proc[j].proc_status != DISABLED_FROM_CONF)) {
//Set args
//The first argument passed through argv is usually the name of the
//binary when started from commandline.
//getopt() seems to ignore this first argument and hence we assign it
//to the process name for consistency with command line args
i = 0;
char* temp_arg = ('/' == child_proc[j].name[0][0]) ?
(strrchr(child_proc[j].name[0], '/') + 1) : child_proc[j].name[0];
strlcpy (child_proc[j].args[i++], temp_arg, sizeof (child_proc[j].args[i++]));
if(conf.premium_feature) {
if(conf.loc_feature_mask & loc_service_mask) {
LOC_LOGD("%s:%d]: Enabled. %s has service mask: %x\n",
__func__, __LINE__, child_proc[j].name[0], conf.loc_feature_mask);
child_proc[j].proc_status = ENABLED;
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_WIFI_BASIC | LOC_FEATURE_MASK_GTP_WIFI_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_WIFI_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_WIFI_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_gtp_wifi,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_CELL_BASIC | LOC_FEATURE_MASK_GTP_CELL_PREMIUM )) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_AP_CELL_BASIC){
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_AP_CELL_PREMIUM){
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_MODEM_CELL_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else {
strlcpy(child_proc[j].args[i++], arg_gtp_ap_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_gtp_modem_cell,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_GTP_WAA_BASIC | LOC_FEATURE_MASK_GTP_WAA_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_GTP_WAA_BASIC) {
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_GTP_WAA_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_gtp_waa,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
if(conf.loc_feature_mask &
(LOC_FEATURE_MASK_SAP_BASIC | LOC_FEATURE_MASK_SAP_PREMIUM)) {
if(loc_service_mask & LOC_FEATURE_MASK_SAP_BASIC) {
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_basic,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else if(loc_service_mask & LOC_FEATURE_MASK_SAP_PREMIUM) {
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_premium,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
else
{
strlcpy(child_proc[j].args[i++], arg_sap,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
strlcpy(child_proc[j].args[i++], arg_disabled,
LOC_PROCESS_MAX_ARG_STR_LENGTH);
}
}
IF_LOC_LOGD {
LOC_LOGD("%s:%d]: %s args\n", __func__, __LINE__, child_proc[j].name[0]);
for(unsigned int k=0; k<LOC_PROCESS_MAX_NUM_ARGS; k++) {
if(child_proc[j].args[k][0] != '\0') {
LOC_LOGD("%s:%d]: k: %d, %s\n", __func__, __LINE__, k,
child_proc[j].args[k]);
}
}
LOC_LOGD("%s:%d]: \n", __func__, __LINE__);
}
}
else {
LOC_LOGD("%s:%d]: Disabled. %s has service mask: %x \n",
__func__, __LINE__, child_proc[j].name[0], conf.loc_feature_mask);
}
}
else {
LOC_LOGD("%s:%d]: %s not a premium feature. Enabled\n",
__func__, __LINE__, child_proc[j].name[0]);
child_proc[j].proc_status = ENABLED;
}
/*Fill up the remaining arguments from configuration file*/
LOC_LOGD("%s] Parsing Process_Arguments from Configuration: %s \n",
__func__, conf.proc_argument);
if(0 != conf.proc_argument[0])
{
/**************************************
** conf_proc_argument is shared by all the programs getting launched,
** hence copy to process specific argument string and parse the same.
***************************************/
strlcpy(child_proc[j].argumentString, conf.proc_argument,
sizeof(child_proc[j].argumentString));
char *temp_args[LOC_PROCESS_MAX_NUM_ARGS];
memset (temp_args, 0, sizeof (temp_args));
loc_util_split_string(child_proc[j].argumentString, &temp_args[i],
(LOC_PROCESS_MAX_NUM_ARGS - i), ' ');
// copy argument from the pointer to the memory
for (unsigned int index = i; index < LOC_PROCESS_MAX_NUM_ARGS; index++) {
if (temp_args[index] == NULL) {
break;
}
strlcpy (child_proc[j].args[index], temp_args[index],
sizeof (child_proc[j].args[index]));
}
}
}
else {
LOC_LOGD("%s:%d]: Process %s is disabled\n",
__func__, __LINE__, child_proc[j].name[0]);
}
}
err:
fclose(conf_fp);
if (ret != 0) {
LOC_LOGE("%s:%d]: ret: %d", __func__, __LINE__, ret);
if (child_proc) {
free (child_proc);
child_proc = nullptr;
}
*process_count_ptr = 0;
*process_info_table_ptr = nullptr;
}
else {
*process_count_ptr = proc_list_length;
*process_info_table_ptr = child_proc;
}
return ret;
}

51
utils/loc_cfg.h
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. /* Copyright (c) 2011-2015, 2018 The Linux Foundation. All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are * modification, are permitted provided that the following conditions are
@ -32,11 +32,29 @@
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <sys/types.h>
#include <unistd.h>
#include <grp.h>
#define LOC_MAX_PARAM_NAME 80 #define LOC_MAX_PARAM_NAME 80
#define LOC_MAX_PARAM_STRING 80 #define LOC_MAX_PARAM_STRING 80
#define LOC_MAX_PARAM_LINE (LOC_MAX_PARAM_NAME + LOC_MAX_PARAM_STRING) #define LOC_MAX_PARAM_LINE (LOC_MAX_PARAM_NAME + LOC_MAX_PARAM_STRING)
#define LOC_FEATURE_MODE_DISABLED "DISABLED"
#define LOC_FEATURE_MODE_BASIC "BASIC"
#define LOC_FEATURE_MODE_PREMIUM "PREMIUM"
#define LOC_FEATURE_GTP_AP_CELL "gtp-ap-cell"
#define LOC_FEATURE_GTP_MODEM_CELL "gtp-modem-cell"
#define LOC_FEATURE_GTP_CELL_ENH "gtp-cell-enh"
#define LOC_FEATURE_GTP_WIFI "gtp-wifi"
#define LOC_FEATURE_GTP_WAA "gtp-waa"
#define LOC_FEATURE_SAP "sap"
#define LOC_PROCESS_MAX_NUM_GROUPS 20
#define LOC_PROCESS_MAX_NUM_ARGS 25
#define LOC_PROCESS_MAX_ARG_STR_LENGTH 32
#define UTIL_UPDATE_CONF(conf_data, len, config_table) \ #define UTIL_UPDATE_CONF(conf_data, len, config_table) \
loc_update_conf((conf_data), (len), (config_table), \ loc_update_conf((conf_data), (len), (config_table), \
sizeof(config_table) / sizeof(config_table[0])) sizeof(config_table) / sizeof(config_table[0]))
@ -62,6 +80,23 @@ typedef struct
'f' for double */ 'f' for double */
} loc_param_s_type; } loc_param_s_type;
typedef enum {
ENABLED,
RUNNING,
DISABLED,
DISABLED_FROM_CONF
} loc_process_e_status;
typedef struct {
loc_process_e_status proc_status;
pid_t proc_id;
char name[2][LOC_MAX_PARAM_STRING];
gid_t group_list[LOC_PROCESS_MAX_NUM_GROUPS];
unsigned char num_groups;
char args[LOC_PROCESS_MAX_NUM_ARGS][LOC_PROCESS_MAX_ARG_STR_LENGTH];
char argumentString[LOC_MAX_PARAM_STRING];
} loc_process_info_s_type;
/*============================================================================= /*=============================================================================
* *
* MODULE EXTERNAL DATA * MODULE EXTERNAL DATA
@ -84,6 +119,20 @@ int loc_read_conf_r(FILE *conf_fp, const loc_param_s_type* config_table,
uint32_t table_length); uint32_t table_length);
int loc_update_conf(const char* conf_data, int32_t length, int loc_update_conf(const char* conf_data, int32_t length,
const loc_param_s_type* config_table, uint32_t table_length); const loc_param_s_type* config_table, uint32_t table_length);
// Below are the location conf file paths
extern const char LOC_PATH_GPS_CONF[];
extern const char LOC_PATH_IZAT_CONF[];
extern const char LOC_PATH_FLP_CONF[];
extern const char LOC_PATH_LOWI_CONF[];
extern const char LOC_PATH_SAP_CONF[];
extern const char LOC_PATH_APDR_CONF[];
extern const char LOC_PATH_XTWIFI_CONF[];
extern const char LOC_PATH_QUIPC_CONF[];
int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_ptr,
loc_process_info_s_type** process_info_table_ptr);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

3
utils/loc_log.cpp
View file

@ -32,9 +32,10 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
#include "log_util.h"
#include "loc_log.h" #include "loc_log.h"
#include "msg_q.h" #include "msg_q.h"
#include <platform_lib_includes.h> #include <loc_pla.h>
#define BUFFER_SIZE 120 #define BUFFER_SIZE 120

2
utils/loc_misc_utils.cpp
View file

@ -30,7 +30,7 @@
#define LOG_TAG "LocSvc_misc_utils" #define LOG_TAG "LocSvc_misc_utils"
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <platform_lib_log_util.h> #include <log_util.h>
#include <loc_misc_utils.h> #include <loc_misc_utils.h>
#include <ctype.h> #include <ctype.h>

3
utils/loc_nmea.cpp
View file

@ -31,7 +31,8 @@
#define LOG_TAG "LocSvc_nmea" #define LOG_TAG "LocSvc_nmea"
#include <loc_nmea.h> #include <loc_nmea.h>
#include <math.h> #include <math.h>
#include <platform_lib_includes.h> #include <log_util.h>
#include <loc_pla.h>
#define GLONASS_SV_ID_OFFSET 64 #define GLONASS_SV_ID_OFFSET 64
#define MAX_SATELLITES_IN_USE 12 #define MAX_SATELLITES_IN_USE 12

5
utils/loc_target.cpp
View file

@ -27,6 +27,7 @@
* *
*/ */
#include <unistd.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -34,10 +35,10 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
#include <cutils/properties.h> #include <log_util.h>
#include "loc_target.h" #include "loc_target.h"
#include "loc_log.h" #include "loc_log.h"
#include <platform_lib_includes.h> #include <loc_pla.h>
#define APQ8064_ID_1 "109" #define APQ8064_ID_1 "109"
#define APQ8064_ID_2 "153" #define APQ8064_ID_2 "153"

3
utils/loc_timer.h
View file

@ -34,7 +34,8 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#include <stddef.h> #include <stddef.h>
#include <platform_lib_includes.h> #include <stdint.h>
#include <loc_pla.h>
/* /*
user_data: client context pointer, passthrough. Originally received user_data: client context pointer, passthrough. Originally received
from calling client when loc_timer_start() is called. from calling client when loc_timer_start() is called.

5
utils/log_util.h
View file

@ -37,13 +37,14 @@
#elif defined (USE_GLIB) #elif defined (USE_GLIB)
// LE targets with no logcat support // LE targets with no logcat support
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <cutils/log.h>
#ifndef LOG_TAG #ifndef LOG_TAG
#define LOG_TAG "GPS_UTILS" #define LOG_TAG "GPS_UTILS"
#endif /* LOG_TAG */
#endif // LOG_TAG
#endif /* #if defined (USE_ANDROID_LOGGING) || defined (ANDROID) */ #endif /* #if defined (USE_ANDROID_LOGGING) || defined (ANDROID) */

8
utils/msg_q.c
View file

@ -26,14 +26,14 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "msg_q.h"
#define LOG_TAG "LocSvc_utils_q" #define LOG_TAG "LocSvc_utils_q"
#include <platform_lib_includes.h>
#include "linked_list.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
#include <loc_pla.h>
#include <log_util.h>
#include "linked_list.h"
#include "msg_q.h"
typedef struct msg_q { typedef struct msg_q {
void* msg_list; /* Linked list to store information */ void* msg_list; /* Linked list to store information */

5
utils/platform_lib_abstractions/Android.mk
View file

@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

47
utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp
View file

@ -1,47 +0,0 @@
/* Copyright (c) 2013, 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 <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include "platform_lib_time.h"
int64_t systemTime(int /*clock*/)
{
struct timespec t;
t.tv_sec = t.tv_nsec = 0;
clock_gettime(CLOCK_MONOTONIC, &t);
return t.tv_sec*1000000LL + t.tv_nsec/1000LL;
}
int64_t elapsedMillisSinceBoot()
{
int64_t t_us = systemTime(0);
return (int64_t) t_us / 1000LL;
}

5
utils/platform_lib_abstractions/loc_pla/Android.mk
View file

@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

10
utils/platform_lib_abstractions/loc_pla/Makefile.am
View file

@ -1,10 +0,0 @@
# Makefile.am for gps loc-pla
#
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = src
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-pla.pc
EXTRA_DIST = $(pkgconfig_DATA)

45
utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h
View file

@ -1,45 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __PLATFORM_LIB_GETTID_H__
#define __PLATFORM_LIB_GETTID_H__
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef USE_GLIB
const char* getprogname();
#endif /* USE_GLIB */
pid_t platform_lib_abstraction_gettid();
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __PLATFORM_LIB_GETTID_H__ */

39
utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h
View file

@ -1,39 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __PLATFORM_LIB_INCLUDES_H__
#define __PLATFORM_LIB_INCLUDES_H__
#include "platform_lib_gettid.h"
#include "platform_lib_log_util.h"
#include "platform_lib_macros.h"
#include "platform_lib_property_service.h"
#include "platform_lib_sched_policy.h"
#include "platform_lib_time.h"
#endif /* __PLATFORM_LIB_INCLUDES_H__ */

174
utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h
View file

@ -1,174 +0,0 @@
/* Copyright (c) 2011-2014 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.
*/
#ifndef __PLATFORM_LIB_LOG_UTIL_H__
#define __PLATFORM_LIB_LOG_UTIL_H__
#include "platform_lib_macros.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#ifndef LOG_TAG
#define LOG_TAG "GPS_UTILS"
#endif /* LOG_TAG */
#if defined (USE_ANDROID_LOGGING) || defined (ANDROID)
// Android and LE targets with logcat support
#include <log_util.h>
#else
// LE targets without logcat support
#ifdef __cplusplus
extern "C"
{
#endif
/*=============================================================================
*
* LOC LOGGER TYPE DECLARATION
*
*============================================================================*/
/* LOC LOGGER */
typedef struct loc_logger_s
{
unsigned long DEBUG_LEVEL;
unsigned long TIMESTAMP;
} loc_logger_s_type;
/*=============================================================================
*
* EXTERNAL DATA
*
*============================================================================*/
extern loc_logger_s_type loc_logger;
// Logging Improvements
extern const char *loc_logger_boolStr[];
extern const char *boolStr[];
extern const char VOID_RET[];
extern const char FROM_AFW[];
extern const char TO_MODEM[];
extern const char FROM_MODEM[];
extern const char TO_AFW[];
extern const char EXIT_TAG[];
extern const char ENTRY_TAG[];
extern const char EXIT_ERROR_TAG[];
/*=============================================================================
*
* MODULE EXPORTED FUNCTIONS
*
*============================================================================*/
void loc_logger_init(unsigned long debug, unsigned long timestamp);
char* get_timestamp(char* str, unsigned long buf_size);
#ifndef DEBUG_DMN_LOC_API
/* LOGGING MACROS */
/*loc_logger.DEBUG_LEVEL is initialized to 0xff in loc_cfg.cpp
if that value remains unchanged, it means gps.conf did not
provide a value and we default to the initial value to use
Android's logging levels*/
#define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5))
#define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5))
#define LOC_LOGE(...) IF_LOC_LOGE { ALOGE(__VA_ARGS__); }
#define LOC_LOGW(...) IF_LOC_LOGW { ALOGW(__VA_ARGS__); }
#define LOC_LOGI(...) IF_LOC_LOGI { ALOGI(__VA_ARGS__); }
#define LOC_LOGD(...) IF_LOC_LOGD { ALOGD(__VA_ARGS__); }
#define LOC_LOGV(...) IF_LOC_LOGV { ALOGV(__VA_ARGS__); }
#else /* DEBUG_DMN_LOC_API */
#define LOC_LOGE(...) ALOGE(__VA_ARGS__)
#define LOC_LOGW(...) ALOGW(__VA_ARGS__)
#define LOC_LOGI(...) ALOGI(__VA_ARGS__)
#define LOC_LOGD(...) ALOGD(__VA_ARGS__)
#define LOC_LOGV(...) ALOGV(__VA_ARGS__)
#endif /* DEBUG_DMN_LOC_API */
/*=============================================================================
*
* LOGGING IMPROVEMENT MACROS
*
*============================================================================*/
#define LOG_(LOC_LOG, ID, WHAT, SPEC, VAL) \
do { \
if (loc_logger.TIMESTAMP) { \
char ts[32]; \
LOC_LOG("[%s] %s %s line %d " #SPEC, \
get_timestamp(ts, sizeof(ts)), ID, WHAT, __LINE__, VAL); \
} else { \
LOC_LOG("%s %s line %d " #SPEC, \
ID, WHAT, __LINE__, VAL); \
} \
} while(0)
#define LOC_LOG_HEAD(fmt) "%s:%d] " fmt
#define LOC_LOGv(fmt,...) LOC_LOGV(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGw(fmt,...) LOC_LOGW(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGd(fmt,...) LOC_LOGD(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOC_LOGe(fmt,...) LOC_LOGE(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL)
#define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL)
#define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL)
#define ENTRY_LOG() LOG_V(ENTRY_TAG, __FUNCTION__, %s, "")
#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL)
#define EXIT_LOG_WITH_ERROR(SPEC, VAL) \
if (VAL != 0) { \
LOG_E(EXIT_ERROR_TAG, __FUNCTION__, SPEC, VAL); \
} else { \
LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL); \
}
// Used for logging callflow from Android Framework
#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __FUNCTION__, %s, "")
// Used for logging callflow to Modem
#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __FUNCTION__, SPEC, VAL)
// Used for logging callflow from Modem(TO_MODEM, __FUNCTION__, %s, "")
#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __FUNCTION__, SPEC, VAL)
// Used for logging callflow to Android Framework
#define CALLBACK_LOG_CALLFLOW(CB, SPEC, VAL) LOG_I(TO_AFW, CB, SPEC, VAL)
#ifdef __cplusplus
}
#endif
#endif /* else of #if defined (USE_ANDROID_LOGGING) || defined (ANDROID) */
#endif /* __PLATFORM_LIB_LOG_UTIL_H__ */

89
utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h
View file

@ -1,89 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __PLATFORM_LIB_MACROS_H__
#define __PLATFORM_LIB_MACROS_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/time.h>
#include <string.h>
#include <stdlib.h>
#ifdef USE_GLIB
#include <glib.h>
#ifndef OFF_TARGET
#define strlcat g_strlcat
#define strlcpy g_strlcpy
#else
#define strlcat strncat
#define strlcpy strncpy
#endif
#endif /* USE_GLIB */
#if defined (USE_GLIB) && !defined (USE_ANDROID_LOGGING)
// LE targets with no logcat support
#define TS_PRINTF(format, x...) \
{ \
struct timeval tv; \
struct timezone tz; \
int hh, mm, ss; \
gettimeofday(&tv, &tz); \
hh = tv.tv_sec/3600%24; \
mm = (tv.tv_sec%3600)/60; \
ss = tv.tv_sec%60; \
fprintf(stdout,"%02d:%02d:%02d.%06ld]" format "\n", hh, mm, ss, tv.tv_usec, ##x); \
}
#define ALOGE(format, x...) TS_PRINTF("E/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGW(format, x...) TS_PRINTF("W/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGI(format, x...) TS_PRINTF("I/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGD(format, x...) TS_PRINTF("D/%s (%d): " format , LOG_TAG, getpid(), ##x)
#define ALOGV(format, x...) TS_PRINTF("V/%s (%d): " format , LOG_TAG, getpid(), ##x)
#endif /* #if defined (USE_GLIB) && !defined (USE_ANDROID_LOGGING) */
// Below are the location conf file paths
extern const char LOC_PATH_GPS_CONF[];
extern const char LOC_PATH_IZAT_CONF[];
extern const char LOC_PATH_FLP_CONF[];
extern const char LOC_PATH_LOWI_CONF[];
extern const char LOC_PATH_SAP_CONF[];
extern const char LOC_PATH_APDR_CONF[];
extern const char LOC_PATH_XTWIFI_CONF[];
extern const char LOC_PATH_QUIPC_CONF[];
#ifdef __cplusplus
}
#endif /*__cplusplus */
#endif /* __PLATFORM_LIB_MACROS_H__ */

46
utils/platform_lib_abstractions/loc_pla/include/platform_lib_sched_policy.h
View file

@ -1,46 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __PLATFORM_LIB_SCHED_POLICY_H__
#define __PLATFORM_LIB_SCHED_POLICY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
PLA_SP_BACKGROUND = 0,
PLA_SP_FOREGROUND = 1,
} PLASchedPolicy;
int platform_lib_abstraction_set_sched_policy(int tid, PLASchedPolicy policy);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __PLATFORM_LIB_SCHED_POLICY_H__ */

36
utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h
View file

@ -1,36 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __PLATFORM_LIB_TIME_H__
#define __PLATFORM_LIB_TIME_H__
#include <stdint.h>
int64_t platform_lib_abstraction_elapsed_millis_since_boot();
int64_t platform_lib_abstraction_elapsed_micros_since_boot();
#endif /* __PLATFORM_LIB_TIME_H__ */

10
utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in
View file

@ -1,10 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: loc-pla
Description: QTI GPS Location Platform Library Abstractions
Version: @VERSION@
Libs: -L${libdir} -lloc_pla
Cflags: -I${includedir}/loc-pla -I${includedir}/gps-utils

68
utils/platform_lib_abstractions/loc_pla/src/Android.mk
View file

@ -1,68 +0,0 @@
GNSS_CFLAGS := \
-Werror \
-Wno-error=unused-parameter \
-Wno-error=format \
-Wno-error=macro-redefined \
-Wno-error=reorder \
-Wno-error=missing-braces \
-Wno-error=self-assign \
-Wno-error=enum-conversion \
-Wno-error=logical-op-parentheses \
-Wno-error=null-arithmetic \
-Wno-error=null-conversion \
-Wno-error=parentheses-equality \
-Wno-error=undefined-bool-conversion \
-Wno-error=tautological-compare \
-Wno-error=switch \
-Wno-error=date-time
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
ifneq ($(BUILD_TINY_ANDROID),true)
#Compile this library only for builds with the latest modem image
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
## Libs
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
liblog \
libloc_stub
LOCAL_SRC_FILES += \
platform_lib_gettid.cpp \
platform_lib_log_util.cpp \
platform_lib_property_service.cpp \
platform_lib_sched_policy.cpp \
platform_lib_time.cpp
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_ \
-std=c++11
## Includes
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH)/../include
LOCAL_HEADER_LIBRARIES := \
libgps.utils_headers \
libloc_stub_headers
LOCAL_MODULE := libloc_pla
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_CFLAGS += $(GNSS_CFLAGS)
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_pla_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
include $(BUILD_HEADER_LIBRARY)
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

40
utils/platform_lib_abstractions/loc_pla/src/Makefile.am
View file

@ -1,40 +0,0 @@
AM_CFLAGS = \
$(LOCSTUB_CFLAGS) \
-I$(WORKSPACE)/hardware/qcom/gps/utils/ \
-I../include \
-D__func__=__PRETTY_FUNCTION__ \
-fno-short-enums
h_sources = \
../include/platform_lib_gettid.h \
../include/platform_lib_includes.h \
../include/platform_lib_log_util.h \
../include/platform_lib_macros.h \
../include/platform_lib_property_service.h \
../include/platform_lib_sched_policy.h \
../include/platform_lib_time.h
library_includedir = $(pkgincludedir)
library_include_HEADERS = $(h_sources)
libloc_pla_la_SOURCES = \
platform_lib_gettid.cpp \
platform_lib_log_util.cpp \
platform_lib_property_service.cpp \
platform_lib_sched_policy.cpp \
platform_lib_time.cpp
if USE_GLIB
libloc_pla_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libloc_pla_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_pla_la_CFLAGS = $(AM_CFLAGS)
libloc_pla_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libloc_pla_la_LIBADD = -lstdc++ -ldl -llog $(LOCSTUB_LIBS)
#Create and Install libraries
lib_LTLIBRARIES = libloc_pla.la

46
utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp
View file

@ -1,46 +0,0 @@
/* Copyright (c) 2014, 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 "platform_lib_gettid.h"
#ifdef USE_GLIB
#include <loc_stub_gettid.h>
#include <errno.h>
const char* getprogname() {
return program_invocation_short_name;
}
#else
#include <unistd.h>
#endif /* USE_GLIB */
pid_t platform_lib_abstraction_gettid()
{
return gettid();
}

78
utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp
View file

@ -1,78 +0,0 @@
/* Copyright (c) 2014, 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 "platform_lib_log_util.h"
#include "platform_lib_macros.h"
char * get_timestamp(char *str, unsigned long buf_size)
{
struct timeval tv;
struct timezone tz;
int hh, mm, ss;
gettimeofday(&tv, &tz);
hh = tv.tv_sec/3600%24;
mm = (tv.tv_sec%3600)/60;
ss = tv.tv_sec%60;
snprintf(str, buf_size, "%02d:%02d:%02d.%06ld", hh, mm, ss, tv.tv_usec);
return str;
}
// Below are the location conf file paths
#ifdef __ANDROID__
#define LOC_PATH_GPS_CONF_STR "/vendor/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/vendor/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/vendor/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/vendor/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/vendor/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/vendor/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/vendor/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/vendor/etc/quipc.conf"
#else
#define LOC_PATH_GPS_CONF_STR "/etc/gps.conf"
#define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf"
#define LOC_PATH_FLP_CONF_STR "/etc/flp.conf"
#define LOC_PATH_LOWI_CONF_STR "/etc/lowi.conf"
#define LOC_PATH_SAP_CONF_STR "/etc/sap.conf"
#define LOC_PATH_APDR_CONF_STR "/etc/apdr.conf"
#define LOC_PATH_XTWIFI_CONF_STR "/etc/xtwifi.conf"
#define LOC_PATH_QUIPC_CONF_STR "/etc/quipc.conf"
#endif // __ANDROID__
// Reference below arrays wherever needed to avoid duplicating
// same conf path string over and again in location code.
const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR;
const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR;
const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR;
const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR;
const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR;
const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR;
const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR;
const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR;

39
utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp
View file

@ -1,39 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifdef USE_GLIB
#include <loc_stub_property_service.h>
#else
#include <cutils/properties.h>
#endif /* USE_GLIB */
#include "platform_lib_property_service.h"
int platform_lib_abstraction_property_get(const char *key, char *value, const char *default_value)
{
return property_get(key, value, default_value);
}

41
utils/platform_lib_abstractions/loc_pla/src/platform_lib_sched_policy.cpp
View file

@ -1,41 +0,0 @@
/* Copyright (c) 2014, 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 "platform_lib_sched_policy.h"
#ifdef USE_GLIB
#include <loc_stub_sched_policy.h>
#else
#include <cutils/sched_policy.h>
#endif /* USE_GLIB */
int platform_lib_abstraction_set_sched_policy(int tid, PLASchedPolicy policy)
{
return set_sched_policy(tid, (SchedPolicy)policy);
}

59
utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp
View file

@ -1,59 +0,0 @@
/* Copyright (c) 2014, 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 "platform_lib_time.h"
#ifdef USE_GLIB
#include <loc_stub_time.h>
#else
#include <utils/SystemClock.h>
#include <utils/Timers.h>
#endif /* USE_GLIB */
int64_t platform_lib_abstraction_elapsed_millis_since_boot()
{
#ifdef USE_GLIB
return elapsedMillisSinceBoot();
#else
//return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000;
return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000;
#endif
}
int64_t platform_lib_abstraction_elapsed_micros_since_boot()
{
#ifdef USE_GLIB
return elapsedMicrosSinceBoot();
#else
//return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME));
return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME));
#endif
}

5
utils/platform_lib_abstractions/loc_stub/Android.mk
View file

@ -1,5 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
include $(call all-subdir-makefiles)
endif

9
utils/platform_lib_abstractions/loc_stub/Makefile.am
View file

@ -1,9 +0,0 @@
# Makefile.am for gps loc-stub
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = src
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = loc-stub.pc
EXTRA_DIST = $(pkgconfig_DATA)

45
utils/platform_lib_abstractions/loc_stub/include/loc_stub_android_runtime.h
View file

@ -1,45 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __LOC_STUB_ANDROID_RUNTIME_H__
#define __LOC_STUB_ANDROID_RUNTIME_H__
#include <pthread.h>
namespace android {
class AndroidRuntime
{
public:
/** create a new thread that is visible from Java */
static pthread_t createJavaThread(const char* name, void (*start)(void *),
void* arg);
};
}
#endif /* __LOC_STUB_ANDROID_RUNTIME_H__ */

42
utils/platform_lib_abstractions/loc_stub/include/loc_stub_property_service.h
View file

@ -1,42 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __LOC_STUB_PROPERTY_SERVICE_H__
#define __LOC_STUB_PROPERTY_SERVICE_H__
#ifdef __cplusplus
extern "C" {
#endif
int property_get(const char *key, char *value, const char *default_value);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_PROPERTY_SERVICE_H__ */

64
utils/platform_lib_abstractions/loc_stub/include/loc_stub_sched_policy.h
View file

@ -1,64 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __LOC_STUB_SCHED_POLICY_H__
#define __LOC_STUB_SCHED_POLICY_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
SP_BACKGROUND = 0,
SP_FOREGROUND = 1,
} SchedPolicy;
/*===========================================================================
FUNCTION set_sched_policy
DESCRIPTION
Local copy of this function which bypasses android set_sched_policy
DEPENDENCIES
None
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
int set_sched_policy(int tid, SchedPolicy policy);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_SCHED_POLICY_H__ */

46
utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h
View file

@ -1,46 +0,0 @@
/* Copyright (c) 2014, 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.
*/
#ifndef __LOC_STUB_TIME_H__
#define __LOC_STUB_TIME_H__
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
int64_t systemTime(int clock);
int64_t elapsedMillisSinceBoot();
int64_t elapsedMicrosSinceBoot();
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_STUB_TIME_H__ */

10
utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in
View file

@ -1,10 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: loc-stub
Description: QTI GPS Location Stub
Version: @VERSION
Libs: -L${libdir} -lloc_stub
Cflags: -I${includedir}/loc-stub

49
utils/platform_lib_abstractions/loc_stub/src/Android.mk
View file

@ -1,49 +0,0 @@
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
ifneq ($(BUILD_TINY_ANDROID),true)
#Compile this library only for builds with the latest modem image
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
## Libs
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
liblog
LOCAL_SRC_FILES += \
loc_stub_android_runtime.cpp \
loc_stub_gettid.cpp \
loc_stub_property_service.cpp \
loc_stub_sched_policy.cpp \
loc_stub_time.cpp
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_ \
-std=c++11
LOCAL_LDFLAGS += -Wl,--export-dynamic
## Includes
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH)/../include \
LOCAL_MODULE := libloc_stub
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_CFLAGS += $(GNSS_CFLAGS)
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_stub_headers
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
include $(BUILD_HEADER_LIBRARY)
endif # not BUILD_TINY_ANDROID
endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

40
utils/platform_lib_abstractions/loc_stub/src/Makefile.am
View file

@ -1,40 +0,0 @@
AM_CFLAGS = \
-I../include \
-D__func__=__PRETTY_FUNCTION__ \
-fno-short-enums
libloc_stub_la_extra_h = \
../include/utils/Log.h
libloc_stub_la_c_sources = \
loc_stub_android_runtime.cpp \
loc_stub_gettid.cpp \
loc_stub_property_service.cpp \
loc_stub_sched_policy.cpp \
loc_stub_time.cpp
libloc_stub_la_SOURCES = $(libloc_stub_la_c_sources) $(libloc_stub_la_extra_h)
library_include_HEADERS = \
../include/loc_stub_android_runtime.h \
../include/loc_stub_gettid.h \
../include/loc_stub_property_service.h \
../include/loc_stub_sched_policy.h \
../include/loc_stub_time.h
library_includedir = $(pkgincludedir)
if USE_GLIB
libloc_stub_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libloc_stub_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_stub_la_CFLAGS = $(AM_CFLAGS)
libloc_stub_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libloc_stub_la_LIBADD = -lstdc++ -ldl -llog
#Create and Install libraries
lib_LTLIBRARIES = libloc_stub.la

41
utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp
View file

@ -1,41 +0,0 @@
/* Copyright (c) 2014, 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 "loc_stub_android_runtime.h"
namespace android {
pthread_t AndroidRuntime::createJavaThread(const char* /*name*/,
void (*start)(void *), void* arg)
{
pthread_t threadId = 0;
pthread_create(&threadId, NULL, (void *(*)(void*))start, arg);
return threadId;
}
}

37
utils/platform_lib_abstractions/loc_stub/src/loc_stub_gettid.cpp
View file

@ -1,37 +0,0 @@
/* Copyright (c) 2014, 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 "loc_stub_gettid.h"
#include <sys/syscall.h>
#include <unistd.h>
// Required for off-target environment to compile properly
pid_t gettid(void)
{
return syscall(SYS_gettid);
}

42
utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp
View file

@ -1,42 +0,0 @@
/* Copyright (c) 2014, 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 "loc_stub_property_service.h"
#include <stdio.h>
#include <string.h>
int property_get(const char *key, char * value, const char */*default_value*/)
{
/* This will disable gps interface
value[0] = '1';
*/
if (strcmp(key, "ro.baseband") == 0) {
memcpy(value, "msm", 4);
}
return 0;
}

50
utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp
View file

@ -1,50 +0,0 @@
/* Copyright (c) 2014, 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 "loc_stub_sched_policy.h"
/*===========================================================================
FUNCTION set_sched_policy
DESCRIPTION
Local copy of this function which bypasses android set_sched_policy
DEPENDENCIES
None
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
int set_sched_policy(int /*tid*/, SchedPolicy /*policy*/)
{
return 0;
}

55
utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp
View file

@ -1,55 +0,0 @@
/* Copyright (c) 2014, 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 "loc_stub_time.h"
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
int64_t systemTime(int /*clock*/)
{
struct timespec t;
t.tv_sec = t.tv_nsec = 0;
clock_gettime(CLOCK_MONOTONIC, &t);
return t.tv_sec*1000000LL + t.tv_nsec/1000LL;
}
int64_t elapsedMicrosSinceBoot()
{
struct timespec ts;
int64_t time_ms = 0;
clock_gettime(CLOCK_BOOTTIME, &ts);
time_ms += (ts.tv_sec * 1000000000LL); /* Seconds to nanoseconds */
time_ms += ts.tv_nsec; /* Add Nanoseconds */
return time_ms;
}
int64_t elapsedMillisSinceBoot()
{
return (int64_t) (elapsedMicrosSinceBoot() /1000000LL);
}