samsung_sm8750/android_kernel_samsung_sm8750-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace common qcom sources with samsung ones

Browse Source
This commit is contained in:
SaschaNes
2025-08-12 22:13:00 +02:00
parent ba24dcded9
commit 6f7753de11
5682 changed files with 2450203 additions and 103634 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
qcom/opensource/location/loc-fidl/CMakeLists.txt Normal file
View File

@@ -0,0 +1,3 @@
cmake_minimum_required(VERSION 2.8)
add_subdirectory( src )

176
qcom/opensource/location/loc-fidl/CMakeLists_x86.txt Normal file
View File

@@ -0,0 +1,176 @@
cmake_minimum_required(VERSION 2.8)
set(PRJ_NAME LocationClientAPI)
set(CMAKE_VERBOSE_MAKEFILE on)
OPTION(USE_FILE "Set to OFF to disable file logging" OFF )
message(STATUS "USE_FILE is set to value: ${USE_FILE}")
OPTION(USE_CONSOLE "Set to OFF to disable console logging" OFF )
message(STATUS "USE_CONSOLE is set to value: ${USE_CONSOLE}")
IF(USE_FILE)
add_definitions(-DUSE_FILE)
ENDIF(USE_FILE)
IF(USE_CONSOLE)
add_definitions(-DUSE_CONSOLE)
ENDIF(USE_CONSOLE)
add_definitions(-D__LINUX__)
add_definitions(-DOFF_TARGET)
add_definitions(-std=c++14)
SET(MAX_LOG_LEVEL "DEBUG" CACHE STRING "maximum log level")
message(STATUS "MAX_LOG_LEVEL is set to value: ${MAX_LOG_LEVEL}")
add_definitions(-DCOMMONAPI_LOGLEVEL=COMMONAPI_LOGLEVEL_${MAX_LOG_LEVEL})
if (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
set (OS "QNX")
set (NO_DEPRECATED_REGISTER "")
set (Boost_USE_STATIC_LIBS ON)
endif (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
if (MSVC)
# Visual C++ is not always sure whether he is really C++
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS /EHsc /wd\\\"4503\\\"")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS /wd\\\"4503\\\"")
else()
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP -DQNX")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP")
endif()
message(STATUS "Compiler options: ${CMAKE_CXX_FLAGS}")
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
"Choose the type of build, options are: Debug Release." FORCE)
endif(NOT CMAKE_BUILD_TYPE)
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
OPTION(USE_INSTALLED_COMMONAPI "Set to OFF to use the local (build tree) version of CommonAPI" ON)
message(STATUS "USE_INSTALLED_COMMONAPI is set to value: ${USE_INSTALLED_COMMONAPI}")
if ("${USE_INSTALLED_COMMONAPI}" STREQUAL "ON")
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
else()
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
endif()
message(STATUS "CommonAPI_CONSIDERED_CONFIGS: ${CommonAPI_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_INCLUDE_DIRS: ${COMMONAPI_INCLUDE_DIRS}")
message(STATUS "CommonAPI-DBus_CONSIDERED_CONFIGS: ${CommonAPI-DBus_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_DBUS_INCLUDE_DIRS: ${COMMONAPI_DBUS_INCLUDE_DIRS}")
# CommonAPI
include(FindPkgConfig)
###############################################################################
# find DBus by using the 'pkg-config' tool
if (MSVC)
#Not beautiful, but it works
if (DBus_DIR)
if (DBus_BUILD_DIR)
set(DBus_INCLUDE_DIRS "${DBus_DIR};${DBus_BUILD_DIR};")
else ()
message (FATAL_ERROR "DBus_BUILD_DIR not set! Cannot continue.")
endif ()
else()
message (FATAL_ERROR "DBus_DIR not set! Cannot continue.")
endif ()
else()
# pkg_check_modules(DBus REQUIRED dbus-1>=1.4)
endif()
# SOME/IP
find_package (CommonAPI-SomeIP 3.2.0 REQUIRED)
find_package (vsomeip3 3.1.20 REQUIRED)
# Source Files
set(PRJ_SRC_PATH src)
set(PRJ_SRC_GEN_PATH src-gen)
set(PRJ_SRC_GEN_COMMONAPI_PATH ${PRJ_SRC_GEN_PATH}/core/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_DBUS_PATH ${PRJ_SRC_GEN_PATH}/dbus/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH ${PRJ_SRC_GEN_PATH}/someip/v0/com/qualcomm/qti/location)
set(OFFTARGET_WS_PATH /local/mnt/workspace/nareshm/off-target/08-16-FOR-FIDL/x86_80)
set(PRJ_NAME_CLIENT ${PRJ_NAME}Client)
set(PRJ_NAME_SERVICE ${PRJ_NAME}Service)
# Application
FILE(GLOB PRJ_PROXY_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Proxy.cpp)
FILE(GLOB PRJ_STUB_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Stub*.cpp)
FILE(GLOB PRJ_STUB_IMPL_SRCS ${PRJ_SRC_COMMONAPI_PATH}/*Stub*.cpp)
set(PRJ_CLIENT_SRCS ${PRJ_SRC_PATH}/${PRJ_NAME_CLIENT}.cpp ${PRJ_PROXY_GEN_SRCS})
set(PRJ_SERVICE_SRCS ${PRJ_SRC_PATH}/${PRJ_NAME_SERVICE}.cpp ${PRJ_SRC_PATH}/${PRJ_NAME}StubImpl.cpp ${PRJ_STUB_GEN_SRCS} ${PRJ_STUB_IMPL_SRCS})
# Boost
#find_package( Boost 1.71 COMPONENTS system thread log REQUIRED )
include_directories( ${Boost_INCLUDE_DIR} )
# DBus library
FILE(GLOB PRJ_DBUS_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_DBUS_PATH}/*cpp)
# SOME/IP library
FILE(GLOB PRJ_SOMEIP_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH}/*cpp)
# Paths
OPTION(USE_INSTALLED_DBUS "Set to OFF to use the local (patched) version of dbus" ON)
message(STATUS "USE_INSTALLED_DBUS is set to value: ${USE_INSTALLED_DBUS}")
include_directories(
src-gen/core
# src-gen/dbus
src-gen/someip
${COMMONAPI_INCLUDE_DIRS}
#${COMMONAPI_DBUS_INCLUDE_DIRS}
${COMMONAPI_SOMEIP_INCLUDE_DIRS}
#${DBus_INCLUDE_DIRS}
${VSOMEIP_INCLUDE_DIRS}
${OFFTARGET_WS_PATH}/location/client_api/inc
${OFFTARGET_WS_PATH}/h_q_gps/utils
${OFFTARGET_WS_PATH}/h_q_gps/pla/oe
)
if ("${USE_INSTALLED_DBUS}" STREQUAL "ON")
link_directories(
${COMMONAPI_LIBDIR}
#${COMMONAPI_DBUS_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${Boost_LIBRARY_DIR}
${OFFTARGET_WS_PATH}/gps-internal/location-x86/prebuilts
)
else()
link_directories(
${COMMONAPI_LIBDIR}
#${COMMONAPI_DBUS_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${DBus_INCLUDE_DIRS}/dbus/.libs
${Boost_LIBRARY_DIR}
${OFFTARGET_WS_PATH}/gps-internal/location-x86/prebuilts
)
endif()
if (MSVC)
set(LINK_LIBRARIES CommonAPI location_client_api gps_utils)
else()
set(LINK_LIBRARIES -Wl,--as-needed CommonAPI location_client_api gps_utils)
endif()
# Build Client
add_executable(${PRJ_NAME_CLIENT} ${PRJ_CLIENT_SRCS})
target_link_libraries(${PRJ_NAME_CLIENT} ${LINK_LIBRARIES})
# Build service
add_executable(${PRJ_NAME_SERVICE} ${PRJ_SERVICE_SRCS})
target_link_libraries(${PRJ_NAME_SERVICE} ${LINK_LIBRARIES})
# Build DBus library
#add_library (${PRJ_NAME}-dbus SHARED ${PRJ_DBUS_LIB_SRCS})
#target_link_libraries(${PRJ_NAME}-dbus CommonAPI-DBus)
# Build SOME/IP library
add_library (${PRJ_NAME}-someip SHARED ${PRJ_SOMEIP_LIB_SRCS})
target_link_libraries(${PRJ_NAME}-someip CommonAPI-SomeIP)

234
qcom/opensource/location/loc-fidl/CMakePresets.json Normal file
View File

@@ -0,0 +1,234 @@
{
"version": 1,
"cmakeMinimumRequired": {
"major": 3,
"minor": 19,
"patch": 0
},
"configurePresets": [
{
"name": "unix-makefiles",
"hidden": true,
"generator": "Unix Makefiles",
"description": "Debug build using makefile generator",
"cacheVariables": {
"CMAKE_LINK_WHAT_YOU_USE": true,
"CMAKE_EXPORT_COMPILE_COMMANDS": true,
"CMAKE_MODULE_PATH": "${sourceDir}/CMake/Module",
"CMAKE_VERBOSE_MAKEFILE": true,
"CMAKE_COLOR_MAKEFILE": true,
"Python3_ROOT": "/usr"
}
},
{
"name": "clang9_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with Clang-9 for Linux x86-64",
"binaryDir": "build/clang9_linux_x86_64",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_clang9",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/clang9_linux_x86_64.cmake"
}
}
},
{
"name": "clang11_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with Clang-11 for Linux x86-64",
"binaryDir": "build/clang11_linux_x86_64",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_clang11",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/clang11_linux_x86_64.cmake"
}
}
},
{
"name": "gcc6_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with GCC-6 for Linux x86-64",
"binaryDir": "build/gcc6_linux_x86_64",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_gcc6",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/gcc6_linux_x86_64.cmake"
}
}
},
{
"name": "gcc7_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with GCC-7 for Linux x86-64",
"binaryDir": "build/gcc7_linux_x86_64",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_gcc7",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/gcc7_linux_x86_64.cmake"
}
}
},
{
"name": "gcc7_linux_x86_64_openssl",
"inherits": "gcc7_linux_x86_64",
"description": "Debug build with GCC-7 for Linux x86-64 with OpenSSL enabled",
"cacheVariables": {
"AMSR_ENABLE_X509": "ON"
}
},
{
"name": "gcc9_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with GCC-9 for Linux x86-64",
"binaryDir": "build/gcc9_linux_x86_64",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_gcc9",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/gcc9_linux_x86_64.cmake"
}
}
},
{
"name": "mips2019_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with MIPS-2019 for Linux x86-64",
"binaryDir": "build/mips2019_linux_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_mips2019",
"CMAKE_PREFIX_PATH": "/opt/mips",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/mips2019_linux_x86_64.cmake"
}
}
},
{
"name": "qcc5_qnx7_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with QCC-5 for QNX7 x86-64",
"binaryDir": "build/qcc5_qnx7_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/qnx7_qcc5",
"CMAKE_PREFIX_PATH": "$env{QNX_HOST}/usr",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/qcc5_qnx7_x86_64.cmake"
}
}
},
{
"name": "qcc8_qnx710_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with QCC-8 for QNX7.1 x86-64",
"binaryDir": "build/qcc8_qnx710_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/qnx710_qcc8",
"CMAKE_PREFIX_PATH": "$env{QNX_HOST}/usr",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/qcc8_qnx710_x86_64.cmake"
}
}
},
{
"name": "qcc8_qnx710_aarch64le",
"inherits": "unix-makefiles",
"description": "Debug build with QCC-8 for QNX7.1 aarch64le",
"binaryDir": "build/qcc8_qnx710_aarch64le",
"cacheVariables": {
"CCACHE_ENABLE": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/qnx710_qcc8",
"CMAKE_PREFIX_PATH": "$env{QNX_HOST}/usr",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/qcc8_qnx710_aarch64le.cmake"
}
}
},
{
"name": "qcc8_qnx710_x86_64_openssl",
"inherits": "qcc8_qnx710_x86_64",
"description": "Debug build with QCC-8 for QNX7.1 x86-64 with OpenSSL enabled",
"cacheVariables": {
"AMSR_ENABLE_X509": "ON"
}
},
{
"name": "cafecc_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with cafeCC for Linux x86-64",
"binaryDir": "build/cafecc_linux_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "ON",
"TACO_EXECUTE_TEST": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_cafecc",
"CMAKE_PREFIX_PATH": "/opt/bauhaus-suite",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/cafecc_linux_x86_64.cmake"
}
},
"environment": {
"COMPILE_ONLY": "true",
"BAUHAUS_CONFIG": "${sourceDir}/Infrastructure/bauhaus/bauhaus-config/cafecc_config_linux_gcc7_x86_64"
}
},
{
"name": "vca_linux_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with Vector Code Analyzer for Linux x86-64",
"binaryDir": "build/vca_linux_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "OFF",
"CMAKE_BUILD_TYPE": "Release",
"CMAKE_LINK_WHAT_YOU_USE": false,
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/linux_vca",
"CMAKE_PREFIX_PATH": "/opt/VectorCodeAnalyzer",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/vca_linux_x86_64.cmake"
},
"Python3_ROOT": null
}
},
{
"name": "cafecc_qnx710_x86_64",
"inherits": "unix-makefiles",
"description": "Debug build with cafeCC for QNX7.1 x86-64",
"binaryDir": "build/cafecc_qnx710_x86_64",
"cacheVariables": {
"CCACHE_ENABLE": "ON",
"TACO_EXECUTE_TEST": "OFF",
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install/qnx_cafecc",
"CMAKE_PREFIX_PATH": "/opt/bauhaus-suite",
"CMAKE_TOOLCHAIN_FILE": {
"type": "FILEPATH",
"value": "${sourceDir}/CMake/Toolchain/cafecc_qnx710_x86_64.cmake"
}
},
"environment": {
"COMPILE_ONLY": "true",
"BAUHAUS_CONFIG": "${sourceDir}/Infrastructure/bauhaus/bauhaus-config/cafecc_config_QNX710_x86_64"
}
}
]
}

8
qcom/opensource/location/loc-fidl/commonapi4dbus.ini Normal file
View File

@@ -0,0 +1,8 @@
[default]
binding=dbus
[logging]
console = true
file = ./mylog.log
dlt = false
level = verbose

9
qcom/opensource/location/loc-fidl/commonapi4someip.ini Normal file
View File

@@ -0,0 +1,9 @@
[default]
binding=someip
tp=true
[logging]
console = true
file = ./mylog.log
dlt = false
level = verbose

150
qcom/opensource/location/loc-fidl/fidl/LocIdlAPI-Core.fdepl Normal file
View File

@@ -0,0 +1,150 @@
/** Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause-Clear */
import "platform:/plugin/org.genivi.commonapi.core/deployment/CommonAPI_deployment_spec.fdepl"
import "LocIdlAPI.fidl"
define org.genivi.commonapi.core.deployment for interface com.qualcomm.qti.location.LocIdlAPI {
DefaultEnumBackingType = UInt32
enumeration IDLLocationReportInfoFlagMask {
EnumBackingType = UInt64
}
enumeration IDLGnssMeasurementsMultipathIndicator {
EnumBackingType = UInt32
GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN {
}
GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT{
}
GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT{
}
}
enumeration IDLLocOutputEngineType {
EnumBackingType = UInt32
}
enumeration IDLGnssSvType {
EnumBackingType = UInt32
}
enumeration IDLLocationResponse {
EnumBackingType = UInt32
}
enumeration IDLGnssSignalTypeMask {
EnumBackingType = UInt64
}
enumeration IDLLocationReportPosDataMask {
EnumBackingType = UInt32
}
enumeration IDLLocationReportNavSolutionMask {
EnumBackingType = UInt32
}
enumeration IDLLocationTechnologyMask {
EnumBackingType = UInt32
}
enumeration IDLLocationFlagsMask {
EnumBackingType = UInt32
}
enumeration IDLGnssSvOptionsMask {
EnumBackingType = UInt32
}
enumeration IDLLocationCapabilitiesMask {
EnumBackingType = UInt64
}
enumeration IDLLCALocationInfoFlagMask {
EnumBackingType = UInt64
}
enumeration IDLLocationReliability {
EnumBackingType = UInt32
}
enumeration IDLGnssLocSvSystemEnumType {
EnumBackingType = UInt32
}
enumeration IDLGnssSystemTimeStructTypeFlags {
EnumBackingType = UInt32
}
enumeration IDLGnssGloTimeStructTypeFlags {
EnumBackingType = UInt32
}
enumeration IDLDrCalibrationStatusMask {
EnumBackingType = UInt64
}
enumeration IDLLocReqEngineTypeMask {
EnumBackingType = UInt32
}
enumeration IDLPositioningEngineMask {
EnumBackingType = UInt32
}
enumeration IDLDrSolutionStatusMask {
EnumBackingType = UInt64
}
enumeration IDLGnssDataMask {
EnumBackingType = UInt32
}
enumeration IDLGnssMeasurementsDataFlagsMask {
EnumBackingType = UInt32
}
enumeration IDLGnssMeasurementsStateMask {
EnumBackingType = UInt32
}
enumeration IDLGnssMeasurementsAdrStateMask {
EnumBackingType = UInt32
}
enumeration IDLGnssMeasurementsMultipathIndicator {
EnumBackingType = UInt32
}
enumeration IDLGnssMeasurementsClockFlagsMask {
EnumBackingType = UInt32
}
enumeration IDLLeapSecondSysInfoMask {
EnumBackingType = UInt32
}
enumeration IDLGeofenceBreachTypeMask {
EnumBackingType = UInt32
}
enumeration IDLGnssReportCbInfoMask {
EnumBackingType = UInt32
}
enumeration IDLEngineReportCbMask {
EnumBackingType = UInt32
}
enumeration IDLAidingDataDeletionMask {
EnumBackingType = UInt32
}
enumeration IDLGnssConstellationType {
EnumBackingType = UInt64
}
enumeration MapMatchingFeedbackDataValidity {
EnumBackingType = UInt64
}
}

236
qcom/opensource/location/loc-fidl/fidl/LocIdlAPI-SomeIP.fdepl Normal file
View File

@@ -0,0 +1,236 @@
/** Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause-Clear */
import "platform:/plugin/org.genivi.commonapi.someip/deployment/CommonAPI-4-SOMEIP_deployment_spec.fdepl"
import "LocIdlAPI.fidl"
define org.genivi.commonapi.someip.deployment for interface com.qualcomm.qti.location.LocIdlAPI {
SomeIpServiceID = 60928 /** 0xEE00*/
attribute gnssCapabilitiesMask {
SomeIpGetterID = 3000
SomeIpSetterID = 3001
SomeIpNotifierID = 33010
SomeIpNotifierEventGroups = { 33000 } /*0x80E8*/
SomeIpAttributeReliable = true
}
method startPositionSession:LocationReport {
SomeIpMethodID = 32001 /** 0x7D01 */
SomeIpReliable = true
}
method startPositionSession:engineSpecificLocation {
SomeIpMethodID = 32002 /** 0x7D02 */
SomeIpReliable = true
}
method stopPositionSession {
SomeIpMethodID = 32003 /** 0x7D03 */
}
method deleteAidingData {
SomeIpMethodID = 32004 /** 0x7D04 */
SomeIpReliable = true
}
method configConstellations {
SomeIpMethodID = 32005 /** 0x7D05 */
SomeIpReliable = true
}
method injectMapMatchedFeedbackData {
SomeIpMethodID = 32006 /** 0x7D06 */
SomeIpReliable = true
}
broadcast GnssMeasurements {
SomeIpEventID = 33001 /** 0x80E9 */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast LocationReport {
SomeIpEventID = 33002 /** 0x80EA */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast EngineLocations {
SomeIpEventID = 33003 /** 0x80EB */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast GnssSv {
SomeIpEventID = 33004 /** 0x80EC */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast GnssNmea {
SomeIpEventID = 33005 /** 0x80ED */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast EngineNmea {
SomeIpEventID = 33006 /** 0x80EE */
SomeIpEventGroups = { 33000 }
out {
}
}
broadcast GnssData {
SomeIpEventID = 33007 /** 0x80EF */
SomeIpEventGroups = { 33000 }
out {
}
}
enumeration IDLGnssMeasurementsMultipathIndicator {
SomeIpEnumWidth = 4
IDL_GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN {
}
IDL_GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT{
}
IDL_GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT{
}
}
enumeration IDLLCALocationInfoFlagMask {
SomeIpEnumWidth = 8
}
enumeration IDLLocOutputEngineType {
SomeIpEnumWidth = 4
}
enumeration IDLGnssSvType {
SomeIpEnumWidth = 4
}
enumeration IDLLocationResponse {
SomeIpEnumWidth = 4
}
enumeration IDLGnssSignalTypeMask {
SomeIpEnumWidth = 8
}
enumeration IDLLocationReportPosDataMask {
SomeIpEnumWidth = 4
}
enumeration IDLLocationReportNavSolutionMask {
SomeIpEnumWidth = 4
}
enumeration IDLLocationTechnologyMask {
SomeIpEnumWidth = 4
}
enumeration IDLLocationFlagsMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssSvOptionsMask {
SomeIpEnumWidth = 4
}
enumeration IDLLocationCapabilitiesMask {
SomeIpEnumWidth = 8
}
enumeration IDLLocationReliability {
SomeIpEnumWidth = 4
}
enumeration IDLGnssSvSystemEnumType {
SomeIpEnumWidth = 4
}
enumeration IDLGnssSystemTimeStructTypeFlags {
SomeIpEnumWidth = 4
}
enumeration IDLGnssGloTimeStructTypeFlags {
SomeIpEnumWidth = 4
}
enumeration IDLDrCalibrationStatusMask {
SomeIpEnumWidth = 8
}
enumeration IDLLocReqEngineTypeMask {
SomeIpEnumWidth = 4
}
enumeration IDLPositioningEngineMask {
SomeIpEnumWidth = 4
}
enumeration IDLDrSolutionStatusMask {
SomeIpEnumWidth = 8
}
enumeration IDLGnssDataMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssMeasurementsDataFlagsMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssMeasurementsStateMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssMeasurementsAdrStateMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssMeasurementsMultipathIndicator {
SomeIpEnumWidth = 4
}
enumeration IDLGnssMeasurementsClockFlagsMask {
SomeIpEnumWidth = 4
}
enumeration IDLGnssReportCbInfoMask {
SomeIpEnumWidth = 4
}
enumeration IDLEngineReportCbMask {
SomeIpEnumWidth = 4
}
enumeration IDLLocSessionStatus {
SomeIpEnumWidth = 4
}
enumeration MapMatchingFeedbackDataValidity {
SomeIpEnumWidth = 8
}
}
define org.genivi.commonapi.someip.deployment for provider as Service {
instance com.qualcomm.qti.location.LocIdlAPI {
InstanceId = "com.qualcomm.qti.location.LocIdlAPI"
SomeIpInstanceID = 1 /**Instance 0x01*/
/** Actual entries configured through vsomeip-location.json files */
SomeIpUnicastAddress = "192.168.1.1"
SomeIpReliableUnicastPort = 30499
SomeIpUnreliableUnicastPort = 30499
}
}

2219
qcom/opensource/location/loc-fidl/fidl/LocIdlAPI.fidl Normal file
View File

File diff suppressed because it is too large Load Diff

3445
qcom/opensource/location/loc-fidl/src-gen/core/v0/com/qualcomm/qti/location/LocIdlAPI.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

398
qcom/opensource/location/loc-fidl/src-gen/core/v0/com/qualcomm/qti/location/LocIdlAPIProxy.hpp Normal file
View File

@@ -0,0 +1,398 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.core 3.2.0.v202012010850.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_HPP_
#include <v0/com/qualcomm/qti/location/LocIdlAPIProxyBase.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/AttributeExtension.hpp>
#include <CommonAPI/Factory.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
template <typename ... _AttributeExtensions>
class LocIdlAPIProxy
: virtual public LocIdlAPI,
virtual public LocIdlAPIProxyBase,
virtual public _AttributeExtensions... {
public:
LocIdlAPIProxy(std::shared_ptr<CommonAPI::Proxy> delegate);
~LocIdlAPIProxy();
typedef LocIdlAPI InterfaceType;
/**
* Returns the CommonAPI address of the remote partner this proxy communicates with.
*/
virtual const CommonAPI::Address &getAddress() const;
/**
* Returns true if the remote partner for this proxy is currently known to be available.
*/
virtual bool isAvailable() const;
/**
* Returns true if the remote partner for this proxy is available.
*/
virtual bool isAvailableBlocking() const;
/**
* Returns the wrapper class that is used to (de-)register for notifications about
* the availability of the remote partner of this proxy.
*/
virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent();
/**
* Returns the wrapper class that is used to access version information of the remote
* partner of this proxy.
*/
virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute();
virtual std::future<void> getCompletionFuture();
/**
* Returns the wrapper class that provides access to the attribute gnssCapabilitiesMask.
*/
virtual GnssCapabilitiesMaskAttribute& getGnssCapabilitiesMaskAttribute() {
return delegate_->getGnssCapabilitiesMaskAttribute();
}
/**
* Returns the wrapper class that provides access to the broadcast GnssMeasurements.
*/
virtual GnssMeasurementsEvent& getGnssMeasurementsEvent() {
return delegate_->getGnssMeasurementsEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast LocationReport.
*/
virtual LocationReportEvent& getLocationReportEvent() {
return delegate_->getLocationReportEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast EngineLocations.
*/
virtual EngineLocationsEvent& getEngineLocationsEvent() {
return delegate_->getEngineLocationsEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast GnssSv.
*/
virtual GnssSvEvent& getGnssSvEvent() {
return delegate_->getGnssSvEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast GnssNmea.
*/
virtual GnssNmeaEvent& getGnssNmeaEvent() {
return delegate_->getGnssNmeaEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast EngineNmea.
*/
virtual EngineNmeaEvent& getEngineNmeaEvent() {
return delegate_->getEngineNmeaEvent();
}
/**
* Returns the wrapper class that provides access to the broadcast GnssData.
*/
virtual GnssDataEvent& getGnssDataEvent() {
return delegate_->getGnssDataEvent();
}
/**
* Calls startPositionSession with synchronous semantics.
*
* All const parameters are input parameters to this method.
* All non-const parameters will be filled with the returned values.
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls startPositionSession with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_gnssReportCallbackMask, StartPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls startPositionSession with synchronous semantics.
*
* All const parameters are input parameters to this method.
* All non-const parameters will be filled with the returned values.
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls startPositionSession with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_locReqEngMask, const uint32_t &_engReportCallbackMask, StartPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls stopPositionSession with synchronous semantics.
*
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void stopPositionSession(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls stopPositionSession with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> stopPositionSessionAsync(StopPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls deleteAidingData with synchronous semantics.
*
* All const parameters are input parameters to this method.
* All non-const parameters will be filled with the returned values.
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void deleteAidingData(uint32_t _aidingDataMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls deleteAidingData with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> deleteAidingDataAsync(const uint32_t &_aidingDataMask, DeleteAidingDataAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls configConstellations with synchronous semantics.
*
* All const parameters are input parameters to this method.
* All non-const parameters will be filled with the returned values.
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void configConstellations(std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls configConstellations with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> configConstellationsAsync(const std::vector< LocIdlAPI::IDLGnssSvIdInfo > &_svList, ConfigConstellationsAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls injectMapMatchedFeedbackData with synchronous semantics.
*
* All const parameters are input parameters to this method.
* All non-const parameters will be filled with the returned values.
* The CallStatus will be filled when the method returns and indicate either
* "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
* will be set.
*/
virtual void injectMapMatchedFeedbackData(LocIdlAPI::MapMatchingFeedbackData _mmfData, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr);
/**
* Calls injectMapMatchedFeedbackData with asynchronous semantics.
*
* The provided callback will be called when the reply to this call arrives or
* an error occurs during the call. The CallStatus will indicate either "SUCCESS"
* or which type of error has occurred. In case of any error, ONLY the CallStatus
* will have a defined value.
* The std::future returned by this method will be fulfilled at arrival of the reply.
* It will provide the same value for CallStatus as will be handed to the callback.
*/
virtual std::future<CommonAPI::CallStatus> injectMapMatchedFeedbackDataAsync(const LocIdlAPI::MapMatchingFeedbackData &_mmfData, InjectMapMatchedFeedbackDataAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr);
private:
std::shared_ptr< LocIdlAPIProxyBase> delegate_;
};
typedef LocIdlAPIProxy<> LocIdlAPIProxyDefault;
namespace LocIdlAPIExtensions {
template <template <typename > class _ExtensionType>
class GnssCapabilitiesMaskAttributeExtension {
public:
typedef _ExtensionType< LocIdlAPIProxyBase::GnssCapabilitiesMaskAttribute> extension_type;
static_assert(std::is_base_of<typename CommonAPI::AttributeExtension< LocIdlAPIProxyBase::GnssCapabilitiesMaskAttribute>, extension_type>::value,
"Not CommonAPI Attribute Extension!");
GnssCapabilitiesMaskAttributeExtension(LocIdlAPIProxyBase& proxy): attributeExtension_(proxy.getGnssCapabilitiesMaskAttribute()) {
}
inline extension_type& getGnssCapabilitiesMaskAttributeExtension() {
return attributeExtension_;
}
private:
extension_type attributeExtension_;
};
} // namespace LocIdlAPIExtensions
//
// LocIdlAPIProxy Implementation
//
template <typename ... _AttributeExtensions>
LocIdlAPIProxy<_AttributeExtensions...>::LocIdlAPIProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
_AttributeExtensions(*(std::dynamic_pointer_cast< LocIdlAPIProxyBase>(delegate)))...,
delegate_(std::dynamic_pointer_cast< LocIdlAPIProxyBase>(delegate)) {
}
template <typename ... _AttributeExtensions>
LocIdlAPIProxy<_AttributeExtensions...>::~LocIdlAPIProxy() {
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::startPositionSession(uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
delegate_->startPositionSession(_intervalInMs, _gnssReportCallbackMask, _internalCallStatus, _resp, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_gnssReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->startPositionSessionAsync(_intervalInMs, _gnssReportCallbackMask, _callback, _info);
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::startPositionSession(uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
delegate_->startPositionSession(_intervalInMs, _locReqEngMask, _engReportCallbackMask, _internalCallStatus, _resp, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_locReqEngMask, const uint32_t &_engReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->startPositionSessionAsync(_intervalInMs, _locReqEngMask, _engReportCallbackMask, _callback, _info);
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::stopPositionSession(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
delegate_->stopPositionSession(_internalCallStatus, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::stopPositionSessionAsync(StopPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->stopPositionSessionAsync(_callback, _info);
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::deleteAidingData(uint32_t _aidingDataMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
delegate_->deleteAidingData(_aidingDataMask, _internalCallStatus, _resp, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::deleteAidingDataAsync(const uint32_t &_aidingDataMask, DeleteAidingDataAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->deleteAidingDataAsync(_aidingDataMask, _callback, _info);
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::configConstellations(std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
delegate_->configConstellations(_svList, _internalCallStatus, _resp, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::configConstellationsAsync(const std::vector< LocIdlAPI::IDLGnssSvIdInfo > &_svList, ConfigConstellationsAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->configConstellationsAsync(_svList, _callback, _info);
}
template <typename ... _AttributeExtensions>
void LocIdlAPIProxy<_AttributeExtensions...>::injectMapMatchedFeedbackData(LocIdlAPI::MapMatchingFeedbackData _mmfData, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
delegate_->injectMapMatchedFeedbackData(_mmfData, _internalCallStatus, _resp, _info);
}
template <typename ... _AttributeExtensions>
std::future<CommonAPI::CallStatus> LocIdlAPIProxy<_AttributeExtensions...>::injectMapMatchedFeedbackDataAsync(const LocIdlAPI::MapMatchingFeedbackData &_mmfData, InjectMapMatchedFeedbackDataAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return delegate_->injectMapMatchedFeedbackDataAsync(_mmfData, _callback, _info);
}
template <typename ... _AttributeExtensions>
const CommonAPI::Address &LocIdlAPIProxy<_AttributeExtensions...>::getAddress() const {
return delegate_->getAddress();
}
template <typename ... _AttributeExtensions>
bool LocIdlAPIProxy<_AttributeExtensions...>::isAvailable() const {
return delegate_->isAvailable();
}
template <typename ... _AttributeExtensions>
bool LocIdlAPIProxy<_AttributeExtensions...>::isAvailableBlocking() const {
return delegate_->isAvailableBlocking();
}
template <typename ... _AttributeExtensions>
CommonAPI::ProxyStatusEvent& LocIdlAPIProxy<_AttributeExtensions...>::getProxyStatusEvent() {
return delegate_->getProxyStatusEvent();
}
template <typename ... _AttributeExtensions>
CommonAPI::InterfaceVersionAttribute& LocIdlAPIProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() {
return delegate_->getInterfaceVersionAttribute();
}
template <typename ... _AttributeExtensions>
std::future<void> LocIdlAPIProxy<_AttributeExtensions...>::getCompletionFuture() {
return delegate_->getCompletionFuture();
}
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
namespace CommonAPI {
template<template<typename > class _AttributeExtension>
struct DefaultAttributeProxyHelper< ::v0::com::qualcomm::qti::location::LocIdlAPIProxy,
_AttributeExtension> {
typedef typename ::v0::com::qualcomm::qti::location::LocIdlAPIProxy<
::v0::com::qualcomm::qti::location::LocIdlAPIExtensions::GnssCapabilitiesMaskAttributeExtension<_AttributeExtension>
> class_t;
};
}
// Compatibility
namespace v0_2 = v0;
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_HPP_

112
qcom/opensource/location/loc-fidl/src-gen/core/v0/com/qualcomm/qti/location/LocIdlAPIProxyBase.hpp Normal file
View File

@@ -0,0 +1,112 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.core 3.2.0.v202012010850.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_BASE_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_BASE_HPP_
#include <v0/com/qualcomm/qti/location/LocIdlAPI.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/Deployment.hpp>
#include <CommonAPI/InputStream.hpp>
#include <CommonAPI/OutputStream.hpp>
#include <CommonAPI/Struct.hpp>
#include <cstdint>
#include <vector>
#include <CommonAPI/Attribute.hpp>
#include <CommonAPI/Event.hpp>
#include <CommonAPI/Proxy.hpp>
#include <functional>
#include <future>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
class LocIdlAPIProxyBase
: virtual public CommonAPI::Proxy {
public:
typedef CommonAPI::ObservableAttribute<uint32_t> GnssCapabilitiesMaskAttribute;
typedef CommonAPI::Event<
::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements
> GnssMeasurementsEvent;
typedef CommonAPI::Event<
::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport
> LocationReportEvent;
typedef CommonAPI::Event<
std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport >
> EngineLocationsEvent;
typedef CommonAPI::Event<
std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv >
> GnssSvEvent;
typedef CommonAPI::Event<
uint64_t, std::string
> GnssNmeaEvent;
typedef CommonAPI::Event<
::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType, uint64_t, std::string
> EngineNmeaEvent;
typedef CommonAPI::Event<
::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData
> GnssDataEvent;
typedef std::function<void(const CommonAPI::CallStatus&, const LocIdlAPI::IDLLocationResponse&)> StartPositionSessionAsyncCallback;
typedef std::function<void(const CommonAPI::CallStatus&)> StopPositionSessionAsyncCallback;
typedef std::function<void(const CommonAPI::CallStatus&, const LocIdlAPI::IDLLocationResponse&)> DeleteAidingDataAsyncCallback;
typedef std::function<void(const CommonAPI::CallStatus&, const LocIdlAPI::IDLLocationResponse&)> ConfigConstellationsAsyncCallback;
typedef std::function<void(const CommonAPI::CallStatus&, const LocIdlAPI::IDLLocationResponse&)> InjectMapMatchedFeedbackDataAsyncCallback;
virtual GnssCapabilitiesMaskAttribute& getGnssCapabilitiesMaskAttribute() = 0;
virtual GnssMeasurementsEvent& getGnssMeasurementsEvent() = 0;
virtual LocationReportEvent& getLocationReportEvent() = 0;
virtual EngineLocationsEvent& getEngineLocationsEvent() = 0;
virtual GnssSvEvent& getGnssSvEvent() = 0;
virtual GnssNmeaEvent& getGnssNmeaEvent() = 0;
virtual EngineNmeaEvent& getEngineNmeaEvent() = 0;
virtual GnssDataEvent& getGnssDataEvent() = 0;
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_gnssReportCallbackMask, StartPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_locReqEngMask, const uint32_t &_engReportCallbackMask, StartPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual void stopPositionSession(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> stopPositionSessionAsync(StopPositionSessionAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual void deleteAidingData(uint32_t _aidingDataMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> deleteAidingDataAsync(const uint32_t &_aidingDataMask, DeleteAidingDataAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual void configConstellations(std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> configConstellationsAsync(const std::vector< LocIdlAPI::IDLGnssSvIdInfo > &_svList, ConfigConstellationsAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual void injectMapMatchedFeedbackData(LocIdlAPI::MapMatchingFeedbackData _mmfData, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<CommonAPI::CallStatus> injectMapMatchedFeedbackDataAsync(const LocIdlAPI::MapMatchingFeedbackData &_mmfData, InjectMapMatchedFeedbackDataAsyncCallback _callback = nullptr, const CommonAPI::CallInfo *_info = nullptr) = 0;
virtual std::future<void> getCompletionFuture() = 0;
};
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
// Compatibility
namespace v0_2 = v0;
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_PROXY_BASE_HPP_

256
qcom/opensource/location/loc-fidl/src-gen/core/v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp Normal file
View File

@@ -0,0 +1,256 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.core 3.2.0.v202012010850.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_HPP_
#include <functional>
#include <sstream>
#include <v0/com/qualcomm/qti/location/LocIdlAPI.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/Deployment.hpp>
#include <CommonAPI/InputStream.hpp>
#include <CommonAPI/OutputStream.hpp>
#include <CommonAPI/Struct.hpp>
#include <cstdint>
#include <unordered_set>
#include <vector>
#include <mutex>
#include <CommonAPI/Stub.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
/**
* Receives messages from remote and handles all dispatching of deserialized calls
* to a stub for the service LocIdlAPI. Also provides means to send broadcasts
* and attribute-changed-notifications of observable attributes as defined by this service.
* An application developer should not need to bother with this class.
*/
class LocIdlAPIStubAdapter
: public virtual CommonAPI::StubAdapter,
public virtual LocIdlAPI {
public:
///Notifies all remote listeners about a change of value of the attribute gnssCapabilitiesMask.
virtual void fireGnssCapabilitiesMaskAttributeChanged(const uint32_t &gnssCapabilitiesMask) = 0;
/**
* Sends a broadcast event for GnssMeasurements. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireGnssMeasurementsEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements &_gnssMeasurements) = 0;
/**
* Sends a broadcast event for LocationReport. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireLocationReportEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport &_locationReport) = 0;
/**
* Sends a broadcast event for EngineLocations. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireEngineLocationsEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport > &_engLocations) = 0;
/**
* Sends a broadcast event for GnssSv. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireGnssSvEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv > &_gnssSvs) = 0;
/**
* Sends a broadcast event for GnssNmea. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireGnssNmeaEvent(const uint64_t &_timestamp, const std::string &_nmea) = 0;
/**
* Sends a broadcast event for EngineNmea. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireEngineNmeaEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType &_engType, const uint64_t &_timestamp, const std::string &_nmea) = 0;
/**
* Sends a broadcast event for GnssData. Should not be called directly.
* Instead, the "fire<broadcastName>Event" methods of the stub should be used.
*/
virtual void fireGnssDataEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData &_gnssData) = 0;
virtual void deactivateManagedInstances() = 0;
void lockGnssCapabilitiesMaskAttribute(bool _lockAccess) {
if (_lockAccess) {
gnssCapabilitiesMaskMutex_.lock();
} else {
gnssCapabilitiesMaskMutex_.unlock();
}
}
protected:
/**
* Defines properties for storing the ClientIds of clients / proxies that have
* subscribed to the selective broadcasts
*/
std::recursive_mutex gnssCapabilitiesMaskMutex_;
};
/**
* Defines the necessary callbacks to handle remote set events related to the attributes
* defined in the IDL description for LocIdlAPI.
* For each attribute two callbacks are defined:
* - a verification callback that allows to verify the requested value and to prevent setting
* e.g. an invalid value ("onRemoteSet<AttributeName>").
* - an action callback to do local work after the attribute value has been changed
* ("onRemote<AttributeName>Changed").
*
* This class and the one below are the ones an application developer needs to have
* a look at if he wants to implement a service.
*/
class LocIdlAPIStubRemoteEvent
{
public:
virtual ~LocIdlAPIStubRemoteEvent() { }
/// Verification callback for remote set requests on the attribute gnssCapabilitiesMask
virtual bool onRemoteSetGnssCapabilitiesMaskAttribute(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _value) = 0;
/// Action callback for remote set requests on the attribute gnssCapabilitiesMask
virtual void onRemoteGnssCapabilitiesMaskAttributeChanged() = 0;
};
/**
* Defines the interface that must be implemented by any class that should provide
* the service LocIdlAPI to remote clients.
* This class and the one above are the ones an application developer needs to have
* a look at if he wants to implement a service.
*/
class LocIdlAPIStub
: public virtual CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>
{
public:
typedef std::function<void (LocIdlAPI::IDLLocationResponse _resp)> startPositionSessionReply_t;
typedef std::function<void (LocIdlAPI::IDLLocationResponse _resp)> startPositionSession1Reply_t;
typedef std::function<void ()> stopPositionSessionReply_t;
typedef std::function<void (LocIdlAPI::IDLLocationResponse _resp)> deleteAidingDataReply_t;
typedef std::function<void (LocIdlAPI::IDLLocationResponse _resp)> configConstellationsReply_t;
typedef std::function<void (LocIdlAPI::IDLLocationResponse _resp)> injectMapMatchedFeedbackDataReply_t;
virtual ~LocIdlAPIStub() {}
void lockInterfaceVersionAttribute(bool _lockAccess) { static_cast<void>(_lockAccess); }
bool hasElement(const uint32_t _id) const {
return (_id < 14);
}
virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> _client) = 0;
/// Provides getter access to the attribute gnssCapabilitiesMask
virtual const uint32_t &getGnssCapabilitiesMaskAttribute(const std::shared_ptr<CommonAPI::ClientId> _client) = 0;
/// sets attribute with the given value and propagates it to the adapter
virtual void fireGnssCapabilitiesMaskAttributeChanged(uint32_t _value) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireGnssCapabilitiesMaskAttributeChanged(_value);
}
void lockGnssCapabilitiesMaskAttribute(bool _lockAccess) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->lockGnssCapabilitiesMaskAttribute(_lockAccess);
}
/// Sends a broadcast event for GnssMeasurements.
virtual void fireGnssMeasurementsEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements &_gnssMeasurements) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireGnssMeasurementsEvent(_gnssMeasurements);
}
/// Sends a broadcast event for LocationReport.
virtual void fireLocationReportEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport &_locationReport) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireLocationReportEvent(_locationReport);
}
/// Sends a broadcast event for EngineLocations.
virtual void fireEngineLocationsEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport > &_engLocations) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireEngineLocationsEvent(_engLocations);
}
/// Sends a broadcast event for GnssSv.
virtual void fireGnssSvEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv > &_gnssSvs) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireGnssSvEvent(_gnssSvs);
}
/// Sends a broadcast event for GnssNmea.
virtual void fireGnssNmeaEvent(const uint64_t &_timestamp, const std::string &_nmea) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireGnssNmeaEvent(_timestamp, _nmea);
}
/// Sends a broadcast event for EngineNmea.
virtual void fireEngineNmeaEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType &_engType, const uint64_t &_timestamp, const std::string &_nmea) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireEngineNmeaEvent(_engType, _timestamp, _nmea);
}
/// Sends a broadcast event for GnssData.
virtual void fireGnssDataEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData &_gnssData) {
auto stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if (stubAdapter)
stubAdapter->fireGnssDataEvent(_gnssData);
}
/// This is the method that will be called on remote calls on the method startPositionSession.
virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, startPositionSessionReply_t _reply) = 0;
/// This is the method that will be called on remote calls on the method startPositionSession.
virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, startPositionSession1Reply_t _reply) = 0;
/// This is the method that will be called on remote calls on the method stopPositionSession.
virtual void stopPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, stopPositionSessionReply_t _reply) = 0;
/// This is the method that will be called on remote calls on the method deleteAidingData.
virtual void deleteAidingData(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _aidingDataMask, deleteAidingDataReply_t _reply) = 0;
/// This is the method that will be called on remote calls on the method configConstellations.
virtual void configConstellations(const std::shared_ptr<CommonAPI::ClientId> _client, std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, configConstellationsReply_t _reply) = 0;
/// This is the method that will be called on remote calls on the method injectMapMatchedFeedbackData.
virtual void injectMapMatchedFeedbackData(const std::shared_ptr<CommonAPI::ClientId> _client, LocIdlAPI::MapMatchingFeedbackData _mmfData, injectMapMatchedFeedbackDataReply_t _reply) = 0;
using CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::initStubAdapter;
typedef CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::StubAdapterType StubAdapterType;
typedef CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType;
typedef LocIdlAPIStubRemoteEvent RemoteEventType;
typedef LocIdlAPI StubInterface;
virtual LocIdlAPIStubRemoteEvent* initStubAdapter(const std::shared_ptr<LocIdlAPIStubAdapter> &_stubAdapter){
CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_ = _stubAdapter;
return mspLocIdlAPIStubRemoteEvent.get();
}
private:
std::shared_ptr<LocIdlAPIStubRemoteEvent> mspLocIdlAPIStubRemoteEvent;
};
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
// Compatibility
namespace v0_2 = v0;
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_HPP_

232
qcom/opensource/location/loc-fidl/src-gen/core/v0/com/qualcomm/qti/location/LocIdlAPIStubDefault.hpp Normal file
View File

@@ -0,0 +1,232 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.core 3.2.0.v202012010850.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_DEFAULT_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_DEFAULT_HPP_
#include <CommonAPI/Export.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
#include <cassert>
#include <sstream>
# if defined(_MSC_VER)
# if _MSC_VER >= 1300
/*
* Diamond inheritance is used for the CommonAPI::Proxy base class.
* The Microsoft compiler put warning (C4250) using a desired c++ feature: "Delegating to a sister class"
* A powerful technique that arises from using virtual inheritance is to delegate a method from a class in another class
* by using a common abstract base class. This is also called cross delegation.
*/
# pragma warning( disable : 4250 )
# endif
# endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
/**
* Provides a default implementation for LocIdlAPIStubRemoteEvent and
* LocIdlAPIStub. Method callbacks have an empty implementation,
* remote set calls on attributes will always change the value of the attribute
* to the one received.
*
* Override this stub if you only want to provide a subset of the functionality
* that would be defined for this service, and/or if you do not need any non-default
* behaviour.
*/
class COMMONAPI_EXPORT_CLASS_EXPLICIT LocIdlAPIStubDefault
: public virtual LocIdlAPIStub {
public:
COMMONAPI_EXPORT LocIdlAPIStubDefault()
: remoteEventHandler_(this),
interfaceVersion_(LocIdlAPI::getInterfaceVersion()) {
}
COMMONAPI_EXPORT const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> _client) {
(void)_client;
return interfaceVersion_;
}
COMMONAPI_EXPORT LocIdlAPIStubRemoteEvent* initStubAdapter(const std::shared_ptr< LocIdlAPIStubAdapter> &_adapter) {
CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_ = _adapter;
return &remoteEventHandler_;
}
COMMONAPI_EXPORT virtual const uint32_t &getGnssCapabilitiesMaskAttribute() {
return gnssCapabilitiesMaskAttributeValue_;
}
COMMONAPI_EXPORT virtual const uint32_t &getGnssCapabilitiesMaskAttribute(const std::shared_ptr<CommonAPI::ClientId> _client) {
(void)_client;
return getGnssCapabilitiesMaskAttribute();
}
COMMONAPI_EXPORT virtual void setGnssCapabilitiesMaskAttribute(uint32_t _value) {
const bool valueChanged = trySetGnssCapabilitiesMaskAttribute(std::move(_value));
if (valueChanged) {
fireGnssCapabilitiesMaskAttributeChanged(gnssCapabilitiesMaskAttributeValue_);
}
}
COMMONAPI_EXPORT virtual void setGnssCapabilitiesMaskAttribute(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _value) {
(void)_client;
setGnssCapabilitiesMaskAttribute(_value);
}
COMMONAPI_EXPORT virtual void fireGnssMeasurementsEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements &_gnssMeasurements) {
LocIdlAPIStub::fireGnssMeasurementsEvent(_gnssMeasurements);
}
COMMONAPI_EXPORT virtual void fireLocationReportEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport &_locationReport) {
LocIdlAPIStub::fireLocationReportEvent(_locationReport);
}
COMMONAPI_EXPORT virtual void fireEngineLocationsEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport > &_engLocations) {
LocIdlAPIStub::fireEngineLocationsEvent(_engLocations);
}
COMMONAPI_EXPORT virtual void fireGnssSvEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv > &_gnssSvs) {
LocIdlAPIStub::fireGnssSvEvent(_gnssSvs);
}
COMMONAPI_EXPORT virtual void fireGnssNmeaEvent(const uint64_t &_timestamp, const std::string &_nmea) {
LocIdlAPIStub::fireGnssNmeaEvent(_timestamp, _nmea);
}
COMMONAPI_EXPORT virtual void fireEngineNmeaEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType &_engType, const uint64_t &_timestamp, const std::string &_nmea) {
if (!_engType.validate()) {
return;
}
LocIdlAPIStub::fireEngineNmeaEvent(_engType, _timestamp, _nmea);
}
COMMONAPI_EXPORT virtual void fireGnssDataEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData &_gnssData) {
LocIdlAPIStub::fireGnssDataEvent(_gnssData);
}
COMMONAPI_EXPORT virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, startPositionSessionReply_t _reply) {
(void)_client;
(void)_intervalInMs;
(void)_gnssReportCallbackMask;
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
if (!resp.validate()) {
return;
}
_reply(resp);
}
COMMONAPI_EXPORT virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, startPositionSession1Reply_t _reply) {
(void)_client;
(void)_intervalInMs;
(void)_locReqEngMask;
(void)_engReportCallbackMask;
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
if (!resp.validate()) {
return;
}
_reply(resp);
}
COMMONAPI_EXPORT virtual void stopPositionSession(const std::shared_ptr<CommonAPI::ClientId> _client, stopPositionSessionReply_t _reply) {
(void)_client;
_reply();
}
COMMONAPI_EXPORT virtual void deleteAidingData(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _aidingDataMask, deleteAidingDataReply_t _reply) {
(void)_client;
(void)_aidingDataMask;
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
if (!resp.validate()) {
return;
}
_reply(resp);
}
COMMONAPI_EXPORT virtual void configConstellations(const std::shared_ptr<CommonAPI::ClientId> _client, std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, configConstellationsReply_t _reply) {
(void)_client;
(void)_svList;
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
if (!resp.validate()) {
return;
}
_reply(resp);
}
COMMONAPI_EXPORT virtual void injectMapMatchedFeedbackData(const std::shared_ptr<CommonAPI::ClientId> _client, LocIdlAPI::MapMatchingFeedbackData _mmfData, injectMapMatchedFeedbackDataReply_t _reply) {
(void)_client;
(void)_mmfData;
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
if (!resp.validate()) {
return;
}
_reply(resp);
}
protected:
COMMONAPI_EXPORT virtual bool trySetGnssCapabilitiesMaskAttribute(uint32_t _value) {
if (!validateGnssCapabilitiesMaskAttributeRequestedValue(_value))
return false;
bool valueChanged;
std::shared_ptr<LocIdlAPIStubAdapter> stubAdapter = CommonAPI::Stub<LocIdlAPIStubAdapter, LocIdlAPIStubRemoteEvent>::stubAdapter_.lock();
if(stubAdapter) {
stubAdapter->lockGnssCapabilitiesMaskAttribute(true);
valueChanged = (gnssCapabilitiesMaskAttributeValue_ != _value);
gnssCapabilitiesMaskAttributeValue_ = std::move(_value);
stubAdapter->lockGnssCapabilitiesMaskAttribute(false);
} else {
valueChanged = (gnssCapabilitiesMaskAttributeValue_ != _value);
gnssCapabilitiesMaskAttributeValue_ = std::move(_value);
}
return valueChanged;
}
COMMONAPI_EXPORT virtual bool validateGnssCapabilitiesMaskAttributeRequestedValue(const uint32_t &_value) {
(void)_value;
return true;
}
COMMONAPI_EXPORT virtual void onRemoteGnssCapabilitiesMaskAttributeChanged() {
// No operation in default
}
class COMMONAPI_EXPORT_CLASS_EXPLICIT RemoteEventHandler: public virtual LocIdlAPIStubRemoteEvent {
public:
COMMONAPI_EXPORT RemoteEventHandler(LocIdlAPIStubDefault *_defaultStub)
:
defaultStub_(_defaultStub) {
}
COMMONAPI_EXPORT virtual void onRemoteGnssCapabilitiesMaskAttributeChanged() {
assert(defaultStub_ !=NULL);
defaultStub_->onRemoteGnssCapabilitiesMaskAttributeChanged();
}
COMMONAPI_EXPORT virtual bool onRemoteSetGnssCapabilitiesMaskAttribute(uint32_t _value) {
assert(defaultStub_ !=NULL);
return defaultStub_->trySetGnssCapabilitiesMaskAttribute(std::move(_value));
}
COMMONAPI_EXPORT virtual bool onRemoteSetGnssCapabilitiesMaskAttribute(const std::shared_ptr<CommonAPI::ClientId> _client, uint32_t _value) {
(void)_client;
return onRemoteSetGnssCapabilitiesMaskAttribute(_value);
}
private:
LocIdlAPIStubDefault *defaultStub_;
};
protected:
LocIdlAPIStubDefault::RemoteEventHandler remoteEventHandler_;
private:
uint32_t gnssCapabilitiesMaskAttributeValue_ {};
CommonAPI::Version interfaceVersion_;
};
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
// Compatibility
namespace v0_2 = v0;
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_STUB_DEFAULT

69
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPDeployment.cpp Normal file
View File

@@ -0,0 +1,69 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#include <v0/com/qualcomm/qti/location/LocIdlAPISomeIPDeployment.hpp>
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
namespace LocIdlAPI_ {
// Type-specific deployments
IDLGnssReportCbInfoMaskDeployment_t IDLGnssReportCbInfoMaskDeployment(32, false);
IDLEngineReportCbMaskDeployment_t IDLEngineReportCbMaskDeployment(32, false);
IDLLocationCapabilitiesMaskDeployment_t IDLLocationCapabilitiesMaskDeployment(64, false);
IDLGnssSvOptionsMaskDeployment_t IDLGnssSvOptionsMaskDeployment(32, false);
IDLLocationFlagsMaskDeployment_t IDLLocationFlagsMaskDeployment(32, false);
IDLLocationTechnologyMaskDeployment_t IDLLocationTechnologyMaskDeployment(32, false);
IDLLocationReportNavSolutionMaskDeployment_t IDLLocationReportNavSolutionMaskDeployment(32, false);
IDLLocationReportPosDataMaskDeployment_t IDLLocationReportPosDataMaskDeployment(32, false);
IDLGnssSignalTypeMaskDeployment_t IDLGnssSignalTypeMaskDeployment(64, false);
IDLLocationResponseDeployment_t IDLLocationResponseDeployment(32, false);
IDLGnssSvTypeDeployment_t IDLGnssSvTypeDeployment(32, false);
IDLLCALocationInfoFlagMaskDeployment_t IDLLCALocationInfoFlagMaskDeployment(64, false);
IDLLocationReliabilityDeployment_t IDLLocationReliabilityDeployment(32, false);
IDLGnssSvSystemEnumTypeDeployment_t IDLGnssSvSystemEnumTypeDeployment(32, false);
IDLGnssSystemTimeStructTypeFlagsDeployment_t IDLGnssSystemTimeStructTypeFlagsDeployment(32, false);
IDLGnssGloTimeStructTypeFlagsDeployment_t IDLGnssGloTimeStructTypeFlagsDeployment(32, false);
IDLDrCalibrationStatusMaskDeployment_t IDLDrCalibrationStatusMaskDeployment(64, false);
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSystemTimeDeployment_t IDLGnssSystemTimeDeployment(0, &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvSystemEnumTypeDeployment, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLSystemTimeStructUnionDeployment_t* >(nullptr));
IDLLocReqEngineTypeMaskDeployment_t IDLLocReqEngineTypeMaskDeployment(32, false);
IDLLocOutputEngineTypeDeployment_t IDLLocOutputEngineTypeDeployment(32, false);
IDLPositioningEngineMaskDeployment_t IDLPositioningEngineMaskDeployment(32, false);
IDLDrSolutionStatusMaskDeployment_t IDLDrSolutionStatusMaskDeployment(64, false);
IDLLocSessionStatusDeployment_t IDLLocSessionStatusDeployment(32, false);
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t IDLLocationReportDeployment(0, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationDeployment_t* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint16_t>* >(nullptr), static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportSvUsedInPositionDeployment_t* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportPositionDynamicsDeployment_t* >(nullptr), &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSystemTimeDeployment, static_cast< CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasUsageInfoDeployment_t >* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint8_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint8_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLLAInfoDeployment_t* >(nullptr), static_cast< CommonAPI::SomeIP::ArrayDeployment< CommonAPI::EmptyDeployment >* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::ArrayDeployment< CommonAPI::SomeIP::IntegerDeployment<uint16_t> >* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<int16_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint8_t>* >(nullptr));
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t IDLGnssSvDeployment(0, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint16_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint16_t>* >(nullptr), &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvTypeDeployment, static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr));
IDLGnssDataMaskDeployment_t IDLGnssDataMaskDeployment(32, false);
IDLGnssMeasurementsDataFlagsMaskDeployment_t IDLGnssMeasurementsDataFlagsMaskDeployment(32, false);
IDLGnssMeasurementsStateMaskDeployment_t IDLGnssMeasurementsStateMaskDeployment(32, false);
IDLGnssMeasurementsAdrStateMaskDeployment_t IDLGnssMeasurementsAdrStateMaskDeployment(32, false);
IDLGnssMeasurementsMultipathIndicatorDeployment_t IDLGnssMeasurementsMultipathIndicatorDeployment(32, false);
IDLGnssMeasurementsClockFlagsMaskDeployment_t IDLGnssMeasurementsClockFlagsMaskDeployment(32, false);
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDataDeployment_t IDLGnssMeasurementsDataDeployment(0, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint16_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint8_t>* >(nullptr), &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvTypeDeployment, static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<int64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<int64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<int64_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::EmptyDeployment* >(nullptr));
CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDataDeployment_t > IDLGnssMeasurements_measurementsDeployment(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDataDeployment, 0, 0, 4);
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment_t IDLGnssMeasurementsDeployment(0, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsClockDeployment_t* >(nullptr), &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurements_measurementsDeployment, static_cast< CommonAPI::EmptyDeployment* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<int16_t>* >(nullptr));
MapMatchingFeedbackDataValidityDeployment_t MapMatchingFeedbackDataValidityDeployment(64, false);
// Attribute-specific deployments
// Argument-specific deployment
// Broadcast-specific deployments
CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t > EngineLocations_engLocationsDeployment(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment, 0, 0, 4);
CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t > GnssSv_gnssSvsDeployment(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment, 0, 0, 4);
} // namespace LocIdlAPI_
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0

613
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPDeployment.hpp Normal file
View File

@@ -0,0 +1,613 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_SOMEIP_DEPLOYMENT_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_SOMEIP_DEPLOYMENT_HPP_
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/SomeIP/Deployment.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
namespace LocIdlAPI_ {
// Interface-specific deployment types
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssReportCbInfoMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLEngineReportCbMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationCapabilitiesMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSvOptionsMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationFlagsMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationTechnologyMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationReportNavSolutionMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationReportPosDataMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSignalTypeMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationResponseDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSvTypeDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLCALocationInfoFlagMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocationReliabilityDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSvSystemEnumTypeDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSystemTimeStructTypeFlagsDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssGloTimeStructTypeFlagsDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLDrCalibrationStatusMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocReqEngineTypeMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocOutputEngineTypeDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLPositioningEngineMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLDrSolutionStatusMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLLocSessionStatusDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssSignalTypesDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssDataMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssMeasurementsDataFlagsMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssMeasurementsStateMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssMeasurementsAdrStateMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssMeasurementsMultipathIndicatorDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssMeasurementsClockFlagsMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLAidingDataDeletionMaskDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> IDLGnssConstellationTypeDeployment_t;
typedef CommonAPI::SomeIP::EnumerationDeployment<uint8_t> MapMatchingFeedbackDataValidityDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>
> IDLLocationReportSvUsedInPositionDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> IDLGnssMeasUsageInfoDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
> IDLLocationReportPositionDynamicsDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> IDLGnssSystemTimeStructTypeDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> IDLGnssGloTimeStructTypeDeployment_t;
typedef CommonAPI::SomeIP::VariantDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
> IDLSystemTimeStructUnionDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvSystemEnumTypeDeployment_t,
CommonAPI::SomeIP::VariantDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>
> IDLGnssSystemTimeDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment
> IDLLocationDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
> IDLLLAInfoDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment
>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>
>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
>,
CommonAPI::SomeIP::StructDeployment<
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvSystemEnumTypeDeployment_t,
CommonAPI::SomeIP::VariantDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>
>,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::StructDeployment<
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
>,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::EmptyDeployment
>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint16_t>
>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<int16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>
> IDLLocationReportDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvTypeDeployment_t,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment
> IDLGnssSvDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::EmptyDeployment
>,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::EmptyDeployment
>
> IDLGnssDataDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvTypeDeployment_t,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
> IDLGnssMeasurementsDataDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<int16_t>,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>
> IDLGnssMeasurementsClockDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<int16_t>,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>
>,
CommonAPI::SomeIP::ArrayDeployment<
CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<uint16_t>,
CommonAPI::SomeIP::IntegerDeployment<uint8_t>,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvTypeDeployment_t,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
>
>,
CommonAPI::EmptyDeployment,
CommonAPI::SomeIP::IntegerDeployment<int16_t>
> IDLGnssMeasurementsDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssConstellationTypeDeployment_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> IDLGnssSvIdInfoDeployment_t;
typedef CommonAPI::SomeIP::StructDeployment<
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::SomeIP::IntegerDeployment<uint64_t>,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment,
CommonAPI::EmptyDeployment
> MapMatchingFeedbackDataDeployment_t;
// Type-specific deployments
COMMONAPI_EXPORT extern IDLGnssReportCbInfoMaskDeployment_t IDLGnssReportCbInfoMaskDeployment;
COMMONAPI_EXPORT extern IDLEngineReportCbMaskDeployment_t IDLEngineReportCbMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationCapabilitiesMaskDeployment_t IDLLocationCapabilitiesMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssSvOptionsMaskDeployment_t IDLGnssSvOptionsMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationFlagsMaskDeployment_t IDLLocationFlagsMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationTechnologyMaskDeployment_t IDLLocationTechnologyMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationReportNavSolutionMaskDeployment_t IDLLocationReportNavSolutionMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationReportPosDataMaskDeployment_t IDLLocationReportPosDataMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssSignalTypeMaskDeployment_t IDLGnssSignalTypeMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationResponseDeployment_t IDLLocationResponseDeployment;
COMMONAPI_EXPORT extern IDLGnssSvTypeDeployment_t IDLGnssSvTypeDeployment;
COMMONAPI_EXPORT extern IDLLCALocationInfoFlagMaskDeployment_t IDLLCALocationInfoFlagMaskDeployment;
COMMONAPI_EXPORT extern IDLLocationReliabilityDeployment_t IDLLocationReliabilityDeployment;
COMMONAPI_EXPORT extern IDLGnssSvSystemEnumTypeDeployment_t IDLGnssSvSystemEnumTypeDeployment;
COMMONAPI_EXPORT extern IDLGnssSystemTimeStructTypeFlagsDeployment_t IDLGnssSystemTimeStructTypeFlagsDeployment;
COMMONAPI_EXPORT extern IDLGnssGloTimeStructTypeFlagsDeployment_t IDLGnssGloTimeStructTypeFlagsDeployment;
COMMONAPI_EXPORT extern IDLDrCalibrationStatusMaskDeployment_t IDLDrCalibrationStatusMaskDeployment;
COMMONAPI_EXPORT extern ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSystemTimeDeployment_t IDLGnssSystemTimeDeployment;
COMMONAPI_EXPORT extern IDLLocReqEngineTypeMaskDeployment_t IDLLocReqEngineTypeMaskDeployment;
COMMONAPI_EXPORT extern IDLLocOutputEngineTypeDeployment_t IDLLocOutputEngineTypeDeployment;
COMMONAPI_EXPORT extern IDLPositioningEngineMaskDeployment_t IDLPositioningEngineMaskDeployment;
COMMONAPI_EXPORT extern IDLDrSolutionStatusMaskDeployment_t IDLDrSolutionStatusMaskDeployment;
COMMONAPI_EXPORT extern IDLLocSessionStatusDeployment_t IDLLocSessionStatusDeployment;
COMMONAPI_EXPORT extern ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t IDLLocationReportDeployment;
COMMONAPI_EXPORT extern ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t IDLGnssSvDeployment;
COMMONAPI_EXPORT extern IDLGnssDataMaskDeployment_t IDLGnssDataMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssMeasurementsDataFlagsMaskDeployment_t IDLGnssMeasurementsDataFlagsMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssMeasurementsStateMaskDeployment_t IDLGnssMeasurementsStateMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssMeasurementsAdrStateMaskDeployment_t IDLGnssMeasurementsAdrStateMaskDeployment;
COMMONAPI_EXPORT extern IDLGnssMeasurementsMultipathIndicatorDeployment_t IDLGnssMeasurementsMultipathIndicatorDeployment;
COMMONAPI_EXPORT extern IDLGnssMeasurementsClockFlagsMaskDeployment_t IDLGnssMeasurementsClockFlagsMaskDeployment;
COMMONAPI_EXPORT extern ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDataDeployment_t IDLGnssMeasurementsDataDeployment;
COMMONAPI_EXPORT extern CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDataDeployment_t > IDLGnssMeasurements_measurementsDeployment;
COMMONAPI_EXPORT extern ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment_t IDLGnssMeasurementsDeployment;
COMMONAPI_EXPORT extern MapMatchingFeedbackDataValidityDeployment_t MapMatchingFeedbackDataValidityDeployment;
// Attribute-specific deployments
// Argument-specific deployment
// Broadcast-specific deployments
COMMONAPI_EXPORT extern CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t > EngineLocations_engLocationsDeployment;
COMMONAPI_EXPORT extern CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t > GnssSv_gnssSvsDeployment;
} // namespace LocIdlAPI_
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_SOMEIP_DEPLOYMENT_HPP_

461
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPProxy.cpp Normal file
View File

@@ -0,0 +1,461 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#include <v0/com/qualcomm/qti/location/LocIdlAPISomeIPProxy.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/SomeIP/AddressTranslator.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
std::shared_ptr<CommonAPI::SomeIP::Proxy> createLocIdlAPISomeIPProxy(
const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection) {
return std::make_shared< LocIdlAPISomeIPProxy>(_address, _connection);
}
void initializeLocIdlAPISomeIPProxy() {
CommonAPI::SomeIP::AddressTranslator::get()->insert(
"local:com.qualcomm.qti.location.LocIdlAPI:v0_2:com.qualcomm.qti.location.LocIdlAPI",
0xee00, 0x1, 0, 2);
CommonAPI::SomeIP::Factory::get()->registerProxyCreateMethod(
"com.qualcomm.qti.location.LocIdlAPI:v0_2",
&createLocIdlAPISomeIPProxy);
}
INITIALIZER(registerLocIdlAPISomeIPProxy) {
CommonAPI::SomeIP::Factory::get()->registerInterface(initializeLocIdlAPISomeIPProxy);
}
LocIdlAPISomeIPProxy::LocIdlAPISomeIPProxy(
const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection)
: CommonAPI::SomeIP::Proxy(_address, _connection),
gnssCapabilitiesMask_(*this, CommonAPI::SomeIP::eventgroup_id_t(0x80e8), CommonAPI::SomeIP::event_id_t(0x80f2), CommonAPI::SomeIP::method_id_t(0xbb8), true, CommonAPI::SomeIP::reliability_type_e::RT_RELIABLE, false, CommonAPI::SomeIP::method_id_t(0xbb9), true, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr)),
gnssMeasurements_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80e9), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment)),
locationReport_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80ea), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment)),
engineLocations_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80eb), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::EngineLocations_engLocationsDeployment)),
gnssSv_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80ec), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::GnssSv_gnssSvsDeployment)),
gnssNmea_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80ed), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::SomeIP::StringDeployment* >(nullptr))),
engineNmea_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80ee), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr), static_cast< CommonAPI::SomeIP::StringDeployment* >(nullptr))),
gnssData_(*this, 0x80e8, CommonAPI::SomeIP::event_id_t(0x80ef), CommonAPI::SomeIP::event_type_e::ET_EVENT , CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE, false, std::make_tuple(static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssDataDeployment_t* >(nullptr)))
{
}
LocIdlAPISomeIPProxy::~LocIdlAPISomeIPProxy() {
completed_.set_value();
}
LocIdlAPISomeIPProxy::GnssCapabilitiesMaskAttribute& LocIdlAPISomeIPProxy::getGnssCapabilitiesMaskAttribute() {
return gnssCapabilitiesMask_;
}
LocIdlAPISomeIPProxy::GnssMeasurementsEvent& LocIdlAPISomeIPProxy::getGnssMeasurementsEvent() {
return gnssMeasurements_;
}
LocIdlAPISomeIPProxy::LocationReportEvent& LocIdlAPISomeIPProxy::getLocationReportEvent() {
return locationReport_;
}
LocIdlAPISomeIPProxy::EngineLocationsEvent& LocIdlAPISomeIPProxy::getEngineLocationsEvent() {
return engineLocations_;
}
LocIdlAPISomeIPProxy::GnssSvEvent& LocIdlAPISomeIPProxy::getGnssSvEvent() {
return gnssSv_;
}
LocIdlAPISomeIPProxy::GnssNmeaEvent& LocIdlAPISomeIPProxy::getGnssNmeaEvent() {
return gnssNmea_;
}
LocIdlAPISomeIPProxy::EngineNmeaEvent& LocIdlAPISomeIPProxy::getEngineNmeaEvent() {
return engineNmea_;
}
LocIdlAPISomeIPProxy::GnssDataEvent& LocIdlAPISomeIPProxy::getGnssDataEvent() {
return gnssData_;
}
void LocIdlAPISomeIPProxy::startPositionSession(uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_intervalInMs(_intervalInMs, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_gnssReportCallbackMask(_gnssReportCallbackMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d01),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_intervalInMs, deploy_gnssReportCallbackMask,
_internalCallStatus,
deploy_resp);
_resp = deploy_resp.getValue();
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_gnssReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_intervalInMs(_intervalInMs, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_gnssReportCallbackMask(_gnssReportCallbackMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d01),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_intervalInMs, deploy_gnssReportCallbackMask,
[_callback] (CommonAPI::CallStatus _internalCallStatus, CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t > _resp) {
if (_callback)
_callback(_internalCallStatus, _resp.getValue());
},
std::make_tuple(deploy_resp));
}
void LocIdlAPISomeIPProxy::startPositionSession(uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_intervalInMs(_intervalInMs, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_locReqEngMask(_locReqEngMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_engReportCallbackMask(_engReportCallbackMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d02),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_intervalInMs, deploy_locReqEngMask, deploy_engReportCallbackMask,
_internalCallStatus,
deploy_resp);
_resp = deploy_resp.getValue();
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_locReqEngMask, const uint32_t &_engReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_intervalInMs(_intervalInMs, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_locReqEngMask(_locReqEngMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_engReportCallbackMask(_engReportCallbackMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>,
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d02),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_intervalInMs, deploy_locReqEngMask, deploy_engReportCallbackMask,
[_callback] (CommonAPI::CallStatus _internalCallStatus, CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t > _resp) {
if (_callback)
_callback(_internalCallStatus, _resp.getValue());
},
std::make_tuple(deploy_resp));
}
void LocIdlAPISomeIPProxy::stopPositionSession(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info) {
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
>,
CommonAPI::SomeIP::SerializableArguments<
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d03),
false,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
_internalCallStatus);
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::stopPositionSessionAsync(StopPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
>,
CommonAPI::SomeIP::SerializableArguments<
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d03),
false,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
[_callback] (CommonAPI::CallStatus _internalCallStatus) {
if (_callback)
_callback(_internalCallStatus);
},
std::make_tuple());
}
void LocIdlAPISomeIPProxy::deleteAidingData(uint32_t _aidingDataMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_aidingDataMask(_aidingDataMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d04),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_aidingDataMask,
_internalCallStatus,
deploy_resp);
_resp = deploy_resp.getValue();
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::deleteAidingDataAsync(const uint32_t &_aidingDataMask, DeleteAidingDataAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deploy_aidingDataMask(_aidingDataMask, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d04),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_aidingDataMask,
[_callback] (CommonAPI::CallStatus _internalCallStatus, CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t > _resp) {
if (_callback)
_callback(_internalCallStatus, _resp.getValue());
},
std::make_tuple(deploy_resp));
}
void LocIdlAPISomeIPProxy::configConstellations(std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< std::vector< LocIdlAPI::IDLGnssSvIdInfo >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >> deploy_svList(_svList, static_cast< CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
std::vector< LocIdlAPI::IDLGnssSvIdInfo >,
CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d05),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_svList,
_internalCallStatus,
deploy_resp);
_resp = deploy_resp.getValue();
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::configConstellationsAsync(const std::vector< LocIdlAPI::IDLGnssSvIdInfo > &_svList, ConfigConstellationsAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< std::vector< LocIdlAPI::IDLGnssSvIdInfo >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >> deploy_svList(_svList, static_cast< CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
std::vector< LocIdlAPI::IDLGnssSvIdInfo >,
CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d05),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_svList,
[_callback] (CommonAPI::CallStatus _internalCallStatus, CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t > _resp) {
if (_callback)
_callback(_internalCallStatus, _resp.getValue());
},
std::make_tuple(deploy_resp));
}
void LocIdlAPISomeIPProxy::injectMapMatchedFeedbackData(LocIdlAPI::MapMatchingFeedbackData _mmfData, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< LocIdlAPI::MapMatchingFeedbackData, ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t> deploy_mmfData(_mmfData, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::MapMatchingFeedbackData,
::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodWithReply(
*this,
CommonAPI::SomeIP::method_id_t(0x7d06),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_mmfData,
_internalCallStatus,
deploy_resp);
_resp = deploy_resp.getValue();
}
std::future<CommonAPI::CallStatus> LocIdlAPISomeIPProxy::injectMapMatchedFeedbackDataAsync(const LocIdlAPI::MapMatchingFeedbackData &_mmfData, InjectMapMatchedFeedbackDataAsyncCallback _callback, const CommonAPI::CallInfo *_info) {
CommonAPI::Deployable< LocIdlAPI::MapMatchingFeedbackData, ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t> deploy_mmfData(_mmfData, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t* >(nullptr));
CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t> deploy_resp(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment);
return CommonAPI::SomeIP::ProxyHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::MapMatchingFeedbackData,
::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t
>
>,
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
LocIdlAPI::IDLLocationResponse,
::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t
>
>
>::callMethodAsync(
*this,
CommonAPI::SomeIP::method_id_t(0x7d06),
true,
false,
(_info ? _info : &CommonAPI::SomeIP::defaultCallInfo),
deploy_mmfData,
[_callback] (CommonAPI::CallStatus _internalCallStatus, CommonAPI::Deployable< LocIdlAPI::IDLLocationResponse, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t > _resp) {
if (_callback)
_callback(_internalCallStatus, _resp.getValue());
},
std::make_tuple(deploy_resp));
}
void LocIdlAPISomeIPProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const {
ownVersionMajor = 0;
ownVersionMinor = 2;
}
std::future<void> LocIdlAPISomeIPProxy::getCompletionFuture() {
return completed_.get_future();
}
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0

125
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPProxy.hpp Normal file
View File

@@ -0,0 +1,125 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_LOC_IDL_API_SOMEIP_PROXY_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_LOC_IDL_API_SOMEIP_PROXY_HPP_
#include <v0/com/qualcomm/qti/location/LocIdlAPIProxyBase.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPISomeIPDeployment.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/SomeIP/Factory.hpp>
#include <CommonAPI/SomeIP/Proxy.hpp>
#include <CommonAPI/SomeIP/Types.hpp>
#include <CommonAPI/SomeIP/Attribute.hpp>
#include <CommonAPI/SomeIP/Event.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <string>
# if defined(_MSC_VER)
# if _MSC_VER >= 1300
/*
* Diamond inheritance is used for the CommonAPI::Proxy base class.
* The Microsoft compiler put warning (C4250) using a desired c++ feature: "Delegating to a sister class"
* A powerful technique that arises from using virtual inheritance is to delegate a method from a class in another class
* by using a common abstract base class. This is also called cross delegation.
*/
# pragma warning( disable : 4250 )
# endif
# endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
class LocIdlAPISomeIPProxy
: virtual public LocIdlAPIProxyBase,
virtual public CommonAPI::SomeIP::Proxy {
public:
LocIdlAPISomeIPProxy(
const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection);
virtual ~LocIdlAPISomeIPProxy();
virtual GnssCapabilitiesMaskAttribute& getGnssCapabilitiesMaskAttribute();
virtual GnssMeasurementsEvent& getGnssMeasurementsEvent();
virtual LocationReportEvent& getLocationReportEvent();
virtual EngineLocationsEvent& getEngineLocationsEvent();
virtual GnssSvEvent& getGnssSvEvent();
virtual GnssNmeaEvent& getGnssNmeaEvent();
virtual EngineNmeaEvent& getEngineNmeaEvent();
virtual GnssDataEvent& getGnssDataEvent();
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _gnssReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_gnssReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void startPositionSession(uint32_t _intervalInMs, uint32_t _locReqEngMask, uint32_t _engReportCallbackMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> startPositionSessionAsync(const uint32_t &_intervalInMs, const uint32_t &_locReqEngMask, const uint32_t &_engReportCallbackMask, StartPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void stopPositionSession(CommonAPI::CallStatus &_internalCallStatus, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> stopPositionSessionAsync(StopPositionSessionAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void deleteAidingData(uint32_t _aidingDataMask, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> deleteAidingDataAsync(const uint32_t &_aidingDataMask, DeleteAidingDataAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void configConstellations(std::vector< LocIdlAPI::IDLGnssSvIdInfo > _svList, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> configConstellationsAsync(const std::vector< LocIdlAPI::IDLGnssSvIdInfo > &_svList, ConfigConstellationsAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void injectMapMatchedFeedbackData(LocIdlAPI::MapMatchingFeedbackData _mmfData, CommonAPI::CallStatus &_internalCallStatus, LocIdlAPI::IDLLocationResponse &_resp, const CommonAPI::CallInfo *_info);
virtual std::future<CommonAPI::CallStatus> injectMapMatchedFeedbackDataAsync(const LocIdlAPI::MapMatchingFeedbackData &_mmfData, InjectMapMatchedFeedbackDataAsyncCallback _callback, const CommonAPI::CallInfo *_info);
virtual void getOwnVersion(uint16_t &_major, uint16_t &_minor) const;
virtual std::future<void> getCompletionFuture();
private:
CommonAPI::SomeIP::ObservableAttribute<CommonAPI::SomeIP::Attribute<GnssCapabilitiesMaskAttribute, CommonAPI::SomeIP::IntegerDeployment<uint32_t>>> gnssCapabilitiesMask_;
CommonAPI::SomeIP::Event<GnssMeasurementsEvent, CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment_t >> gnssMeasurements_;
CommonAPI::SomeIP::Event<LocationReportEvent, CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t >> locationReport_;
CommonAPI::SomeIP::Event<EngineLocationsEvent, CommonAPI::Deployable< std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t > >> engineLocations_;
CommonAPI::SomeIP::Event<GnssSvEvent, CommonAPI::Deployable< std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t > >> gnssSv_;
CommonAPI::SomeIP::Event<GnssNmeaEvent, CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t> >, CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment >> gnssNmea_;
CommonAPI::SomeIP::Event<EngineNmeaEvent, CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment_t >, CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t> >, CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment >> engineNmea_;
CommonAPI::SomeIP::Event<GnssDataEvent, CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssDataDeployment_t >> gnssData_;
std::promise<void> completed_;
};
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_SOMEIP_PROXY_HPP_

55
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPStubAdapter.cpp Normal file
View File

@@ -0,0 +1,55 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#include <v0/com/qualcomm/qti/location/LocIdlAPISomeIPStubAdapter.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPI.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/SomeIP/AddressTranslator.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
std::shared_ptr<CommonAPI::SomeIP::StubAdapter> createLocIdlAPISomeIPStubAdapter(
const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection,
const std::shared_ptr<CommonAPI::StubBase> &_stub) {
return std::make_shared< LocIdlAPISomeIPStubAdapter<::v0::com::qualcomm::qti::location::LocIdlAPIStub>>(_address, _connection, _stub);
}
void initializeLocIdlAPISomeIPStubAdapter() {
CommonAPI::SomeIP::AddressTranslator::get()->insert(
"local:com.qualcomm.qti.location.LocIdlAPI:v0_2:com.qualcomm.qti.location.LocIdlAPI",
0xee00, 0x1, 0, 2);
CommonAPI::SomeIP::Factory::get()->registerStubAdapterCreateMethod(
"com.qualcomm.qti.location.LocIdlAPI:v0_2",
&createLocIdlAPISomeIPStubAdapter);
}
INITIALIZER(registerLocIdlAPISomeIPStubAdapter) {
CommonAPI::SomeIP::Factory::get()->registerInterface(initializeLocIdlAPISomeIPStubAdapter);
}
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0

414
qcom/opensource/location/loc-fidl/src-gen/someip/v0/com/qualcomm/qti/location/LocIdlAPISomeIPStubAdapter.hpp Normal file
View File

@@ -0,0 +1,414 @@
/*
* This file was generated by the CommonAPI Generators.
* Used org.genivi.commonapi.someip 3.2.0.v202012010944.
* Used org.franca.core 0.13.1.201807231814.
*
* This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
* If a copy of the MPL was not distributed with this file, You can obtain one at
* http://mozilla.org/MPL/2.0/.
*/
#ifndef V0_COM_QUALCOMM_QTI_LOCATION_LOC_IDL_API_SOMEIP_STUB_ADAPTER_HPP_
#define V0_COM_QUALCOMM_QTI_LOCATION_LOC_IDL_API_SOMEIP_STUB_ADAPTER_HPP_
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPISomeIPDeployment.hpp>
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#define COMMONAPI_INTERNAL_COMPILATION
#define HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
#include <CommonAPI/SomeIP/AddressTranslator.hpp>
#include <CommonAPI/SomeIP/StubAdapterHelper.hpp>
#include <CommonAPI/SomeIP/StubAdapter.hpp>
#include <CommonAPI/SomeIP/Factory.hpp>
#include <CommonAPI/SomeIP/Types.hpp>
#include <CommonAPI/SomeIP/Constants.hpp>
#if defined (HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE)
#undef COMMONAPI_INTERNAL_COMPILATION
#undef HAS_DEFINED_COMMONAPI_INTERNAL_COMPILATION_HERE
#endif
namespace v0 {
namespace com {
namespace qualcomm {
namespace qti {
namespace location {
template <typename _Stub = ::v0::com::qualcomm::qti::location::LocIdlAPIStub, typename... _Stubs>
class LocIdlAPISomeIPStubAdapterInternal
: public virtual LocIdlAPIStubAdapter,
public CommonAPI::SomeIP::StubAdapterHelper< _Stub, _Stubs...>,
public std::enable_shared_from_this< LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>>
{
public:
typedef CommonAPI::SomeIP::StubAdapterHelper< _Stub, _Stubs...> LocIdlAPISomeIPStubAdapterHelper;
~LocIdlAPISomeIPStubAdapterInternal() {
deactivateManagedInstances();
LocIdlAPISomeIPStubAdapterHelper::deinit();
}
void fireGnssCapabilitiesMaskAttributeChanged(const uint32_t &_value);
void fireGnssMeasurementsEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements &_gnssMeasurements);
void fireLocationReportEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport &_locationReport);
void fireEngineLocationsEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport > &_engLocations);
void fireGnssSvEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv > &_gnssSvs);
void fireGnssNmeaEvent(const uint64_t &_timestamp, const std::string &_nmea);
void fireEngineNmeaEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType &_engType, const uint64_t &_timestamp, const std::string &_nmea);
void fireGnssDataEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData &_gnssData);
void deactivateManagedInstances() {}
CommonAPI::SomeIP::GetAttributeStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
CommonAPI::Version
> getLocIdlAPIInterfaceVersionStubDispatcher;
CommonAPI::SomeIP::GetAttributeStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> getGnssCapabilitiesMaskAttributeStubDispatcher;
CommonAPI::SomeIP::SetObservableAttributeStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
> setGnssCapabilitiesMaskAttributeStubDispatcher;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< uint32_t, uint32_t>,
std::tuple< LocIdlAPI::IDLLocationResponse>,
std::tuple< CommonAPI::SomeIP::IntegerDeployment<uint32_t>, CommonAPI::SomeIP::IntegerDeployment<uint32_t>>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t>
> startPositionSessionStubDispatcher;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< uint32_t, uint32_t, uint32_t>,
std::tuple< LocIdlAPI::IDLLocationResponse>,
std::tuple< CommonAPI::SomeIP::IntegerDeployment<uint32_t>, CommonAPI::SomeIP::IntegerDeployment<uint32_t>, CommonAPI::SomeIP::IntegerDeployment<uint32_t>>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t>
> startPositionSessionStubDispatcher1;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< >,
std::tuple< >,
std::tuple< >,
std::tuple< >
> stopPositionSessionStubDispatcher;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< uint32_t>,
std::tuple< LocIdlAPI::IDLLocationResponse>,
std::tuple< CommonAPI::SomeIP::IntegerDeployment<uint32_t>>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t>
> deleteAidingDataStubDispatcher;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< std::vector< LocIdlAPI::IDLGnssSvIdInfo >>,
std::tuple< LocIdlAPI::IDLLocationResponse>,
std::tuple< CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t>
> configConstellationsStubDispatcher;
CommonAPI::SomeIP::MethodWithReplyStubDispatcher<
::v0::com::qualcomm::qti::location::LocIdlAPIStub,
std::tuple< LocIdlAPI::MapMatchingFeedbackData>,
std::tuple< LocIdlAPI::IDLLocationResponse>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t>,
std::tuple< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment_t>
> injectMapMatchedFeedbackDataStubDispatcher;
LocIdlAPISomeIPStubAdapterInternal(
const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection,
const std::shared_ptr<CommonAPI::StubBase> &_stub):
CommonAPI::SomeIP::StubAdapter(_address, _connection),
LocIdlAPISomeIPStubAdapterHelper(
_address,
_connection,
std::dynamic_pointer_cast< LocIdlAPIStub>(_stub)),
getLocIdlAPIInterfaceVersionStubDispatcher(&LocIdlAPIStub::lockInterfaceVersionAttribute, &LocIdlAPIStub::getInterfaceVersion, false, true),
getGnssCapabilitiesMaskAttributeStubDispatcher(
&::v0::com::qualcomm::qti::location::LocIdlAPIStub::lockGnssCapabilitiesMaskAttribute,
&::v0::com::qualcomm::qti::location::LocIdlAPIStub::getGnssCapabilitiesMaskAttribute,
false,
_stub->hasElement(0)),
setGnssCapabilitiesMaskAttributeStubDispatcher(
&::v0::com::qualcomm::qti::location::LocIdlAPIStub::lockGnssCapabilitiesMaskAttribute,
&::v0::com::qualcomm::qti::location::LocIdlAPIStub::getGnssCapabilitiesMaskAttribute,
&LocIdlAPIStubRemoteEvent::onRemoteSetGnssCapabilitiesMaskAttribute,
&LocIdlAPIStubRemoteEvent::onRemoteGnssCapabilitiesMaskAttributeChanged,
&LocIdlAPIStubAdapter::fireGnssCapabilitiesMaskAttributeChanged,
false,
_stub->hasElement(0))
,
startPositionSessionStubDispatcher(
&LocIdlAPIStub::startPositionSession,
false,
_stub->hasElement(8),
std::make_tuple(static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr)),
std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment))
,
startPositionSessionStubDispatcher1(
&LocIdlAPIStub::startPositionSession,
false,
_stub->hasElement(9),
std::make_tuple(static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr), static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr)),
std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment))
,
stopPositionSessionStubDispatcher(
&LocIdlAPIStub::stopPositionSession,
false,
_stub->hasElement(10),
std::make_tuple(),
std::make_tuple())
,
deleteAidingDataStubDispatcher(
&LocIdlAPIStub::deleteAidingData,
false,
_stub->hasElement(11),
std::make_tuple(static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr)),
std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment))
,
configConstellationsStubDispatcher(
&LocIdlAPIStub::configConstellations,
false,
_stub->hasElement(12),
std::make_tuple(static_cast< CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvIdInfoDeployment_t >* >(nullptr)),
std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment))
,
injectMapMatchedFeedbackDataStubDispatcher(
&LocIdlAPIStub::injectMapMatchedFeedbackData,
false,
_stub->hasElement(13),
std::make_tuple(static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::MapMatchingFeedbackDataDeployment_t* >(nullptr)),
std::make_tuple(&::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationResponseDeployment))
{
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0xbb8) }, &getGnssCapabilitiesMaskAttributeStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0xbb9) }, &setGnssCapabilitiesMaskAttributeStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d01) }, &startPositionSessionStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d02) }, &startPositionSessionStubDispatcher1 );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d03) }, &stopPositionSessionStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d04) }, &deleteAidingDataStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d05) }, &configConstellationsStubDispatcher );
LocIdlAPISomeIPStubAdapterHelper::addStubDispatcher( { CommonAPI::SomeIP::method_id_t(0x7d06) }, &injectMapMatchedFeedbackDataStubDispatcher );
std::shared_ptr<CommonAPI::SomeIP::ClientId> itsClient = std::make_shared<CommonAPI::SomeIP::ClientId>(0xFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
// Provided events/fields
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80e9), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80ea), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80eb), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80ec), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80ed), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80ee), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
{
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(0x80e8));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80ef), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_EVENT, CommonAPI::SomeIP::reliability_type_e::RT_UNRELIABLE);
}
if (_stub->hasElement(0)) {
std::set<CommonAPI::SomeIP::eventgroup_id_t> itsEventGroups;
itsEventGroups.insert(CommonAPI::SomeIP::eventgroup_id_t(CommonAPI::SomeIP::eventgroup_id_t(0x80e8)));
CommonAPI::SomeIP::StubAdapter::registerEvent(CommonAPI::SomeIP::event_id_t(0x80f2), itsEventGroups, CommonAPI::SomeIP::event_type_e::ET_FIELD, CommonAPI::SomeIP::reliability_type_e::RT_RELIABLE);
fireGnssCapabilitiesMaskAttributeChanged(std::dynamic_pointer_cast< ::v0::com::qualcomm::qti::location::LocIdlAPIStub>(_stub)->getGnssCapabilitiesMaskAttribute(itsClient));
}
}
// Register/Unregister event handlers for selective broadcasts
void registerSelectiveEventHandlers();
void unregisterSelectiveEventHandlers();
};
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireGnssCapabilitiesMaskAttributeChanged(const uint32_t &_value) {
CommonAPI::Deployable< uint32_t, CommonAPI::SomeIP::IntegerDeployment<uint32_t>> deployedValue(_value, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint32_t>* >(nullptr));
CommonAPI::SomeIP::StubEventHelper<
CommonAPI::SomeIP::SerializableArguments<
CommonAPI::Deployable<
uint32_t,
CommonAPI::SomeIP::IntegerDeployment<uint32_t>
>
>
>::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80f2),
false,
deployedValue
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireGnssMeasurementsEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements &_gnssMeasurements) {
CommonAPI::Deployable< LocIdlAPI::IDLGnssMeasurements, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment_t> deployed_gnssMeasurements(_gnssMeasurements, &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment);
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssMeasurements, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssMeasurementsDeployment_t >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80e9),
false,
deployed_gnssMeasurements
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireLocationReportEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport &_locationReport) {
CommonAPI::Deployable< LocIdlAPI::IDLLocationReport, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t> deployed_locationReport(_locationReport, &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment);
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80ea),
false,
deployed_locationReport
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireEngineLocationsEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport > &_engLocations) {
CommonAPI::Deployable< std::vector< LocIdlAPI::IDLLocationReport >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t >> deployed_engLocations(_engLocations, &::v0::com::qualcomm::qti::location::LocIdlAPI_::EngineLocations_engLocationsDeployment);
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocationReport >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocationReportDeployment_t > >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80eb),
false,
deployed_engLocations
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireGnssSvEvent(const std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv > &_gnssSvs) {
CommonAPI::Deployable< std::vector< LocIdlAPI::IDLGnssSv >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t >> deployed_gnssSvs(_gnssSvs, &::v0::com::qualcomm::qti::location::LocIdlAPI_::GnssSv_gnssSvsDeployment);
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< std::vector< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssSv >, CommonAPI::SomeIP::ArrayDeployment< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssSvDeployment_t > >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80ec),
false,
deployed_gnssSvs
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireGnssNmeaEvent(const uint64_t &_timestamp, const std::string &_nmea) {
CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t>> deployed_timestamp(_timestamp, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr));
CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment> deployed_nmea(_nmea, static_cast< CommonAPI::SomeIP::StringDeployment* >(nullptr));
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t> >
, CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80ed),
false,
deployed_timestamp
, deployed_nmea
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireEngineNmeaEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType &_engType, const uint64_t &_timestamp, const std::string &_nmea) {
CommonAPI::Deployable< LocIdlAPI::IDLLocOutputEngineType, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment_t> deployed_engType(_engType, &::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment);
CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t>> deployed_timestamp(_timestamp, static_cast< CommonAPI::SomeIP::IntegerDeployment<uint64_t>* >(nullptr));
CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment> deployed_nmea(_nmea, static_cast< CommonAPI::SomeIP::StringDeployment* >(nullptr));
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLLocOutputEngineType, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLLocOutputEngineTypeDeployment_t >
, CommonAPI::Deployable< uint64_t, CommonAPI::SomeIP::IntegerDeployment<uint64_t> >
, CommonAPI::Deployable< std::string, CommonAPI::SomeIP::StringDeployment >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80ee),
false,
deployed_engType
, deployed_timestamp
, deployed_nmea
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::fireGnssDataEvent(const ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData &_gnssData) {
CommonAPI::Deployable< LocIdlAPI::IDLGnssData, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssDataDeployment_t> deployed_gnssData(_gnssData, static_cast< ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssDataDeployment_t* >(nullptr));
CommonAPI::SomeIP::StubEventHelper<CommonAPI::SomeIP::SerializableArguments< CommonAPI::Deployable< ::v0::com::qualcomm::qti::location::LocIdlAPI::IDLGnssData, ::v0::com::qualcomm::qti::location::LocIdlAPI_::IDLGnssDataDeployment_t >
>>
::sendEvent(
*this,
CommonAPI::SomeIP::event_id_t(0x80ef),
false,
deployed_gnssData
);
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::registerSelectiveEventHandlers() {
}
template <typename _Stub, typename... _Stubs>
void LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>::unregisterSelectiveEventHandlers() {
}
template <typename _Stub = ::v0::com::qualcomm::qti::location::LocIdlAPIStub, typename... _Stubs>
class LocIdlAPISomeIPStubAdapter
: public LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...> {
public:
LocIdlAPISomeIPStubAdapter(const CommonAPI::SomeIP::Address &_address,
const std::shared_ptr<CommonAPI::SomeIP::ProxyConnection> &_connection,
const std::shared_ptr<CommonAPI::StubBase> &_stub)
: CommonAPI::SomeIP::StubAdapter(_address, _connection),
LocIdlAPISomeIPStubAdapterInternal<_Stub, _Stubs...>(_address, _connection, _stub) {
}
};
} // namespace location
} // namespace qti
} // namespace qualcomm
} // namespace com
} // namespace v0
#endif // V0_COM_QUALCOMM_QTI_LOCATION_Loc_Idl_API_SOMEIP_STUB_ADAPTER_HPP_

9
qcom/opensource/location/loc-fidl/src/CMakeLists.txt Normal file
View File

@@ -0,0 +1,9 @@
cmake_minimum_required(VERSION 2.8)
macro(SYSR_INCLUDE_DIR subdir)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I =/usr/include/${subdir}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I =/usr/include/${subdir}")
endmacro()
add_subdirectory( LocIdlService )
add_subdirectory( LocIdlClient )

186
qcom/opensource/location/loc-fidl/src/LocIdlClient/CMakeLists.txt Normal file
View File

@@ -0,0 +1,186 @@
cmake_minimum_required(VERSION 2.8)
set(PRJ_NAME LocIdlAPI)
set(CMAKE_VERBOSE_MAKEFILE on)
OPTION(USE_FILE "Set to OFF to disable file logging" OFF )
message(STATUS "USE_FILE is set to value: ${USE_FILE}")
OPTION(USE_CONSOLE "Set to OFF to disable console logging" OFF )
message(STATUS "USE_CONSOLE is set to value: ${USE_CONSOLE}")
IF(USE_FILE)
add_definitions(-DUSE_FILE)
ENDIF(USE_FILE)
IF(USE_CONSOLE)
add_definitions(-DUSE_CONSOLE)
ENDIF(USE_CONSOLE)
add_definitions(-D__LINUX__)
add_definitions(-DOFF_TARGET)
add_definitions(-std=c++14)
add_definitions(-DUSE_GLIB)
add_definitions(-DUSE_ANDROID_LOGGING)
add_definitions(-DBASE_PATH=/var/tmp/location)
SET(MAX_LOG_LEVEL "DEBUG" CACHE STRING "maximum log level")
message(STATUS "MAX_LOG_LEVEL is set to value: ${MAX_LOG_LEVEL}")
add_definitions(-DCOMMONAPI_LOGLEVEL=COMMONAPI_LOGLEVEL_${MAX_LOG_LEVEL})
if (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
set (OS "QNX")
set (NO_DEPRECATED_REGISTER "")
set (Boost_USE_STATIC_LIBS ON)
endif (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
if (MSVC)
# Visual C++ is not always sure whether he is really C++
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS /EHsc /wd\\\"4503\\\"")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS /wd\\\"4503\\\"")
else()
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP -DQNX")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP")
endif()
message(STATUS "Compiler options: ${CMAKE_CXX_FLAGS}")
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
"Choose the type of build, options are: Debug Release." FORCE)
endif(NOT CMAKE_BUILD_TYPE)
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
OPTION(USE_INSTALLED_COMMONAPI "Set to OFF to use the local (build tree) version of CommonAPI" ON)
message(STATUS "USE_INSTALLED_COMMONAPI is set to value: ${USE_INSTALLED_COMMONAPI}")
if ("${USE_INSTALLED_COMMONAPI}" STREQUAL "ON")
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
else()
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
endif()
message(STATUS "CommonAPI_CONSIDERED_CONFIGS: ${CommonAPI_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_INCLUDE_DIRS: ${COMMONAPI_INCLUDE_DIRS}")
message(STATUS "CommonAPI-DBus_CONSIDERED_CONFIGS: ${CommonAPI-DBus_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_DBUS_INCLUDE_DIRS: ${COMMONAPI_DBUS_INCLUDE_DIRS}")
# CommonAPI
include(FindPkgConfig)
###############################################################################
# find DBus by using the 'pkg-config' tool
if (MSVC)
#Not beautiful, but it works
if (DBus_DIR)
if (DBus_BUILD_DIR)
set(DBus_INCLUDE_DIRS "${DBus_DIR};${DBus_BUILD_DIR};")
else ()
message (FATAL_ERROR "DBus_BUILD_DIR not set! Cannot continue.")
endif ()
else()
message (FATAL_ERROR "DBus_DIR not set! Cannot continue.")
endif ()
else()
# pkg_check_modules(DBus REQUIRED dbus-1>=1.4)
endif()
SYSR_INCLUDE_DIR(qcom-gps-utils)
# SOME/IP
find_package (CommonAPI-SomeIP 3.2.0 REQUIRED)
find_package (vsomeip3 3.1.20 REQUIRED)
# Source Files
set(PRJ_SRC_PATH ../../src/LocIdlClient)
set(PRJ_SRC_GEN_PATH ../../src-gen)
set(PRJ_SRC_GEN_COMMONAPI_PATH ${PRJ_SRC_GEN_PATH}/core/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_DBUS_PATH ${PRJ_SRC_GEN_PATH}/dbus/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH ${PRJ_SRC_GEN_PATH}/someip/v0/com/qualcomm/qti/location)
set(PRJ_NAME_CLIENT ${PRJ_NAME}Client)
# Application
FILE(GLOB PRJ_PROXY_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Proxy.cpp)
FILE(GLOB PRJ_STUB_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Stub*.cpp)
FILE(GLOB PRJ_STUB_IMPL_SRCS ${PRJ_SRC_COMMONAPI_PATH}/*Stub*.cpp)
set(PRJ_CLIENT_SRCS ${PRJ_SRC_PATH}/${PRJ_NAME_CLIENT}.cpp ${PRJ_PROXY_GEN_SRCS})
# Boost
#find_package( Boost 1.71 COMPONENTS system thread log REQUIRED )
include_directories( ${Boost_INCLUDE_DIR} )
SYSR_INCLUDE_DIR(open-avb)
# DBus library
FILE(GLOB PRJ_DBUS_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_DBUS_PATH}/*cpp)
# SOME/IP library
FILE(GLOB PRJ_SOMEIP_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH}/*cpp)
# Paths
OPTION(USE_INSTALLED_DBUS "Set to OFF to use the local (patched) version of dbus" ON)
message(STATUS "USE_INSTALLED_DBUS is set to value: ${USE_INSTALLED_DBUS}")
include_directories(
../../src-gen/core
../../src-gen/someip
${COMMONAPI_INCLUDE_DIRS}
${COMMONAPI_SOMEIP_INCLUDE_DIRS}
${VSOMEIP_INCLUDE_DIRS}
${SDK_USR_INC_PATH}/
)
if ("${USE_INSTALLED_DBUS}" STREQUAL "ON")
link_directories(
${COMMONAPI_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${Boost_LIBRARY_DIR}
)
else()
link_directories(
${COMMONAPI_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${DBus_INCLUDE_DIRS}/dbus/.libs
${Boost_LIBRARY_DIR}
)
endif()
if (MSVC)
set(LINK_LIBRARIES CommonAPI gptp gps_utils log)
else()
set(LINK_LIBRARIES -Wl,--as-needed CommonAPI gptp gps_utils log)
endif()
# Build Client
add_executable(${PRJ_NAME_CLIENT} ${PRJ_CLIENT_SRCS})
target_link_libraries(${PRJ_NAME_CLIENT} ${LINK_LIBRARIES})
# Build SOME/IP library
add_library (${PRJ_NAME_CLIENT}-someip SHARED ${PRJ_SOMEIP_LIB_SRCS})
target_link_libraries(${PRJ_NAME_CLIENT}-someip CommonAPI-SomeIP)
install (
# TARGETS ${PRJ_NAME_CLIENT} ${PRJ_NAME_SERVICE}
TARGETS ${PRJ_NAME_CLIENT}
RUNTIME DESTINATION "${INSTALL_BIN_DIR}" COMPONENT bin)
install (
TARGETS ${PRJ_NAME}-someip
LIBRARY DESTINATION "${INSTALL_LIB_DIR}" COMPONENT shlib
)
#set(EXAMPLE_CONFIG_FILES ${PRJ_SRC_PATH}/vsomeip-client.json)
set(EXAMPLE_CONFIG_FILES
"vsomeip-client.json"
)
set(EXAMPLE_CONFIG_FILES
"vsomeip-client.json"
"commonapi4someip.ini"
"vsomeip-local.json"
)
install (
FILES ${EXAMPLE_CONFIG_FILES} DESTINATION /etc COMPONENT config
)

1280
qcom/opensource/location/loc-fidl/src/LocIdlClient/LocIdlAPIClient.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

9
qcom/opensource/location/loc-fidl/src/LocIdlClient/commonapi4someip.ini Normal file
View File

@@ -0,0 +1,9 @@
[default]
binding=someip
tp=true
[logging]
console = true
file = ./mylog.log
dlt = false
level = verbose

39
qcom/opensource/location/loc-fidl/src/LocIdlClient/vsomeip-client.json Normal file
View File

@@ -0,0 +1,39 @@
{
"unicast" : "10.131.6.75",
"netmask" : "255.255.0.0",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "true", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "client-sample",
"id" : "0x1343"
}
],
"services" :
[
{
"service" : "0x1234",
"instance" : "0x5678",
"unreliable" : "30509",
"unicast":"192.168.1.9",
"someip-tp":
{
"client-to-service": ["0x9471","0x9472"]
}
}
],
"routing" : "client-sample",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}

38
qcom/opensource/location/loc-fidl/src/LocIdlClient/vsomeip-local.json Normal file
View File

@@ -0,0 +1,38 @@
{
"unicast" : "10.131.4.37",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "false", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "client-sample",
"id" : "0x1343"
},
{
"name" : "service-sample",
"id" : "0x1277"
}
],
"services" :
[
{
"service" : "0x1234",
"instance" : "0x5678",
"reliable" : { "port" : "30509", "enable-magic-cookies" : "false" },
"unreliable" : "31000"
}
],
"routing" : "client-sample",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}

202
qcom/opensource/location/loc-fidl/src/LocIdlService/CMakeLists.txt Normal file
View File

@@ -0,0 +1,202 @@
cmake_minimum_required(VERSION 2.8)
set(PRJ_NAME LocIdlAPI)
set(CMAKE_VERBOSE_MAKEFILE on)
include(CheckCXXCompilerFlag)
OPTION(USE_FILE "Set to OFF to disable file logging" OFF )
message(STATUS "USE_FILE is set to value: ${USE_FILE}")
OPTION(USE_CONSOLE "Set to OFF to disable console logging" OFF )
message(STATUS "USE_CONSOLE is set to value: ${USE_CONSOLE}")
IF(USE_FILE)
add_definitions(-DUSE_FILE)
ENDIF(USE_FILE)
IF(USE_CONSOLE)
add_definitions(-DUSE_CONSOLE)
ENDIF(USE_CONSOLE)
add_definitions(-D__LINUX__)
add_definitions(-DOFF_TARGET)
add_definitions(-std=c++14)
add_definitions(-DBASE_PATH=/var/tmp/location)
add_definitions(-DUSE_ANDROID_LOGGING)
SET(MAX_LOG_LEVEL "DEBUG" CACHE STRING "maximum log level")
message(STATUS "MAX_LOG_LEVEL is set to value: ${MAX_LOG_LEVEL}")
add_definitions(-DCOMMONAPI_LOGLEVEL=COMMONAPI_LOGLEVEL_${MAX_LOG_LEVEL})
if (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
set (OS "QNX")
set (NO_DEPRECATED_REGISTER "")
set (Boost_USE_STATIC_LIBS ON)
endif (${CMAKE_SYSTEM_NAME} MATCHES "QNX")
if (MSVC)
# Visual C++ is not always sure whether he is really C++
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS /EHsc /wd\\\"4503\\\"")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS /wd\\\"4503\\\"")
else()
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP -DQNX")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O0 -std=c++11 -D_GLIBCXX_USE_NANOSLEEP")
endif()
message(STATUS "Compiler options: ${CMAKE_CXX_FLAGS}")
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
"Choose the type of build, options are: Debug Release." FORCE)
endif(NOT CMAKE_BUILD_TYPE)
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
OPTION(USE_INSTALLED_COMMONAPI "Set to OFF to use the local (build tree) version of CommonAPI" ON)
message(STATUS "USE_INSTALLED_COMMONAPI is set to value: ${USE_INSTALLED_COMMONAPI}")
if ("${USE_INSTALLED_COMMONAPI}" STREQUAL "ON")
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
else()
FIND_PACKAGE(CommonAPI 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
#FIND_PACKAGE(CommonAPI-DBus 3.2.0 REQUIRED CONFIG NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
endif()
message(STATUS "CommonAPI_CONSIDERED_CONFIGS: ${CommonAPI_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_INCLUDE_DIRS: ${COMMONAPI_INCLUDE_DIRS}")
message(STATUS "CommonAPI-DBus_CONSIDERED_CONFIGS: ${CommonAPI-DBus_CONSIDERED_CONFIGS}")
message(STATUS "COMMONAPI_DBUS_INCLUDE_DIRS: ${COMMONAPI_DBUS_INCLUDE_DIRS}")
# CommonAPI
include(FindPkgConfig)
###############################################################################
# find DBus by using the 'pkg-config' tool
if (MSVC)
#Not beautiful, but it works
if (DBus_DIR)
if (DBus_BUILD_DIR)
set(DBus_INCLUDE_DIRS "${DBus_DIR};${DBus_BUILD_DIR};")
else ()
message (FATAL_ERROR "DBus_BUILD_DIR not set! Cannot continue.")
endif ()
else()
message (FATAL_ERROR "DBus_DIR not set! Cannot continue.")
endif ()
else()
# pkg_check_modules(DBus REQUIRED dbus-1>=1.4)
endif()
SYSR_INCLUDE_DIR(qcom-gps-utils)
SYSR_INCLUDE_DIR(location-client-api)
SYSR_INCLUDE_DIR(open-avb)
SYSR_INCLUDE_DIR(location-integration-api)
SYSR_INCLUDE_DIR(loc-diag-iface-hdr)
check_cxx_compiler_flag("-DPOWER_DAEMON_MGR_ENABLED" FLAG_POWER_DAEMON_MGR_ENABLED)
if (FLAG_POWER_DAEMON_MGR_ENABLED)
add_definitions(-DPOWER_DAEMON_MGR_ENABLED)
SYSR_INCLUDE_DIR(powermanager)
else()
message(STATUS "Flag -DPOWER_DAEMON_MGR_ENABLED is not supported.")
endif()
# SOME/IP
find_package (CommonAPI-SomeIP 3.2.0 REQUIRED)
find_package (vsomeip3 3.1.20 REQUIRED)
# Source Files
set(PRJ_SRC_PATH ../../src/LocIdlService)
set(PRJ_SRC_GEN_PATH ../../src-gen)
set(PRJ_SRC_GEN_COMMONAPI_PATH ${PRJ_SRC_GEN_PATH}/core/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_DBUS_PATH ${PRJ_SRC_GEN_PATH}/dbus/v0/com/qualcomm/qti/location)
set(PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH ${PRJ_SRC_GEN_PATH}/someip/v0/com/qualcomm/qti/location)
set(PRJ_NAME_SERVICE ${PRJ_NAME}Service)
# Application
FILE(GLOB PRJ_PROXY_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Proxy.cpp)
FILE(GLOB PRJ_STUB_GEN_SRCS ${PRJ_SRC_GEN_COMMONAPI_PATH}/*Stub*.cpp)
FILE(GLOB PRJ_STUB_IMPL_SRCS ${PRJ_SRC_COMMONAPI_PATH}/*Stub*.cpp)
set(PRJ_SERVICE_SRCS ${PRJ_SRC_PATH}/${PRJ_NAME_SERVICE}.cpp ${PRJ_SRC_PATH}/${PRJ_NAME}StubImpl.cpp ${PRJ_STUB_GEN_SRCS} ${PRJ_STUB_IMPL_SRCS} ${PRJ_SRC_PATH}/LocLcaIdlConverter.cpp ${PRJ_SRC_PATH}/LocIdlPowerEvtManager.cpp ${PRJ_SRC_PATH}/LocIdlServiceLog.cpp)
# Boost
#find_package( Boost 1.71 COMPONENTS system thread log REQUIRED )
include_directories( ${Boost_INCLUDE_DIR} )
# DBus library
FILE(GLOB PRJ_DBUS_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_DBUS_PATH}/*cpp)
# SOME/IP library
FILE(GLOB PRJ_SOMEIP_LIB_SRCS ${PRJ_SRC_GEN_COMMONAPI_SOMEIP_PATH}/*cpp)
# Paths
OPTION(USE_INSTALLED_DBUS "Set to OFF to use the local (patched) version of dbus" ON)
message(STATUS "USE_INSTALLED_DBUS is set to value: ${USE_INSTALLED_DBUS}")
include_directories(
../../src-gen/core
../../src-gen/someip
${COMMONAPI_INCLUDE_DIRS}
${COMMONAPI_SOMEIP_INCLUDE_DIRS}
${VSOMEIP_INCLUDE_DIRS}
)
if ("${USE_INSTALLED_DBUS}" STREQUAL "ON")
link_directories(
${COMMONAPI_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${Boost_LIBRARY_DIR}
)
else()
link_directories(
${COMMONAPI_LIBDIR}
${COMMONAPI_SOMEIP_CMAKE_DIR}/build
${DBus_INCLUDE_DIRS}/dbus/.libs
${Boost_LIBRARY_DIR}
)
endif()
if (MSVC)
set(LINK_LIBRARIES CommonAPI location_client_api gps_utils gptp location_integration_api log)
else()
set(LINK_LIBRARIES -Wl,--as-needed CommonAPI location_client_api gps_utils gptp location_integration_api log)
endif()
# Build service
add_executable(${PRJ_NAME_SERVICE} ${PRJ_SERVICE_SRCS})
if (FLAG_POWER_DAEMON_MGR_ENABLED)
target_link_libraries(${PRJ_NAME_SERVICE} ${LINK_LIBRARIES} powermanager)
else ()
target_link_libraries(${PRJ_NAME_SERVICE} ${LINK_LIBRARIES})
endif()
# Build DBus library
#add_library (${PRJ_NAME}-dbus SHARED ${PRJ_DBUS_LIB_SRCS})
#target_link_libraries(${PRJ_NAME}-dbus CommonAPI-DBus)
# Build SOME/IP library
add_library (${PRJ_NAME}-someip SHARED ${PRJ_SOMEIP_LIB_SRCS})
target_link_libraries(${PRJ_NAME}-someip CommonAPI-SomeIP)
install (
# TARGETS ${PRJ_NAME_CLIENT} ${PRJ_NAME_SERVICE}
TARGETS ${PRJ_NAME_SERVICE}
RUNTIME DESTINATION "${INSTALL_BIN_DIR}" COMPONENT bin)
install (
TARGETS ${PRJ_NAME}-someip
LIBRARY DESTINATION "${INSTALL_LIB_DIR}" COMPONENT shlib
)
set(EXAMPLE_CONFIG_FILES
"vsomeip-location.json"
"vsomeip-service.json"
"commonapi4someip.ini"
"vsomeip-local.json"
)
install (
FILES ${EXAMPLE_CONFIG_FILES} DESTINATION /etc COMPONENT config
)

896
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlAPIService.cpp Normal file
View File

@@ -0,0 +1,896 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
*/
#define LOG_TAG "LOC_IDL_SERVICE"
#include <iostream>
#include <thread>
#include <stdio.h>
#include <functional>
#include <stdint.h>
#include <unistd.h>
#include <inttypes.h>
#include <string.h>
#include <CommonAPI/CommonAPI.hpp>
#include "LocIdlAPIStubImpl.hpp"
#include "LocIdlAPIService.h"
#include "gptp_helper.h"
using namespace std;
using namespace v0::com::qualcomm::qti::location;
using namespace location_client;
static bool capabilitiesReceived = false;
static uint32_t posCount = 0;
static uint32_t latentPosCount = 0;
static bool exitFromMemUsageMsgTask = false;
/** Latency threshold for Position reports in msec */
#define MAX_POSITION_LATENCY 20
#define IDL_MAX_RETRY 5
static void onConfigResponseCb(location_integration::LocConfigTypeEnum requestType,
location_integration::LocIntegrationResponse response) {
LOC_LOGd("<<< onConfigResponseCb, type %d, err %d\n", requestType, response);
}
class LocationTrackingSessCbHandler {
public:
LocationTrackingSessCbHandler(const LocIdlAPIService *pClientApiService,
const uint32_t &reportCbMask) {
if (NULL != pClientApiService) {
LOC_LOGd(" ==== LocationTrackingSessCbHandler --> ");
memset(&mCallbackOptions, 0, sizeof(GnssReportCbs));
if (reportCbMask & LocIdlAPI::IDLGnssReportCbInfoMask::IDL_LOC_CB_INFO_BIT) {
mCallbackOptions.gnssLocationCallback =
[pClientApiService] (const ::GnssLocation n) {
//Convert Location report from LCA to FIDL format
if (pClientApiService->mLcaIdlConverter) {
LocIdlAPI::IDLLocationReport idlLocRpt =
pClientApiService->parseLocationReport(n);
posCount++;
struct timespec curBootTime = {};
clock_gettime(CLOCK_BOOTTIME, &curBootTime);
int64_t curBootTimeNs = ((int64_t)curBootTime.tv_sec * 1000000000) +
(int64_t)curBootTime.tv_nsec;
int16_t latencyMs = 0;
latencyMs = (int16_t)((curBootTimeNs - n.elapsedRealTimeNs)/1000000);
if (latencyMs > MAX_POSITION_LATENCY) {
latentPosCount++;
}
if (posCount % 600 == 0) {
LOC_LOGe("%"PRId64" out of %"PRId64" Position samples are"
" latent by 20 msec",
latentPosCount, posCount);
}
idlLocRpt.setReportingLatency(latencyMs);
if (pClientApiService->mDiagLogIface) {
pClientApiService->mDiagLogIface->diagLogGnssReportInfo(
OUTPUT_PVT_REPORT, latencyMs, latentPosCount);
}
if (pClientApiService->mService) {
pClientApiService->mService->fireLocationReportEvent(idlLocRpt);
}
}
};
}
if (reportCbMask &
LocIdlAPI::IDLGnssReportCbInfoMask::IDL_SV_CB_INFO_BIT) {
mCallbackOptions.gnssSvCallback =
[pClientApiService](const std::vector<::GnssSv>& gnssSvs) {
std::vector<LocIdlAPI::IDLGnssSv> idlSVReportVector;
LOC_LOGd("Number of SV's recevived -- %d", gnssSvs.size());
if (pClientApiService->mLcaIdlConverter) {
for (auto GnssSv : gnssSvs) {
//Convert Location report from LCA to FIDL format
LocIdlAPI::IDLGnssSv idlSVRpt =
pClientApiService->parseGnssSvReport(GnssSv);
idlSVReportVector.push_back(idlSVRpt);
}
if (pClientApiService->mService) {
pClientApiService->mService->fireGnssSvEvent(idlSVReportVector);
}
}
};
}
if (reportCbMask &
LocIdlAPI::IDLGnssReportCbInfoMask::IDL_NMEA_CB_INFO_BIT) {
mCallbackOptions.nmeaSentencesCallback =
[pClientApiService](::LocOutputEngineType engType,
uint64_t timestamp, const std::string nmea) {
if (pClientApiService->mService) {
pClientApiService->mService->fireGnssNmeaEvent(timestamp, nmea);
}
};
}
if (reportCbMask &
LocIdlAPI::IDLGnssReportCbInfoMask::IDL_1HZ_MEAS_CB_INFO_BIT) {
mCallbackOptions.gnssMeasurementsCallback =
[pClientApiService](const ::GnssMeasurements gnssMeasurements) {
if (pClientApiService->mLcaIdlConverter) {
LocIdlAPI::IDLGnssMeasurements idlGnssMeasurement =
pClientApiService->parseGnssMeasurements(gnssMeasurements);
struct timespec curBootTime = {};
clock_gettime(CLOCK_BOOTTIME, &curBootTime);
int64_t curBootTimeNs = ((int64_t)curBootTime.tv_sec * 1000000000) +
(int64_t)curBootTime.tv_nsec;
int16_t latencyMs = 0;
latencyMs = (int16_t)((curBootTimeNs -
gnssMeasurements.clock.elapsedRealTime)/1000000);
idlGnssMeasurement.setReportingLatency(latencyMs);
if (pClientApiService->mDiagLogIface) {
pClientApiService->mDiagLogIface->diagLogGnssReportInfo(
OUTPUT_MEAS_REPORT, latencyMs, 0);
}
if (pClientApiService->mService) {
pClientApiService->mService->fireGnssMeasurementsEvent(
idlGnssMeasurement);
}
}
};
}
// GnssDataCb
if (reportCbMask & LocIdlAPI::IDLGnssReportCbInfoMask::IDL_DATA_CB_INFO_BIT) {
mCallbackOptions.gnssDataCallback =
[pClientApiService] (const ::GnssData n) {
//Convert GnssData report from LCA to FIDL format
if (pClientApiService->mLcaIdlConverter) {
LocIdlAPI::IDLGnssData idlGnssDataRpt =
pClientApiService->parseGnssDataReport(n);
if (pClientApiService->mService) {
pClientApiService->mService->fireGnssDataEvent(idlGnssDataRpt);
}
}
};
}
}
}
LocationTrackingSessCbHandler(const LocIdlAPIService *pClientApiService,
const uint32_t &locReqEngMask, const uint32_t &engReportCallbackMask) {
if (NULL != pClientApiService) {
memset(&mEngineCallbackOptions, 0, sizeof(EngineReportCbs));
if (engReportCallbackMask &
LocIdlAPI::IDLEngineReportCbMask::IDL_ENGINE_LOCATION_CB_INFO_BIT) {
mEngineCallbackOptions.engLocationsCallback =
[pClientApiService] (const std::vector<::GnssLocation> &engLocations) {
if (pClientApiService->mLcaIdlConverter) {
std::vector<LocIdlAPI::IDLLocationReport> idlEngLocVector;
for (auto gnssLocation : engLocations) {
LocIdlAPI::IDLLocationReport idlLocRpt =
pClientApiService->parseLocationReport(gnssLocation);
idlEngLocVector.push_back(idlLocRpt);
}
if (pClientApiService->mService) {
pClientApiService->mService->fireEngineLocationsEvent(
idlEngLocVector);
}
}
};
}
//Fill LocReqEngMask
memset(&mLcaLocReqEngMask, 0, sizeof(location_client::LocReqEngineTypeMask));
uint32_t lcaLocReqEngMask = 0;
if (locReqEngMask &
LocIdlAPI::IDLLocReqEngineTypeMask::IDL_LOC_REQ_ENG_FUSED) {
lcaLocReqEngMask |= location_client::LOC_REQ_ENGINE_FUSED_BIT;
}
if (locReqEngMask & LocIdlAPI::IDLLocReqEngineTypeMask::IDL_LOC_REQ_ENG_SPE) {
lcaLocReqEngMask |= location_client::LOC_REQ_ENGINE_SPE_BIT;
}
if (locReqEngMask & LocIdlAPI::IDLLocReqEngineTypeMask::IDL_LOC_REQ_ENG_PPE) {
lcaLocReqEngMask |= location_client::LOC_REQ_ENGINE_PPE_BIT;
}
if (locReqEngMask & LocIdlAPI::IDLLocReqEngineTypeMask::IDL_LOC_REQ_ENG_VPE) {
lcaLocReqEngMask |= location_client::LOC_REQ_ENGINE_VPE_BIT;
}
mLcaLocReqEngMask = (location_client::LocReqEngineTypeMask)lcaLocReqEngMask;
}
}
GnssReportCbs& getLocationCbs() { return mCallbackOptions; }
EngineReportCbs& getEngineLocationCbs() { return mEngineCallbackOptions; }
location_client::LocReqEngineTypeMask& getLcaLocReqEngMask() { return mLcaLocReqEngMask; }
private:
GnssReportCbs mCallbackOptions;
EngineReportCbs mEngineCallbackOptions;
location_client::LocReqEngineTypeMask mLcaLocReqEngMask;
};
LocIdlAPI::IDLLocationReport LocIdlAPIService::parseLocationReport
(
const location_client::GnssLocation &lcaLoc
) const {
return (mLcaIdlConverter->parseLocReport(lcaLoc));
}
LocIdlAPI::IDLGnssSv LocIdlAPIService::parseGnssSvReport
(
const location_client::GnssSv& gnssSvs
) const {
return (mLcaIdlConverter->parseSvReport(gnssSvs));
}
LocIdlAPI::IDLGnssMeasurements LocIdlAPIService::parseGnssMeasurements
(
const location_client::GnssMeasurements& gnssMeasurements
) const {
return (mLcaIdlConverter->parseMeasurements(gnssMeasurements));
}
LocIdlAPI::IDLGnssData LocIdlAPIService::parseGnssDataReport
(
const location_client::GnssData& gnssData
) const {
return (mLcaIdlConverter->parseGnssData(gnssData));
}
LocIdlAPIService* LocIdlAPIService::mInstance = nullptr;
LocIdlAPIService* LocIdlAPIService::getInstance()
{
if (nullptr == mInstance) {
mInstance = new LocIdlAPIService();
}
return mInstance;
}
LocIdlAPIService::LocIdlAPIService():
mLcaInstance(nullptr),
mMsgTask(new MsgTask("LocIDLService")),
mLIAInstance(nullptr),
#ifdef POWER_DAEMON_MGR_ENABLED
mPowerEventObserver(nullptr),
#endif
mLcaIdlConverter(new LocLcaIdlConverter()),
mDiagLogIface(new LocIdlServiceLog()),
mGnssReportMask(0),
numControlRequests(0),
mMemoryMonitorMsgTask(new MsgTask("LocIDLServiceMem")),
serviceRegisterationStatus(false)
{
if (mDiagLogIface) {
mDiagLogIface->initializeDiagIface();
}
}
LocIdlAPIService::~LocIdlAPIService()
{
exitFromMemUsageMsgTask = true;
sleep(IDL_MEMORY_CHECK_INTERVAL_SEC);
}
void LocIdlAPIService::onPowerEvent(IDLPowerStateType powerEvent) {
LOC_LOGi("Recieved Power Event %d", powerEvent);
struct PowerEventMsg : public LocMsg {
LocIdlAPIService* mIDLService;
IDLPowerStateType mPowerEvent;
inline PowerEventMsg(LocIdlAPIService* IDLService,
IDLPowerStateType event) :
LocMsg(),
mIDLService(IDLService),
mPowerEvent(event){};
inline virtual void proc() const {
bool retVal = false;
uint8_t serviceStatus = SERVICE_STAUS_UNKNOWN;
if (mIDLService) {
switch (mPowerEvent) {
case POWER_STATE_SUSPEND:
case POWER_STATE_SHUTDOWN:
retVal = mIDLService->unRegisterWithFIDLService();
if (retVal) {
serviceStatus = UNREGISTER_SERVICE_SUCCESS;
mIDLService->serviceRegisterationStatus = false;
} else {
serviceStatus = UNREGISTER_SERVICE_FAILED;
mIDLService->serviceRegisterationStatus = true;
}
break;
case POWER_STATE_RESUME:
retVal = mIDLService->registerWithFIDLService();
if (retVal) {
serviceStatus = REGISTER_SERVICE_SUCCESS;
mIDLService->serviceRegisterationStatus = true;
} else {
serviceStatus =REGISTER_SERVICE_FAILED;
mIDLService->serviceRegisterationStatus = false;
}
break;
default:
LOC_LOGd(" Unknown Power Event: %d !!", mPowerEvent);
}
if (mIDLService->mDiagLogIface) {
mIDLService->mDiagLogIface->diagLogPowerEventInfo(mPowerEvent, serviceStatus);
}
}
}
};
mMsgTask->sendMsg(new PowerEventMsg(this, powerEvent));
}
void LocIdlAPIService::updateSystemStatus(uint32_t totalRss) {
bool gptpSyncStatus = false;
if (gptpInit()) {
gptpSyncStatus = gptpGetSyncStatus();
}
if (mDiagLogIface) {
mDiagLogIface->updateSystemHealth(totalRss, gptpSyncStatus);
}
}
void LocIdlAPIService::monitorMemoryUsage () {
struct MonitorMemoryUsageMsg : public LocMsg {
LocIdlAPIService* mIdlService;
inline MonitorMemoryUsageMsg(LocIdlAPIService* idlService):
LocMsg(),
mIdlService(idlService){};
inline virtual void proc() const {
const char *pFileName = "/proc/self/statm";
const uint16_t pageSize = 4; //4K
unsigned long size = 0, rssPages = 0, totalRSS = 0;
unsigned long share = 0, text = 0, lib = 0, data = 0, dt = 0;
if (mIdlService) {
do {
FILE *fp = fopen(pFileName, "r");
if (NULL != fp) {
if (7 == fscanf(fp, "%ld %ld %ld %ld %ld %ld %ld",
&size, &rssPages, &share, &text, &lib, &data, &dt)) {
totalRSS = rssPages * pageSize;
mIdlService->updateSystemStatus(totalRSS);
} else {
LOC_LOGe("Failed to read data from %s!! error: %s",
pFileName, strerror(errno));
}
fclose(fp);
} else {
LOC_LOGe("Failed to open the file %s!! error: %s",
pFileName, strerror(errno));
} if (exitFromMemUsageMsgTask) {
LOC_LOGd("Normal exit from monitorMemoryUsage");
break;
}
sleep(IDL_MEMORY_CHECK_INTERVAL_SEC); //Sleep and re-attempt
} while (true);
LOC_LOGe("Exiting monitorMemoryUsage...!");
}
}
};
mMemoryMonitorMsgTask->sendMsg(new MonitorMemoryUsageMsg(this));
}
bool LocIdlAPIService::init()
{
struct InitMsg : public LocMsg {
LocIdlAPIService* mLCAService;
inline InitMsg(LocIdlAPIService* LCAService) :
LocMsg(),
mLCAService(LCAService){};
inline virtual void proc() const {
if (mLCAService) {
mLCAService->createLocIdlService();
mLCAService->monitorMemoryUsage();
}
}
};
mMsgTask->sendMsg(new InitMsg(this));
return true;
}
bool LocIdlAPIService::createLocIdlService()
{
LOC_LOGe("Initializing IDL Service ");
// Create LCA object
if (!mLcaInstance) {
//Create capability callback
CapabilitiesCb capabilitiesCb = [pClientApiService=this] (::LocationCapabilitiesMask mask) {
LOC_LOGe("<<< onCapabilitiesCb mask=0x%" PRIx64 "", mask);
LOC_LOGd("<<< onCapabilitiesCb mask string=%s ",
LocationClientApi::capabilitiesToString(mask).c_str());
pClientApiService->processCapabilities(mask);
if (pClientApiService->mDiagLogIface)
pClientApiService->mDiagLogIface->diagLogCapabilityInfo(
LocationClientApi::capabilitiesToString(mask));
};
// Create LCA instance
mLcaInstance = new LocationClientApi(capabilitiesCb);
LOC_LOGi (" LCA instance created Successfully ");
}
if (nullptr == mLIAInstance) {
LocConfigPriorityMap priorityMap;
LocIntegrationCbs intCbs;
intCbs.configCb = LocConfigCb(onConfigResponseCb);
mLIAInstance = new LocationIntegrationApi(priorityMap, intCbs);
LOC_LOGi (" LIA instance created Successfully ");
}
#ifdef POWER_DAEMON_MGR_ENABLED
if (nullptr == mPowerEventObserver && mInstance != NULL) {
mPowerEventObserver = LocIdlPowerEvtHandler::getPwrEvtHandler(mInstance);
if (nullptr == mPowerEventObserver) {
LOC_LOGe(" mPowerEventObserver null !! ");
}
}
#endif
serviceRegisterationStatus = registerWithFIDLService();
return true;
}
bool LocIdlAPIService::processCapabilities(::LocationCapabilitiesMask mask)
{
struct ProcessCapsMsg : public LocMsg {
LocIdlAPIService* mLCAService;
::LocationCapabilitiesMask mMask;
string mCapsMask;
inline ProcessCapsMsg(LocIdlAPIService* LCAService,
::LocationCapabilitiesMask mask, string capsMask) :
LocMsg(),
mLCAService(LCAService),
mMask(mask),
mCapsMask(capsMask){};
inline virtual void proc() const {
//convert capabilities from LCA to FIDL format
uint32_t idlCapsMask = 0;
if (mMask & LOCATION_CAPS_TIME_BASED_TRACKING_BIT) {
idlCapsMask |= LocIdlAPI::IDLLocationCapabilitiesMask::\
IDL_CAPS_TIME_BASED_TRACKING_BIT;
}
if (mMask & LOCATION_CAPS_GNSS_MEASUREMENTS_BIT) {
idlCapsMask |= LocIdlAPI::IDLLocationCapabilitiesMask::IDL_CAPS_GNSS_MEAS_BIT;
}
//Update Capabilities to clients
if (mLCAService->mService) {
mLCAService->mService->fireGnssCapabilitiesMaskAttributeChanged(idlCapsMask);
mLCAService->mDiagLogIface->diagLogCapabilityInfo(mCapsMask);
} else {
LOC_LOGe("mLCAService->mService == NULL !! \n");
}
}
};
mMsgTask->sendMsg(new ProcessCapsMsg(this, mask,
LocationClientApi::capabilitiesToString(mask)));
return true;
}
bool LocIdlAPIService::registerWithFIDLService()
{
LOC_LOGe("Registering IDL Service ");
CommonAPI::Runtime::setProperty("LogContext", "LOCIDL");
CommonAPI::Runtime::setProperty("LogApplication", "LOCIDL");
CommonAPI::Runtime::setProperty("LibraryBase", "LocIdlAPI");
std::shared_ptr<CommonAPI::Runtime> runtime = CommonAPI::Runtime::get();
std::string domain = "local";
std::string instance = "com.qualcomm.qti.location.LocIdlAPI";
std::string connection = "location-fidl-service";
bool successfullyRegistered = false;
if (!serviceRegisterationStatus) {
mService = std::make_shared<LocIdlAPIStubImpl>(this);
if (runtime && mService) {
successfullyRegistered = runtime->registerService(domain, instance,
mService, connection);
while (!successfullyRegistered) {
LOC_LOGe("Register IDL Service failed, trying again in 100 milliseconds !!");
std::this_thread::sleep_for(std::chrono::milliseconds(100));
successfullyRegistered = runtime->registerService(domain,
instance, mService, connection);
}
LOC_LOGd("Successfully Registered Service!");
} else {
LOC_LOGe(" Either mService or runtime is NULL !! ");
}
} else {
successfullyRegistered = true;
}
return successfullyRegistered;
}
bool LocIdlAPIService::unRegisterWithFIDLService()
{
LOC_LOGi("UnRegistering IDL Service ");
std::shared_ptr<CommonAPI::Runtime> runtime = CommonAPI::Runtime::get();
std::string domain = "local";
std::string instance = "com.qualcomm.qti.location.LocIdlAPI";
std::string connection = "location-fidl-service";
bool successfullyUnRegistered = false;
if (serviceRegisterationStatus) {
successfullyUnRegistered = runtime->unregisterService(domain,
v0::com::qualcomm::qti::location::LocIdlAPI::getInterface(), instance);
uint8_t count = 1;
while (!successfullyUnRegistered && count <= IDL_MAX_RETRY) {
LOC_LOGi("UnRegister IDL Service failed, No. of retires: %d !!", count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
successfullyUnRegistered = runtime->unregisterService(domain,
v0::com::qualcomm::qti::location::LocIdlAPI::getInterface(), instance);
count++;
}
LOC_LOGi("Successfully UnRegistered Service!");
}
return successfullyUnRegistered;
}
LocIdlAPI::IDLLocationResponse LocIdlAPIService::parseIDLResponse(
const location_client::LocationResponse lcaResponse) const {
LocIdlAPI::IDLLocationResponse resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
switch (lcaResponse) {
case LOCATION_RESPONSE_SUCCESS:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_SUCCESS;
break;
case LOCATION_RESPONSE_UNKOWN_FAILURE:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKOWN_FAILURE;
break;
case LOCATION_RESPONSE_NOT_SUPPORTED:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_NOT_SUPPORTED;
break;
case LOCATION_RESPONSE_PARAM_INVALID:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_PARAM_INVALID;
break;
case LOCATION_RESPONSE_TIMEOUT:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_TIMEOUT;
break;
case LOCATION_RESPONSE_REQUEST_ALREADY_IN_PROGRESS:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_REQUEST_ALREADY_IN_PROGRESS;
break;
case LOCATION_RESPONSE_SYSTEM_NOT_READY:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_SYSTEM_NOT_READY;
break;
case LOCATION_RESPONSE_EXCLUSIVE_SESSION_IN_PROGRESS:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_EXCLUSIVE_SESSION_IN_PROGRESS;
break;
default:
resp = LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKNOWN;
}
return resp;
}
/* Process Fused/Detailed Position request */
void LocIdlAPIService::startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs, uint32_t gnssReportCallbackMask,
LocIdlAPIStub::startPositionSessionReply_t reply
) const
{
struct StartFusedPosMsg : public LocMsg {
const LocIdlAPIService* mLCAService;
const std::shared_ptr<CommonAPI::ClientId> mClient;
uint32_t mIntervalInMs;
uint32_t mGnssReportCbMask;
LocIdlAPIStub::startPositionSession1Reply_t mReply;
inline StartFusedPosMsg(const LocIdlAPIService* LCAService,
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs,
uint32_t gnssReportCallbackMask,
LocIdlAPIStub::startPositionSession1Reply_t reply) :
LocMsg(),
mLCAService(LCAService),
mClient(client),
mIntervalInMs(intervalInMs),
mGnssReportCbMask(gnssReportCallbackMask),
mReply(reply){};
inline virtual void proc() const {
if (mLCAService) {
mLCAService->numControlRequests++;
mLCAService->mGnssReportMask |= mGnssReportCbMask;
LOC_LOGi("==== startPositionSession intervalMs %u GnssReportCbMask 0X%X"
" LCAReportMask 0X%X numControlRequests %u", mIntervalInMs,
mGnssReportCbMask, mLCAService->mGnssReportMask,
mLCAService->numControlRequests);
LocationTrackingSessCbHandler cbHandler(mLCAService, mLCAService->mGnssReportMask);
ResponseCb rspCb = [client=mClient, reply=mReply] (::LocationResponse response) {
LOC_LOGd("==== responseCb %d", response);
//convert response from LCA to FIDL format
LocIdlAPI::IDLLocationResponse resp = mInstance->parseIDLResponse(response);
reply(resp);
};
if (mLCAService->mLcaInstance) {
mLCAService->mLcaInstance->startPositionSession(mIntervalInMs,
cbHandler.getLocationCbs(), rspCb);
}
diagControlCommandInfo idlSessionInfo = {};
idlSessionInfo.sessionRequestType = SESSION_START_REQUEST;
idlSessionInfo.intervalMs = mIntervalInMs;
idlSessionInfo.requestedCallbackMask = mGnssReportCbMask;
idlSessionInfo.updatedCallbackMask = mLCAService->mGnssReportMask;
idlSessionInfo.numControlRequests = mLCAService->numControlRequests;
if (mLCAService->mDiagLogIface) {
mLCAService->mDiagLogIface->diagLogSessionInfo(idlSessionInfo,
mClient->hashCode());
}
}
}
};
mMsgTask->sendMsg(new StartFusedPosMsg(this, client, intervalInMs,
gnssReportCallbackMask, reply));
}
/* Process Engine specific Position request */
void LocIdlAPIService::startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs, uint32_t locReqEngMask, uint32_t engReportCallbackMask,
LocIdlAPIStub::startPositionSession1Reply_t reply
) const
{
struct StartPosMsg : public LocMsg {
const LocIdlAPIService* mLCAService;
const std::shared_ptr<CommonAPI::ClientId> mClient;
uint32_t mIntervalInMs;
uint32_t mLocReqEngMask;
uint32_t mEngReportCallbackMask;
LocIdlAPIStub::startPositionSession1Reply_t mReply;
inline StartPosMsg(const LocIdlAPIService* LCAService,
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs,
uint32_t locReqEngMask,
uint32_t engReportCallbackMask,
LocIdlAPIStub::startPositionSession1Reply_t reply) :
LocMsg(),
mLCAService(LCAService),
mClient(client),
mIntervalInMs(intervalInMs),
mLocReqEngMask(locReqEngMask),
mEngReportCallbackMask(engReportCallbackMask),
mReply(reply){};
inline virtual void proc() const {
if (mLCAService) {
mLCAService->numControlRequests++;
LOC_LOGi("==== startPositionSession Engine Specific %u 0X%X 0X%X ",
mIntervalInMs, mLocReqEngMask, mEngReportCallbackMask);
LocationTrackingSessCbHandler cbHandler(mLCAService, mLocReqEngMask,
mEngReportCallbackMask);
ResponseCb rspCb = [client=mClient, reply=mReply] (::LocationResponse response) {
LOC_LOGd("==== responseCb %d", response);
//convert response from LCA to FIDL format
LocIdlAPI::IDLLocationResponse resp = mInstance->parseIDLResponse(response);
reply(resp);
};
if (mLCAService->mLcaInstance) {
mLCAService->mLcaInstance->startPositionSession(mIntervalInMs,
cbHandler.getLcaLocReqEngMask(),
cbHandler.getEngineLocationCbs(),
rspCb);
}
}
}
};
mMsgTask->sendMsg(new StartPosMsg(this, client, intervalInMs,
locReqEngMask, engReportCallbackMask, reply));
}
void LocIdlAPIService::stopPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPIStub::stopPositionSessionReply_t reply
) const
{
struct StopPosMsg : public LocMsg {
const LocIdlAPIService* mLCAService;
const std::shared_ptr<CommonAPI::ClientId> mClient;
LocIdlAPIStub::stopPositionSessionReply_t mReply;
inline StopPosMsg(const LocIdlAPIService* LCAService,
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPIStub::stopPositionSessionReply_t reply) :
LocMsg(),
mLCAService(LCAService),
mClient(client),
mReply(reply){};
inline virtual void proc() const {
if (mLCAService) {
if (mLCAService->numControlRequests > 0) {
mLCAService->numControlRequests--;
diagControlCommandInfo idlSessionInfo = {};
idlSessionInfo.sessionRequestType = SESSION_STOP_REQUEST;
idlSessionInfo.numControlRequests = mLCAService->numControlRequests;
if (mLCAService->mDiagLogIface) {
mLCAService->mDiagLogIface->diagLogSessionInfo(
idlSessionInfo, mClient->hashCode());
}
if (!mLCAService->numControlRequests) {
LOC_LOGd(" Sending STOP Session request !!");
mLCAService->mLcaInstance->stopPositionSession();
posCount = 0;
latentPosCount = 0;
mLCAService->mGnssReportMask = 0;
}
} else {
LOC_LOGe(" Faulty STOP request numOfRequests %d",
mLCAService->numControlRequests);
}
}
mReply();
}
};
mMsgTask->sendMsg(new StopPosMsg(this, client, reply));
}
void LocIdlAPIService::LIAdeleteAidingData
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t aidingDataMask,
LocIdlAPIStub::deleteAidingDataReply_t reply
) const
{
uint16_t mask = aidingDataMask;
LOC_LOGd(" DeleteAssistance Mask recieved: %x ", mask);
if (mLIAInstance) {
bool ret = mLIAInstance->deleteAidingData((location_integration::\
AidingDataDeletionMask)mask);
if (ret) {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_SUCCESS);
} else {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKOWN_FAILURE);
}
}
if (mDiagLogIface) {
mDiagLogIface->diagLogDeleteAidingRequest(client->hashCode(), aidingDataMask);
}
}
void LocIdlAPIService::LIAconfigConstellations
(
const std::shared_ptr<CommonAPI::ClientId> client,
std::vector< LocIdlAPI::IDLGnssSvIdInfo > svListSrc,
LocIdlAPIStub::configConstellationsReply_t reply
) const
{
LOC_LOGd(" ");
location_integration::LocConfigBlacklistedSvIdList svList;
for (int i = 0; i < svListSrc.size(); i++) {
location_integration::GnssSvIdInfo svIdConstellation = {};
switch (svListSrc[i].getConstellation()) {
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_GLONASS:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_GLONASS;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_QZSS:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_QZSS;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_BEIDOU:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_BEIDOU;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_GALILEO:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_GALILEO;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_SBAS:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_SBAS;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_NAVIC:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_NAVIC;
break;
case LocIdlAPI::IDLGnssConstellationType::IDL_GNSS_CONSTELLATION_TYPE_GPS:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_GPS;
break;
default:
svIdConstellation.constellation = location_integration::\
GNSS_CONSTELLATION_TYPE_MAX;
}
svIdConstellation.svId = svListSrc[i].getSvId();
svList.push_back(svIdConstellation);
}
if (mLIAInstance) {
bool retVal = mLIAInstance->configConstellations(&svList);
if (retVal) {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_SUCCESS);
} else {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKOWN_FAILURE);
}
}
if (mDiagLogIface) {
mDiagLogIface->diagLogConfigConstellationRequest(client->hashCode(), svListSrc);
}
}
void LocIdlAPIService::injectMapMatchedFeedbackData
(
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPI::MapMatchingFeedbackData& mapData,
LocIdlAPIStub::injectMapMatchedFeedbackDataReply_t reply
) const
{
location_integration::mapMatchedFeedbackData mmfData = {};
mmfData.validityMask = mapData.getValidityMask();
mmfData.utcTimestampMs = mapData.getUtcTimestampMs();
mmfData.mapMatchedLatitudeDifference = mapData.getMapMatchedLatitudeDifference();
mmfData.mapMatchedLongitudeDifference = mapData.getMapMatchedLongitudeDifference();
mmfData.isTunnel = mapData.getIsTunnel();
mmfData.bearing = mapData.getBearing();
mmfData.altitude = mapData.getAltitude();
mmfData.horizontalAccuracy = mapData.getHorizontalAccuracy();
mmfData.altitudeAccuracy = mapData.getAltitudeAccuracy();
mmfData.bearingAccuracy = mapData.getBearingAccuracy();
if (mLIAInstance) {
bool retVal = mLIAInstance->injectMapMatchedData(mmfData);
if (retVal) {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_SUCCESS);
} else {
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_UNKOWN_FAILURE);
}
}
}
int main() {
LocIdlAPIService *pLCAService = LocIdlAPIService::getInstance();
if (pLCAService) {
pLCAService->init();
}
if (gptpInit()) {
LOC_LOGd(" GPTP init success ");
} else {
LOC_LOGe(" GPTP init failed ");
}
// Waiting for calls
int fd[2], n = 0;
char buffer[10];
if (pipe(fd) != -1) {
n = read(fd[0], buffer, 10);
if (n > 0) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
return 0;
}

193
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlAPIService.h Normal file
View File

@@ -0,0 +1,193 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 LOCATIOCLIENTAPI_SERVICE_H
#define LOCATIOCLIENTAPI_SERVICE_H
#include <CommonAPI/CommonAPI.hpp>
#include "LocIdlAPIStubImpl.hpp"
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
#include "LocationClientApi.h"
#include "MsgTask.h"
#include "log_util.h"
#include "LocLcaIdlConverter.h"
#include "LocationIntegrationApi.h"
#include "LocIdlServiceLog.h"
#ifdef POWER_DAEMON_MGR_ENABLED
#include "LocIdlPowerEvtManager.h"
#endif
using namespace location_client;
using namespace v0::com::qualcomm::qti::location;
using namespace std;
using namespace loc_util;
using namespace location_integration;
#define IDL_MEMORY_CHECK_INTERVAL_SEC (2)
// Enum to define supported Power states in power-daemon
enum IDLPowerStateType {
IDL_POWER_STATE_UNKNOWN = 0,
IDL_POWER_STATE_SUSPEND = 1,
IDL_POWER_STATE_RESUME = 2,
IDL_POWER_STATE_SHUTDOWN = 3,
IDL_POWER_STATE_DEEP_SLEEP_ENTRY = 4,
IDL_POWER_STATE_DEEP_SLEEP_EXIT = 5
};
#ifdef POWER_DAEMON_MGR_ENABLED
class LocIdlPowerEvtHandler;
#endif
class LocIdlAPIStubImpl;
class LocIdlServiceLog;
class LocIdlAPIService {
public:
std::shared_ptr<LocIdlAPIStubImpl> mService;
// singleton instance
static LocIdlAPIService* getInstance();
bool init();
bool createLocIdlService();
bool registerWithFIDLService();
bool unRegisterWithFIDLService();
bool processCapabilities(::LocationCapabilitiesMask mask);
/* Process Fused/Detailed Position request */
void startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t _intervalInMs, uint32_t gnssReportCallbackMask,
LocIdlAPIStub::startPositionSessionReply_t reply
) const;
/* Process Engine specific Position request */
void startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs, uint32_t locReqEngMask, uint32_t engReportCallbackMask,
LocIdlAPIStub::startPositionSession1Reply_t reply
) const;
void stopPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPIStub::stopPositionSessionReply_t reply
) const;
void LIAdeleteAidingData
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t aidingDataMask,
LocIdlAPIStub::deleteAidingDataReply_t reply
) const;
/// This is the method that will be called on remote calls on the method configConstellations.
void LIAconfigConstellations
(
const std::shared_ptr<CommonAPI::ClientId> client,
std::vector< LocIdlAPI::IDLGnssSvIdInfo > svList,
LocIdlAPIStub::configConstellationsReply_t reply
) const;
LocIdlAPI::IDLLocationReport parseLocationReport
(
const ::GnssLocation &lcaLoc
) const;
LocIdlAPI::IDLGnssSv parseGnssSvReport
(
const location_client::GnssSv& gnssSvs
) const;
LocIdlAPI::IDLGnssMeasurements parseGnssMeasurements
(
const location_client::GnssMeasurements& gnssMeasurements
) const;
LocIdlAPI::IDLGnssData parseGnssDataReport
(
const location_client::GnssData& gnssData
) const;
LocIdlAPI::IDLLocationResponse parseIDLResponse
(
const location_client::LocationResponse lcaResponse
) const;
void onPowerEvent(IDLPowerStateType powerEvent);
void injectMapMatchedFeedbackData
(
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPI::MapMatchingFeedbackData& mapData,
LocIdlAPIStub::injectMapMatchedFeedbackDataReply_t reply
) const;
/** To start a new thread to monito memory
* usahe every 2second by LocIDlService */
void monitorMemoryUsage();
/** To pass the system health status to Diag structure */
void updateSystemStatus(uint32_t totalRss);
#ifdef POWER_DAEMON_MGR_ENABLED
LocIdlPowerEvtHandler* mPowerEventObserver;
#endif
LocIdlServiceLog* mDiagLogIface;
LocLcaIdlConverter* mLcaIdlConverter;
private:
static LocIdlAPIService *mInstance;
LocationClientApi* mLcaInstance;
MsgTask* mMsgTask;
MsgTask* mMemoryMonitorMsgTask;
LocationIntegrationApi* mLIAInstance;
mutable uint32_t mGnssReportMask;
/** Keep cont of number of start session requests, this variable
* shall be incremented on each startSession and decremented on
* every stop Session, Stop session request shall be sent to LCA
* only if this variable is 0 */
mutable uint32_t numControlRequests;
/** Keeps track if service is registered or not
* True: Service registered Successfully
* False: Service not registered */
mutable bool serviceRegisterationStatus;
LocIdlAPIService();
~LocIdlAPIService();
};
#endif //LOCATIOCLIENTAPI_SERVICE_H

127
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlAPIStubImpl.cpp Normal file
View File

@@ -0,0 +1,127 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 <functional>
#include <stdint.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>
#include <LocationClientApi.h>
#include "LocIdlAPIStubImpl.hpp"
#include <time.h>
#define NSEC_IN_ONE_SEC (1000000000ULL) /* nanosec in a sec */
using namespace v0::com::qualcomm::qti::location;
using namespace location_client;
LocIdlAPIStubImpl::LocIdlAPIStubImpl(const LocIdlAPIService* apiService):
mApiService(apiService){
}
LocIdlAPIStubImpl::~LocIdlAPIStubImpl() {
}
const uint32_t & LocIdlAPIStubImpl::getGnssCapabilitiesMaskAttribute (
const std::shared_ptr<CommonAPI::ClientId> client
)
{
return mCapsMask;
}
void LocIdlAPIStubImpl::startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs, uint32_t gnssReportCallbackMask,
startPositionSessionReply_t reply
)
{
std::cout << "==== startPositionSession1 _intervalInMs " << intervalInMs <<\
"_gnssReportCallbackMask " << gnssReportCallbackMask << std::endl;
if (mApiService) {
mApiService->startPositionSession(client, intervalInMs, gnssReportCallbackMask, reply);
}
}
void LocIdlAPIStubImpl::startPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs, uint32_t locReqEngMask,
uint32_t engReportCallbackMask, startPositionSession1Reply_t reply
)
{
std::cout << "==== startPositionSession2 _intervalInMs " << intervalInMs\
<< " locReqEngMask " << locReqEngMask << std::endl;
if (mApiService) {
mApiService->startPositionSession(client, intervalInMs, engReportCallbackMask, reply);
}
}
void LocIdlAPIStubImpl::stopPositionSession
(
const std::shared_ptr<CommonAPI::ClientId> client,
stopPositionSessionReply_t reply
)
{
if (mApiService) {
mApiService->stopPositionSession(client, reply);
}
reply();
}
void LocIdlAPIStubImpl::deleteAidingData(const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t aidingDataMask,
deleteAidingDataReply_t reply) {
if (mApiService) {
mApiService->LIAdeleteAidingData(client, aidingDataMask, reply);
}
}
/// This is the method that will be called on remote calls on the method configConstellations.
void LocIdlAPIStubImpl::configConstellations(const std::shared_ptr<CommonAPI::ClientId> client,
std::vector< LocIdlAPI::IDLGnssSvIdInfo > svList,
configConstellationsReply_t reply) {
// This API is currently not supported.
reply(LocIdlAPI::IDLLocationResponse::IDL_LOC_RESP_NOT_SUPPORTED);
}
void LocIdlAPIStubImpl::injectMapMatchedFeedbackData(
const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPI::MapMatchingFeedbackData mmfData, injectMapMatchedFeedbackDataReply_t reply) {
if (mApiService) {
mApiService->injectMapMatchedFeedbackData(client, mmfData, reply);
}
}

92
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlAPIStubImpl.hpp Normal file
View File

@@ -0,0 +1,92 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 LOCIDLAPISTUBIMPL_HPP
#define LOCIDLAPISTUBIMPL_HPP
#include <iostream>
#include <thread>
#include <stdio.h>
#include <CommonAPI/CommonAPI.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPI.hpp>
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
#include "LocIdlAPIService.h"
using namespace std;
using namespace v0::com::qualcomm::qti::location;
class LocIdlAPIService;
class LocIdlAPIStubImpl: public v0::com::qualcomm::qti::location::LocIdlAPIStub {
public:
virtual const CommonAPI::Version& getInterfaceVersion(
std::shared_ptr<CommonAPI::ClientId> client)
{
return CommonAPI::Version(0, 1);
}
virtual const uint32_t &getGnssCapabilitiesMaskAttribute(
const std::shared_ptr<CommonAPI::ClientId> client);
/// This is the method that will be called on remote calls on the method startPositionSession.
virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs,
uint32_t gnssReportCallbackMask, startPositionSessionReply_t reply);
/// This is the method that will be called on remote calls on the method startPositionSession.
virtual void startPositionSession(const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t intervalInMs,
uint32_t locReqEngMask, uint32_t engReportCallbackMask,
startPositionSession1Reply_t reply);
virtual void stopPositionSession(const std::shared_ptr<CommonAPI::ClientId> client,
stopPositionSessionReply_t reply);
virtual void deleteAidingData(const std::shared_ptr<CommonAPI::ClientId> client,
uint32_t aidingDataMask,
deleteAidingDataReply_t reply);
/// This is the method that will be called on remote calls on the method configConstellations.
virtual void configConstellations(const std::shared_ptr<CommonAPI::ClientId> client,
std::vector< LocIdlAPI::IDLGnssSvIdInfo > svList,
configConstellationsReply_t reply);
virtual void injectMapMatchedFeedbackData(const std::shared_ptr<CommonAPI::ClientId> client,
LocIdlAPI::MapMatchingFeedbackData mmfData, injectMapMatchedFeedbackDataReply_t reply);
uint32_t mCapsMask;
const LocIdlAPIService* mApiService;
LocIdlAPIStubImpl(const LocIdlAPIService* apiService);
~LocIdlAPIStubImpl();
};
#endif // LOCIDLAPISTUBIMPL_HPP

93
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlPowerEvtManager.cpp Normal file
View File

@@ -0,0 +1,93 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "IDL_POWER_HANDLER"
#ifdef POWER_DAEMON_MGR_ENABLED
#include <unistd.h>
#include "LocIdlPowerEvtManager.h"
#define ACK_TIMEOUT_US 300000 // 300 msec
LocIdlAPIService* LocIdlPowerEvtHandler::mLocationApiService = nullptr;
LocIdlPowerEvtHandler* LocIdlPowerEvtHandler::getPwrEvtHandler(LocIdlAPIService* locServiceApiObj) {
mLocationApiService = locServiceApiObj;
static LocIdlPowerEvtHandler instance;
return &instance;
}
LocIdlPowerEvtHandler::LocIdlPowerEvtHandler() {
int ret = pwr_state_notification_register(LocIdlPowerEvtHandler::pwrMngrLibStateCb);
}
LocIdlPowerEvtHandler::~LocIdlPowerEvtHandler() {
}
int LocIdlPowerEvtHandler::pwrMngrLibStateCb(power_state_t pwr_state) {
client_ack_t client_ack;
client_ack.ack = ERR;
IDLPowerStateType powerState = IDL_POWER_STATE_UNKNOWN;
LOC_LOGe("Received powerState %d", pwr_state);
switch (pwr_state.sys_state) {
case SYS_SUSPEND:
client_ack.ack = SUSPEND_ACK;
powerState = IDL_POWER_STATE_SUSPEND;
break;
case SYS_RESUME:
client_ack.ack = RESUME_ACK;
powerState = IDL_POWER_STATE_RESUME;
break;
case SYS_SHUTDOWN:
client_ack.ack = SHUTDOWN_ACK;
powerState = IDL_POWER_STATE_SHUTDOWN;
break;
}
if (powerState != IDL_POWER_STATE_UNKNOWN) {
if (mLocationApiService) {
mLocationApiService->onPowerEvent(powerState);
}
}
//Allow some time to stop the session and write calibration data NVM.
usleep(ACK_TIMEOUT_US);
LOC_LOGd("LocIdlPowerEvtHandler: pwrStateCb sending ack");
send_acknowledgement(client_ack);
return 0;
}
#endif

58
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlPowerEvtManager.h Normal file
View File

@@ -0,0 +1,58 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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_IDL_POWER_EVENT_MANAGER_H_
#define LOC_IDL_POWER_EVENT_MANAGER_H_
#ifdef POWER_DAEMON_MGR_ENABLED
#include <power_state.h>
#endif
#include <log_util.h>
#include "LocIdlAPIService.h"
class LocIdlAPIService;
class LocIdlPowerEvtHandler
{
public:
static LocIdlPowerEvtHandler* getPwrEvtHandler(LocIdlAPIService*);
~LocIdlPowerEvtHandler();
static int pwrMngrLibStateCb(power_state_t pwr_state);
private:
LocIdlPowerEvtHandler();
static LocIdlAPIService* mLocationApiService;
};
#endif //LOC_IDL_POWER_EVENT_MANAGER_H_

252
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlServiceLog.cpp Normal file
View File

@@ -0,0 +1,252 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "LocIdlServiceLog.h"
static LocDiagInterface *locDiagIfaceHandle = nullptr;
bool LocIdlServiceLog::initializeDiagIface()
{
LOC_LOGd("");
bool retVal = true;
if (nullptr == locDiagIfaceHandle) {
locDiagIfaceHandle = loadLocDiagIfaceInterface();
if (nullptr == locDiagIfaceHandle) {
LOC_LOGe("Failed to loadLocDiagIfaceInterface!!");
retVal = false;
}
}
return retVal;
}
void LocIdlServiceLog::updateSystemHealth(uint32_t totalRss, bool gptpSyncStatus) {
mTotalRss = totalRss;
mGptpSyncStatus = gptpSyncStatus;
}
void LocIdlServiceLog::populateIdlDiagHeaderInfo(diagServiceGenericHeader& idlHeader) {
idlHeader.version = LOG_LOCATION_IDL_SERVICE_REPORT_VERSION;
idlHeader.idlServiceRssStats = mTotalRss;
idlHeader.gptpSyncStatus = mGptpSyncStatus;
}
void LocIdlServiceLog::diagLogGnssReportInfo(uint8_t reportType, int16_t latencyMs,
uint32_t latentReportCount) {
size_t size = 0;
diagServiceInfoStruct* gnssReportInfo = NULL;
diagBuffSrc bufferSrc;
size = sizeof(diagServiceInfoStruct)- sizeof(gnssReportInfo->serviceReport) +
sizeof(diagOutputGnssReportInfo);
if (locDiagIfaceHandle) {
gnssReportInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (gnssReportInfo) {
gnssReportInfo->serviceInfoType = GNSS_REPORT_INFO;
populateIdlDiagHeaderInfo(gnssReportInfo->header);
gnssReportInfo->serviceReport.reportInfo.reportType =
(diagServiceOutputReportType)reportType;
gnssReportInfo->serviceReport.reportInfo.packetLatencyTime = latencyMs;
gnssReportInfo->serviceReport.reportInfo.latentReportCount = latentReportCount;
locDiagIfaceHandle->logCommit(gnssReportInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for Delete Aiding Request !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
void LocIdlServiceLog::diagLogConfigConstellationRequest(uint64_t clientIdentifier,
vector< LocIdlAPI::IDLGnssSvIdInfo > svListSrc) {
size_t size = 0;
diagServiceInfoStruct* svListInfo = NULL;
diagBuffSrc bufferSrc;
uint16_t numSvReceived = svListSrc.size();
size = sizeof(diagServiceInfoStruct)- sizeof(svListInfo->serviceReport) +
sizeof(uint8_t) + sizeof(diagGnssSvIdInfo)*numSvReceived;
if (locDiagIfaceHandle) {
svListInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (svListInfo) {
svListInfo->header.clientIdentifier = clientIdentifier;
svListInfo->serviceInfoType = CONFIG_API_ACCESS_INFO;
populateIdlDiagHeaderInfo(svListInfo->header);
svListInfo->serviceReport.configApiInfo.requestType = CONFIG_CONSTELLATIONS_REQUEST;
for (int i = 0; i < numSvReceived; i++) {
svListInfo->serviceReport.configApiInfo.configData.svList[i].constellationType =
svListSrc[i].getConstellation();
svListInfo->serviceReport.configApiInfo.configData.svList[i].svId =
svListSrc[i].getSvId();
}
locDiagIfaceHandle->logCommit(svListInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for Delete Aiding Request !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
void LocIdlServiceLog::diagLogDeleteAidingRequest (uint64_t clientIdentifier,
uint32_t aidingMask) {
size_t size = 0;
diagServiceInfoStruct* aidingInfo = NULL;
diagBuffSrc bufferSrc;
size = sizeof(diagServiceInfoStruct)- sizeof(aidingInfo->serviceReport) +
sizeof(uint8_t) + sizeof(uint32_t);
if (locDiagIfaceHandle) {
aidingInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (aidingInfo) {
aidingInfo->header.clientIdentifier = clientIdentifier;
aidingInfo->serviceInfoType = CONFIG_API_ACCESS_INFO;
populateIdlDiagHeaderInfo(aidingInfo->header);
aidingInfo->serviceReport.configApiInfo.requestType = DELETE_AIDING_DATA;
aidingInfo->serviceReport.configApiInfo.configData.deleteAidingMask = aidingMask;
locDiagIfaceHandle->logCommit(aidingInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for Delete Aiding Request !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
void LocIdlServiceLog::diagLogSessionInfo (diagControlCommandInfo idlSessionInfo,
uint64_t clientIdentifier) {
size_t size = 0;
diagServiceInfoStruct* sessionInfo = NULL;
diagBuffSrc bufferSrc;
size = sizeof(diagServiceInfoStruct)- sizeof(sessionInfo->serviceReport) +
sizeof(diagControlCommandInfo);
if (locDiagIfaceHandle) {
sessionInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (sessionInfo) {
sessionInfo->header.clientIdentifier = clientIdentifier;
sessionInfo->serviceInfoType = SESSION_CONTROL_INFO;
populateIdlDiagHeaderInfo(sessionInfo->header);
sessionInfo->serviceReport.cmdInfo.sessionRequestType =
idlSessionInfo.sessionRequestType;
sessionInfo->serviceReport.cmdInfo.intervalMs = idlSessionInfo.intervalMs;
sessionInfo->serviceReport.cmdInfo.requestedCallbackMask =
idlSessionInfo.requestedCallbackMask;
sessionInfo->serviceReport.cmdInfo.updatedCallbackMask =
idlSessionInfo.updatedCallbackMask;
sessionInfo->serviceReport.cmdInfo.numControlRequests =
idlSessionInfo.numControlRequests;
locDiagIfaceHandle->logCommit(sessionInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for session event Info !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
void LocIdlServiceLog::diagLogPowerEventInfo(uint8_t powerEvent, uint8_t serviceStatus) {
size_t size = 0;
diagServiceInfoStruct* powerEventInfo = NULL;
diagBuffSrc bufferSrc;
size = sizeof(diagServiceInfoStruct)- sizeof(powerEventInfo->serviceReport) +
sizeof(diagPowerEventInfo);
if (locDiagIfaceHandle) {
powerEventInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (powerEventInfo) {
powerEventInfo->serviceInfoType = POWER_EVENT_INFO;
populateIdlDiagHeaderInfo(powerEventInfo->header);
powerEventInfo->serviceReport.powerEvent.powerEventType = powerEvent;
powerEventInfo->serviceReport.powerEvent.serviceStatus = serviceStatus;
locDiagIfaceHandle->logCommit(powerEventInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for Power Event Info !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
void LocIdlServiceLog::diagLogCapabilityInfo(string capabilityMask) {
size_t size = 0;
diagServiceInfoStruct* capsInfo = NULL;
diagBuffSrc bufferSrc;
size = sizeof(diagServiceInfoStruct)- sizeof(capsInfo->serviceReport) +
sizeof(diagCapabilityReceivedInfo) + capabilityMask.size() -1;
if (locDiagIfaceHandle) {
capsInfo = (diagServiceInfoStruct*)locDiagIfaceHandle->logAlloc(
LOG_LOCATION_IDL_SERVICE_REPORT_C,
size, &bufferSrc);
if (capsInfo) {
capsInfo->serviceInfoType = CAPS_EVENT_INFO;
populateIdlDiagHeaderInfo(capsInfo->header);
capsInfo->serviceReport.capabiltiyInfo.capabilityStringLength = capabilityMask.size();
memcpy(&capsInfo->serviceReport.capabiltiyInfo.capabilitiesReceived,
capabilityMask.c_str(),
capsInfo->serviceReport.capabiltiyInfo.capabilityStringLength);
locDiagIfaceHandle->logCommit(capsInfo, bufferSrc,
LOG_LOCATION_IDL_SERVICE_REPORT_VERSION, size);
} else {
LOC_LOGe(" logAlloc failed for Capability Info !! ");
}
} else {
LOC_LOGe(" locDiagIfaceHandle is NULL ");
}
}
LocIdlServiceLog::LocIdlServiceLog() {
}
LocIdlServiceLog::~LocIdlServiceLog() {
}

279
qcom/opensource/location/loc-fidl/src/LocIdlService/LocIdlServiceLog.h Normal file
View File

@@ -0,0 +1,279 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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_IDL_SERVICE_LOG_H
#define LOC_IDL_SERVICE_LOG_H
#include <stdint.h>
#include <inttypes.h>
#include <vector>
#include "log_util.h"
#include "LocDiagIfaceApi.h"
#include "LocIdlAPIStubImpl.hpp"
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
using namespace std;
#ifndef LOG_1X_BASE_C
#define LOG_1X_BASE_C ((uint16_t) 0x1000)
#endif
// DIAG ID's and Version Information
#define LOG_LOCATION_IDL_SERVICE_REPORT_C ((0xE6A) + LOG_1X_BASE_C)
#define LOG_LOCATION_IDL_SERVICE_REPORT_VERSION 0
#define IDL_DIAG_MAX_SV (176)
#ifdef __linux__
#define PACKED
#define PACKED_POST __attribute__((__packed__))
#endif
#if defined(__linux__) || defined(USE_GLIB) || defined(__ANDROID__)
#define TYPEDEF_PACKED_STRUCT typedef PACKED struct PACKED_POST
#else
#define TYPEDEF_PACKED_STRUCT typedef struct
#endif
#if !defined(USE_GLIB) && !defined(__ANDROID__)
#ifndef _LOG_HDR_TYPE_
#define _LOG_HDR_TYPE_
typedef struct PACKED_POST {
uint16_t len; /* Specifies the length, in bytes of the
entry, including this header. */
uint16_t code; /* Specifies the log code for the entry as
enumerated above. Note: This is
specified as word to guarantee size. */
/*upper 48 bits represent elapsed time since
6 Jan 1980 00:00:00 in 1.25 ms units. The
low order 16 bits represent elapsed time
since the last 1.25 ms tick in 1/32 chip
units (this 16 bit counter wraps at the
value 49152). */
uint32_t ts_lo; /* Time stamp */
uint32_t ts_hi;
} log_hdr_type;
#endif
#endif
/** @brief Generic Diag logger header for all IDL Service messages. */
TYPEDEF_PACKED_STRUCT {
/** Used by Logging Module */
log_hdr_type logHeader;
/** Message Version */
uint8_t version;
/** Client Hashcode */
uint64_t clientIdentifier;
/** Log RSS memory stats for FIDL service */
uint32_t idlServiceRssStats;
/** GPTP sync status */
bool gptpSyncStatus;
/** Reserve field */
uint32_t reserved1;
} diagServiceGenericHeader;
/** Logging report Type */
enum diagServiceInfoType {
INFO_TYPE_UNKNOWN = 0,
GNSS_REPORT_INFO = 1,
SESSION_CONTROL_INFO = 2,
CONFIG_API_ACCESS_INFO = 3,
POWER_EVENT_INFO = 4,
CAPS_EVENT_INFO = 5,
};
/** Enum to specify report Type */
enum diagServiceOutputReportType {
OUTPUT_REPORT_UNKOWN = 0,
OUTPUT_PVT_REPORT = 1,
OUTPUT_MEAS_REPORT = 2,
OUTPUT_NHZ_MEAS_REPORT = 3,
OUTPUT_NMEA_REPORT = 4,
OUTPUT_SV_INFO_REPORT = 5,
OUTPUT_GNSS_DATA_REPORT = 6,
};
/** To store inof about GNSS reports being sent out */
TYPEDEF_PACKED_STRUCT {
/** Gnss report type defined by diagServiceOutputReportType */
uint8_t reportType;
/** Time Difference between Time of genration of packet
* and time at which report is sent over SOMEIP */
int16_t packetLatencyTime;
/** Count of postion reports latent by 20 msec */
uint32_t latentReportCount;
} diagOutputGnssReportInfo;
/** Seerion Control command*/
enum diagServiceSessionRequestType {
SESSION_REQUEST_UNKNOWN = 0,
SESSION_START_REQUEST = 1,
SESSION_STOP_REQUEST = 2,
};
/** Session Control Command related Info */
TYPEDEF_PACKED_STRUCT {
/**Type of request Start/Stop defined by diagServiceSessionRequestType */
uint8_t sessionRequestType;
/** Requested Time interval between fixes */
uint32_t intervalMs;
/** Requested subscription mask */
uint32_t requestedCallbackMask;
/** IDL service subscription mask */
uint32_t updatedCallbackMask;
/** Number of session control requests */
uint32_t numControlRequests;
} diagControlCommandInfo;
/** Config API types */
enum diagServiceLIARequestType {
LIA_REQUEST_UNKNOWN = 0,
DELETE_AIDING_DATA = 1,
CONFIG_CONSTELLATIONS_REQUEST = 2,
};
/**Fields specifiying Aiding Data deletion */
typedef enum {
/** Aiding Mask Unknown */
NO_AIDING_DELETION = 0,
/** Mask to delete all aiding data from all position
engines on the device <br/> */
DELETE_ALL_AIDING_DATA = 0x0001,
/** Mask to delete ephemeris aiding data <br/> */
DELETE_EPHEMERIS_DATA = 0x0002,
/** Mask to delete calibration data from dead reckoning position
* engine.<br/> */
DELETE_DR_SENSOR_CALIBRATION = 0x0004,
} diagDeleteAidingMask;
/**Sv Info to store configConstellation request */
TYPEDEF_PACKED_STRUCT {
/** Gnss Constellation */
uint8_t constellationType;
/** SV ID */
uint16_t svId;
} diagGnssSvIdInfo;
/** Config API info */
TYPEDEF_PACKED_STRUCT {
/** Config API type defined by diagServiceLIARequestType */
uint8_t requestType;
union {
/** Delete Aiding Mask diagDeleteAidingMask */
uint32_t deleteAidingMask;
/** Config Constellation Info diagGnssSvIdInfo*/
diagGnssSvIdInfo svList[IDL_DIAG_MAX_SV];
} configData;
} diagConfigApiRequest;
// Enum to define supported Power states in power-daemon
enum diagPowerStateType {
POWER_STATE_UNKNOWN = 0,
POWER_STATE_SUSPEND = 1,
POWER_STATE_RESUME = 2,
POWER_STATE_SHUTDOWN = 3,
POWER_STATE_DEEP_SLEEP_ENTRY = 4,
POWER_STATE_DEEP_SLEEP_EXIT = 5
};
/**IDL service registeration status */
enum diagServiceStatus {
SERVICE_STAUS_UNKNOWN = 0,
REGISTER_SERVICE_SUCCESS = 1,
REGISTER_SERVICE_FAILED = 2,
UNREGISTER_SERVICE_SUCCESS = 3,
UNREGISTER_SERVICE_FAILED = 4,
};
/* Platform power event Info **/
TYPEDEF_PACKED_STRUCT {
/** Platform define power states:: diagPowerStateType */
uint8_t powerEventType;
/** FIDL service registeration status:: diagServiceStatus*/
uint8_t serviceStatus;
} diagPowerEventInfo;
/* Platform capability Info **/
TYPEDEF_PACKED_STRUCT {
/** Length of capability string */
uint32_t capabilityStringLength;
/** capabilities Received*/
uint8_t capabilitiesReceived[1];
} diagCapabilityReceivedInfo;
TYPEDEF_PACKED_STRUCT {
/** IDL Service Generic Info */
diagServiceGenericHeader header;
/** IDL report type defined by diagServiceInfoType */
uint8_t serviceInfoType;
/** Union for various reports that shall be captured in IDL Service Context */
union {
/** System Capabilities Info */
diagCapabilityReceivedInfo capabiltiyInfo;
/** Captures Type of GNSS report Sent out and associated info */
diagOutputGnssReportInfo reportInfo;
/** Captures Type of Session Control Commands received by LocIdlService */
diagControlCommandInfo cmdInfo;
/** Captures Type of configuration requests received by LocIdlService */
diagConfigApiRequest configApiInfo;
/** Captures Platform power events received by LocIdlService */
diagPowerEventInfo powerEvent;
} serviceReport;
} diagServiceInfoStruct;
class LocIdlServiceLog {
public:
LocIdlServiceLog();
~LocIdlServiceLog();
bool initializeDiagIface();
void populateIdlDiagHeaderInfo(diagServiceGenericHeader& idlHeader);
void diagLogCapabilityInfo(string capabilitiesReceived);
void diagLogDeleteAidingRequest (uint32_t aidingMask);
void diagLogSessionInfo (diagControlCommandInfo idlSessionInfo, uint64_t clientIdentifier);
void diagLogGnssReportInfo(uint8_t reportType, int16_t latencyMs, uint32_t latentReportCount);
void diagLogPowerEventInfo(uint8_t powerEvent, uint8_t serviceStatus);
void diagLogDeleteAidingRequest (uint64_t clientIdentifier, uint32_t aidingMask);
void diagLogConfigConstellationRequest(uint64_t clientIdentifier,
vector< LocIdlAPI::IDLGnssSvIdInfo > svListSrc);
void updateSystemHealth(uint32_t totalRss, bool gptpSyncStatus);
private:
uint32_t mTotalRss;
bool mGptpSyncStatus;
};
#endif //LOC_IDL_SERVICE_LOG_H

1572
qcom/opensource/location/loc-fidl/src/LocIdlService/LocLcaIdlConverter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

209
qcom/opensource/location/loc-fidl/src/LocIdlService/LocLcaIdlConverter.h Normal file
View File

@@ -0,0 +1,209 @@
/*
Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted (subject to the limitations in the
disclaimer below) 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 Qualcomm Innovation Center, Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
*/
/************************************************************************
* File contains all the conversion functions from LCA reports type
* to IDL format
**********************************************************************/
#ifndef LOCLCAIDLCONVERTER_H
#define LOCLCAIDLCONVERTER_H
#include <iostream>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <cstring>
#include "LocationClientApi.h"
#include <v0/com/qualcomm/qti/location/LocIdlAPIStub.hpp>
#include <gptp_helper.h>
using namespace v0::com::qualcomm::qti::location;
using namespace std;
using namespace location_client;
class LocLcaIdlConverter {
public:
LocIdlAPI::IDLLocation parseBasicLocationInfo
(
const ::GnssLocation &basicLoc
);
uint32_t parseIDLLocReliability
(
::LocationReliability locReliability
);
LocIdlAPI::IDLLocationReportSvUsedInPosition parseIDLSvUsedInPosition
(
::GnssLocationSvUsedInPosition halSv
);
uint32_t parseIDLNavSolutionMask
(
::GnssLocationNavSolutionMask navSolMask
);
uint32_t parseIDLPosTechMask
(
location_client::LocationTechnologyMask posTechMask
);
LocIdlAPI::IDLLocationReportPositionDynamics parseIDLBodyFrameData
(
location_client::GnssLocationPositionDynamics bodyFrameData
);
LocIdlAPI::IDLGnssSystemTime parseGnssSystemTime
(
location_client::GnssSystemTime gnssSystemTime
);
LocIdlAPI::IDLGnssSystemTimeStructType parseIDLGnssTime
(
location_client::GnssSystemTimeStructType gnssTime
);
LocIdlAPI::IDLGnssGloTimeStructType parseIDLGloTime
(
location_client::GnssGloTimeStructType gloTime
);
uint32_t parseIDLGnssConstellation
(
location_client::Gnss_LocSvSystemEnumType constellation
);
vector< LocIdlAPI::IDLGnssMeasUsageInfo > parseIDLMeasUsageInfo
(
vector<location_client::GnssMeasUsageInfo> measUsageInfo
);
uint32_t parseIDLCalibrationStatus
(
location_client::DrCalibrationStatusMask statusMask
);
uint32_t parseIDLEngMask
(
location_client::PositioningEngineMask locOutputEngMask
);
LocIdlAPI::IDLLLAInfo parseIDLLatLongAltInfo
(
location_client::LLAInfo llaVRPBased
);
uint64_t parseIDLDrSolStatusMask
(
location_client::DrSolutionStatusMask drSolutionStatusMask
);
LocIdlAPI::IDLLocationReport parseLocReport
(
const location_client::GnssLocation &lcaLoc
);
LocIdlAPI::IDLGnssSvType parseIDLSvType
(
location_client::GnssSvType svType
);
uint32_t parseIDLSvOptionMask
(
location_client:: GnssSvOptionsMask optionMask
);
LocIdlAPI::IDLGnssSv parseSvReport
(
const location_client::GnssSv& gnssSvs
);
uint32_t parseGnssClkFlags (
location_client::GnssMeasurementsClockFlagsMask clkFlags
);
LocIdlAPI::IDLGnssMeasurementsClock parseIDLMeasClockInfo
(
location_client::GnssMeasurementsClock gnssClock
);
uint32_t parseIDLMeasFlags(
location_client::GnssMeasurementsDataFlagsMask gnssFlags
);
uint32_t parseIDLStateMask(
location_client::GnssMeasurementsStateMask stateMask
);
uint32_t parseIDLAdrStateMask(
location_client::GnssMeasurementsAdrStateMask adrStatemask
);
uint32_t parseIDLMultiPathIndicator(
location_client::GnssMeasurementsMultipathIndicator multipathIndicator
);
vector<LocIdlAPI::IDLGnssMeasurementsData > parseIDLMeasData
(
vector<location_client::GnssMeasurementsData> gnssMeasData
);
LocIdlAPI::IDLGnssMeasurements parseMeasurements
(
const location_client::GnssMeasurements& gnssMeasurements
);
uint32_t parseIDLDataMask
(
const location_client::GnssDataMask& mask
);
LocIdlAPI::IDLGnssData parseGnssData
(
const location_client::GnssData& gnssData
);
uint32_t parseIDLSignalType (
location_client::GnssSignalTypeMask lcaSignalType
);
LocLcaIdlConverter();
~LocLcaIdlConverter();
};
#endif

9
qcom/opensource/location/loc-fidl/src/LocIdlService/commonapi4someip.ini Normal file
View File

@@ -0,0 +1,9 @@
[default]
binding=someip
tp=true
[logging]
console = true
file = ./mylog.log
dlt = false
level = verbose

38
qcom/opensource/location/loc-fidl/src/LocIdlService/vsomeip-local.json Normal file
View File

@@ -0,0 +1,38 @@
{
"unicast" : "10.131.4.37",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "false", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "client-sample",
"id" : "0x1343"
},
{
"name" : "service-sample",
"id" : "0x1277"
}
],
"services" :
[
{
"service" : "0x1234",
"instance" : "0x5678",
"reliable" : { "port" : "30509", "enable-magic-cookies" : "false" },
"unreliable" : "31000"
}
],
"routing" : "client-sample",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}

40
qcom/opensource/location/loc-fidl/src/LocIdlService/vsomeip-location.json Normal file
View File

@@ -0,0 +1,40 @@
{
"unicast" : "192.168.1.10",
"netmask" : "255.255.0.0",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "false", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "location-fidl-service",
"id" : "0x3"
}
],
"services" :
[
{
"service" : "0xEE00",
"instance" : "0x01",
"reliable" : { "port" : "30509", "enable-magic-cookies" : "false" },
"unreliable" : "31000",
"someip-tp": {
"service-to-client": ["0x80E9", "0x80EA", "0x80EB", "0x80EC", "0x80ED", "0x80EE", "0x80EF", "0x80F0"]
}
}
],
"max-payload-size-unreliable" : "15000",
"routing" : "sensor-fidl-service",
"network" : "vlan_ivss",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}

38
qcom/opensource/location/loc-fidl/src/LocIdlService/vsomeip-service.json Normal file
View File

@@ -0,0 +1,38 @@
{
"unicast" : "10.131.4.37",
"netmask" : "255.255.0.0",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "false", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "service-sample",
"id" : "0x1277"
}
],
"services" :
[
{
"service" : "0x1234",
"instance" : "0x5678",
"reliable" : { "port" : "30509", "enable-magic-cookies" : "false" },
"unreliable" : "31000",
"someip-tp": {
"service-to-client": ["0x9471", "0x7472", "0x7535", "0x7531"]
}
}
],
"routing" : "service-sample",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}

38
qcom/opensource/location/loc-fidl/vsomeip-local.json Normal file
View File

@@ -0,0 +1,38 @@
{
"unicast" : "10.131.4.37",
"logging" :
{
"level" : "debug",
"console" : "true",
"file" : { "enable" : "false", "path" : "/var/log/vsomeip.log" },
"dlt" : "false"
},
"applications" :
[
{
"name" : "client-sample",
"id" : "0x1343"
},
{
"name" : "service-sample",
"id" : "0x1277"
}
],
"services" :
[
{
"service" : "0x1234",
"instance" : "0x5678",
"reliable" : { "port" : "30509", "enable-magic-cookies" : "false" },
"unreliable" : "31000"
}
],
"routing" : "client-sample",
"service-discovery" :
{
"enable" : "true",
"multicast" : "224.244.224.245",
"port" : "30490",
"protocol" : "udp"
}
}