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

remove loc_api from hardware/qcom/gps

Browse source 
Change-Id: I2a1e928dc38de45c7421e2ef7a406ca969eafc97
Signed-off-by: Iliyan Malchev <malchev@google.com>
This commit is contained in:
Iliyan Malchev 2013-02-06 22:34:45 -08:00
parent 11db31880d
commit 0d257cc5d3
120 changed files with 6 additions and 45182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
CleanSpec.mk
View file

@ -48,3 +48,9 @@
# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
# ************************************************
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libloc_api*)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libloc* \
$(PRODUCT_OUT)/symbols/system/lib/libloc* \
$(PRODUCT_OUT)/system/lib/libloc* \
$(PRODUCT_OUT)/obj/lib/libloc* \
$(PRODUCT_OUT)/obj/include/libloc_eng)

37
loc_api/Android.mk
View file

@ -1,37 +0,0 @@
# Copyright (c) 2009, QUALCOMM USA, INC.
# All rights reserved.
# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
# · Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
# · Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
# · Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
# THIS SOFTWARE IS PROVIDED 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.
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
LOCAL_PATH := $(call my-dir)
GPS_DIR_LIST :=
ifeq (exists, $(shell test -d $(TOP)/vendor/qcom/proprietary/qmi-framework && echo exists))
# add RPC dirs if RPC is available
ifneq ($(TARGET_NO_RPC),true)
GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api-rpc-50001/
GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api-rpc/
GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api/
else
GPS_DIR_LIST += $(LOCAL_PATH)/loc_api_v02/
endif #TARGET_NO_RPC
endif
GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api_50001/
#call the subfolders
include $(addsuffix Android.mk, $(GPS_DIR_LIST))
endif#BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE

13
loc_api/NOTICE
View file

@ -1,13 +0,0 @@
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.

3
loc_api/libloc_api-rpc-50001/Android.mk
View file

@ -1,3 +0,0 @@
ifeq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
include $(call all-subdir-makefiles)
endif

59
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
View file

@ -1,59 +0,0 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
RPC_INC:=rpc_inc
source_files:= \
src/loc_api_rpc_glue.c \
src/loc_api_sync_call.c \
src/loc_apicb_appinit.c \
src/loc_api_fixup.c \
src/loc_api_log.c \
src/LocApiRpcAdapter.cpp
LOCAL_SRC_FILES:= $(source_files)
LOCAL_CFLAGS:=-fno-short-enums
LOCAL_CFLAGS+=-DDEBUG -DUSE_QCOM_AUTO_RPC -DUSE_QCOM_AUTO_RPC
LOCAL_CFLAGS+=$(GPS_FEATURES)
# for loc_api_fixup.c
LOCAL_CFLAGS+=-DADD_XDR_FLOAT -DADD_XDR_BOOL
LOCAL_SHARED_LIBRARIES:= \
librpc \
libutils \
libcutils \
libcommondefs \
libgps.utils \
libloc_adapter
LOCAL_STATIC_LIBRARIES := \
libloc_api_rpcgen
LOCAL_PRELINK_MODULE:= false
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH) \
$(LOCAL_PATH)/rpc_inc \
$(TARGET_OUT_HEADERS)/gps.utils \
$(TARGET_OUT_HEADERS)/loc_api/rpcgen/inc \
$(TARGET_OUT_HEADERS)/libcommondefs-rpc \
$(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc \
$(TARGET_OUT_HEADERS)/librpc \
$(TARGET_OUT_HEADERS)/libloc-rpc/rpc_inc \
$(TARGET_OUT_HEADERS)/libloc_eng \
hardware/msm7k/librpc
LOCAL_COPY_HEADERS_TO:= libloc_api-rpc-qc/$(RPC_INC)
LOCAL_COPY_HEADERS:= \
$(RPC_INC)/loc_api_rpc_glue.h \
$(RPC_INC)/loc_api_fixup.h \
$(RPC_INC)/loc_api_sync_call.h \
$(RPC_INC)/loc_apicb_appinit.h
LOCAL_MODULE:= libloc_api-rpc-qc
LOCAL_MODULE_TAGS := optional
include $(BUILD_SHARED_LIBRARY)

102
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpcAdapter.h
View file

@ -1,102 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_API_RPC_ADAPTER_H
#define LOC_API_RPC_ADAPTER_H
#include <rpc/rpc.h>
#include <loc_api_rpc_glue.h>
#include <LocApiAdapter.h>
class LocApiRpcAdapter : public LocApiAdapter {
// RPC communication establishment
rpc_loc_client_handle_type client_handle;
rpc_loc_event_mask_type eMask;
static const rpc_loc_event_mask_type locBits[];
static rpc_loc_event_mask_type convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask);
static enum loc_api_adapter_err convertErr(int rpcErr);
void reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr);
void reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr);
void reportStatus(const rpc_loc_status_event_s_type *status_report_ptr);
void reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr);
void ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr);
void NIEvent(const rpc_loc_ni_event_s_type *ni_req_ptr);
int NIEventFillVerfiyType(GpsNiNotification &notif,
rpc_loc_ni_notify_verify_e_type notif_priv);
GpsNiEncodingType convertNiEncodingType(int loc_encoding);
public:
LocApiRpcAdapter(LocEng &locEng);
~LocApiRpcAdapter();
int locEventCB(rpc_loc_client_handle_type client_handle,
rpc_loc_event_mask_type loc_event,
const rpc_loc_event_payload_u_type* loc_event_payload);
void locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event);
// RPC adapter interface implementations
virtual enum loc_api_adapter_err
reinit();
virtual enum loc_api_adapter_err
startFix();
virtual enum loc_api_adapter_err
stopFix();
virtual enum loc_api_adapter_err
setPositionMode(LocPositionMode mode, GpsPositionRecurrence recurrence,
uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time);
virtual enum loc_api_adapter_err
enableData(int enable);
virtual enum loc_api_adapter_err
setTime(GpsUtcTime time, int64_t timeReference, int uncertainty);
virtual enum loc_api_adapter_err
injectPosition(double latitude, double longitude, float accuracy);
virtual enum loc_api_adapter_err
deleteAidingData(GpsAidingData f);
virtual enum loc_api_adapter_err
informNiResponse(GpsUserResponseType userResponse, const void* passThroughData);
virtual enum loc_api_adapter_err
setAPN(char* apn, int len);
virtual enum loc_api_adapter_err
setServer(const char* url, int len);
virtual enum loc_api_adapter_err
setServer(unsigned int ip, int port, LocServerType type);
virtual enum loc_api_adapter_err
setXtraData(char* data, int length);
virtual enum loc_api_adapter_err
atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType);
virtual enum loc_api_adapter_err
atlCloseStatus(int handle, int is_succ);
virtual enum loc_api_adapter_err
setSUPLVersion(uint32_t version);
};
#endif //LOC_API_RPC_ADAPTER_H

69
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h
View file

@ -1,69 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef DEBUG_H
#define DEBUG_H
#include <stdio.h>
#define LOG_TAG "LocSvc_rpc"
#include <utils/Log.h>
#define PRINT(x...) do { \
fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \
fprintf(stdout, ##x); \
LOGD(x); \
} while(0)
#ifdef DEBUG
#define D PRINT
#else
#define D(x...) do { } while(0)
#endif
#ifdef VERBOSE
#define V PRINT
#else
#define V(x...) do { } while(0)
#endif
#define E(x...) do { \
fprintf(stderr, "%s(%d) ", __FUNCTION__, __LINE__); \
fprintf(stderr, ##x); \
LOGE(x); \
} while(0)
#define FAILIF(cond, msg...) do { \
if (__builtin_expect (cond, 0)) { \
fprintf(stderr, "%s:%s:(%d): ", __FILE__, __FUNCTION__, __LINE__); \
fprintf(stderr, ##msg); \
LOGE(##msg); \
} \
} while(0)
#endif/*DEBUG_H*/

226
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h
View file

@ -1,226 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LOC_API_FIXUP_H
#define LOC_API_FIXUP_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifndef NULLPROC
#define NULLPROC 0
#endif /* NULLPROC */
#ifdef ADD_XDR_FLOAT
extern bool_t xdr_float (XDR *__xdrs, float *__fp);
extern bool_t xdr_double (XDR *__xdrs, double *__dp);
#endif /* ADD_XDR_FLOAT */
#ifdef ADD_XDR_BOOL
extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
#endif /* ADD_XDR_BOOL */
#define RPC_LOC_API_MAJOR_VERSION_NUMBER 1
#define RPC_LOC_API_MINOR_VERSION_NUMBER 0
// Return value for loc_open in case of failure.
#define RPC_LOC_CLIENT_HANDLE_INVALID -1
// Return value of loc api calls for loc_close, loc_start_fix, loc_stop_fix and loc_ioctl
// These are also the status for the ioctl callback
#define RPC_LOC_API_SUCCESS 0
#define RPC_LOC_API_GENERAL_FAILURE 1
#define RPC_LOC_API_UNSUPPORTED 2
#define RPC_LOC_API_INVALID_HANDLE 4
#define RPC_LOC_API_INVALID_PARAMETER 5
#define RPC_LOC_API_ENGINE_BUSY 6
#define RPC_LOC_API_PHONE_OFFLINE 7
#define RPC_LOC_API_TIMEOUT 8
// Special return value for loc api calls in case of RPC failure
#define RPC_LOC_API_RPC_FAILURE (-1234)
// Special return value for modem restart incurred RPC failure
#define RPC_LOC_API_RPC_MODEM_RESTART (-1235)
#define RPC_LOC_API_MAX_SV_COUNT 80
#define RPC_LOC_API_MAX_NMEA_STRING_LENGTH 1200
// Maximum server address that will be used in location API
#define RPC_LOC_API_MAX_SERVER_ADDR_LENGTH 256
#define RPC_LOC_API_MAX_NUM_PREDICTED_ORBITS_SERVERS 3
#define RPC_LOC_API_MAX_NUM_NTP_SERVERS 3
#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 // Position report comes in loc_parsed_position_s_type
#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 // Satellite in view report
#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 // NMEA report at 1HZ rate
#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 // NMEA report at position report rate
#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 // NI notification/verification request
#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 // Assistance data, eg: time, predicted orbits request
#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 // Request for location server
#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 // Callback report for loc_ioctl
#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 // Misc status report: eg, engine state
#define RPC_LOC_POS_VALID_SESSION_STATUS 0x00000001
#define RPC_LOC_POS_VALID_TIMESTAMP_CALENDAR 0x00000002
#define RPC_LOC_POS_VALID_TIMESTAMP_UTC 0x00000004
#define RPC_LOC_POS_VALID_LEAP_SECONDS 0x00000008
#define RPC_LOC_POS_VALID_TIME_UNC 0x00000010
#define RPC_LOC_POS_VALID_LATITUDE 0x00000020
#define RPC_LOC_POS_VALID_LONGITUDE 0x00000040
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000080
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000100
#define RPC_LOC_POS_VALID_SPEED_HORIZONTAL 0x00000200
#define RPC_LOC_POS_VALID_SPEED_VERTICAL 0x00000400
#define RPC_LOC_POS_VALID_HEADING 0x00000800
#define RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR 0x00001000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MAJ 0x00002000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MIN 0x00004000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_ORIENT_AZIMUTH 0x00008000
#define RPC_LOC_POS_VALID_VERTICAL_UNC 0x00010000
#define RPC_LOC_POS_VALID_SPEED_UNC 0x00020000
#define RPC_LOC_POS_VALID_HEADING_UNC 0x00040000
#define RPC_LOC_POS_VALID_CONFIDENCE_HORIZONTAL 0x00080000
#define RPC_LOC_POS_VALID_CONFIDENCE_VERTICAL 0x00100000
#define RPC_LOC_POS_VALID_MAGNETIC_VARIATION 0x00200000
#define RPC_LOC_POS_VALID_TECHNOLOGY_MASK 0x00400000
#define RPC_LOC_POS_TECH_SATELLITE 0x00000001
#define RPC_LOC_POS_TECH_CELLID 0x00000002
#define RPC_LOC_POS_TECH_WIFI 0x00000004
#define RPC_LOC_SV_INFO_VALID_SYSTEM 0x00000001
#define RPC_LOC_SV_INFO_VALID_PRN 0x00000002
#define RPC_LOC_SV_INFO_VALID_HEALTH_STATUS 0x00000004
#define RPC_LOC_SV_INFO_VALID_PROCESS_STATUS 0x00000008
#define RPC_LOC_SV_INFO_VALID_HAS_EPH 0x00000010
#define RPC_LOC_SV_INFO_VALID_HAS_ALM 0x00000020
#define RPC_LOC_SV_INFO_VALID_ELEVATION 0x00000040
#define RPC_LOC_SV_INFO_VALID_AZIMUTH 0x00000080
#define RPC_LOC_SV_INFO_VALID_SNR 0x00000100
#define RPC_LOC_GNSS_INFO_VALID_POS_DOP 0x00000001
#define RPC_LOC_GNSS_INFO_VALID_HOR_DOP 0x00000002
#define RPC_LOC_GNSS_INFO_VALID_VERT_DOP 0x00000004
#define RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED 0x00000008
#define RPC_LOC_GNSS_INFO_VALID_SV_COUNT 0x00000010
#define RPC_LOC_GNSS_INFO_VALID_SV_LIST 0x00000020
#define RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH 200
#define RPC_LOC_NI_SUPL_HASH_LENGTH 8
#define RPC_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH 4
#define RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH 64
#define RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS 20
#define RPC_LOC_NI_CODEWORD_LENGTH 20
#define RPC_LOC_NI_SUPL_QOP_VALID 0x01
#define RPC_LOC_NI_SUPL_QOP_VERACC_VALID 0x02
#define RPC_LOC_NI_SUPL_QOP_MAXAGE_VALID 0x04
#define RPC_LOC_NI_SUPL_QOP_DELAY_VALID 0x08
#define RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE 0x00000001
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE 0x00000002
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY 0x00000004
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME 0x00000008
#define RPC_LOC_FIX_CRIT_VALID_INTERMEDIATE_POS_REPORT_ENABLED 0x00000010
#define RPC_LOC_FIX_CRIT_VALID_NOTIFY_TYPE 0x00000020
#define RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL 0x00000040
#define RPC_LOC_FIX_CRIT_VALID_MIN_DISTANCE 0x00000080
#define RPC_LOC_FIX_CRIT_VALID_MIN_DIST_SAMPLE_INTERVAL 0x00000100
#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_UTC 0x00000001
#define RPC_LOC_ASSIST_POS_VALID_LATITUDE 0x00000002
#define RPC_LOC_ASSIST_POS_VALID_LONGITUDE 0x00000004
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000008
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000010
#define RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR 0x00000020
#define RPC_LOC_ASSIST_POS_VALID_VERT_UNC 0x00000040
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL 0x00000080
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_VERTICAL 0x00000100
#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_AGE 0x00000200
#define RPC_LOC_ASSIST_DATA_ALL 0xFFFFFFFF
#define RPC_LOC_NMEA_MASK_ALL 0xffff
#define RPC_LOC_NMEA_MASK_GGA 0x0001
#define RPC_LOC_NMEA_MASK_RMC 0x0002
#define RPC_LOC_NMEA_MASK_GSV 0x0004
#define RPC_LOC_NMEA_MASK_GSA 0x0008
#define RPC_LOC_NMEA_MASK_VTG 0x0010
/* EFS data access */
#define RPC_LOC_EFS_MAX_PATH_LEN_BYTES 64 /* Max file name length in bytes that can be written*/
#define RPC_LOC_EFS_MAX_FILE_LEN_BYTES 2000 /* Max file size in bytes that can be written */
/* WIPER valid information flag in log report */
#define RPC_LOC_WIPER_LOG_TIME_VALID 0x01
#define RPC_LOC_WIPER_LOG_POS_VALID 0x02
#define RPC_LOC_WIPER_LOG_AP_SET_VALID 0x04
/* General WIPER defines */
#define RPC_LOC_WIPER_MAC_ADDR_LENGTH 6 // Do not change this number since it affects RPC and log packet sizes
#define RPC_LOC_WIPER_MAX_REPORTED_APS_PER_LOG_MSG 50 // Do not change this number since it affects RPC and log packet sizes
/* WIPER AP Qualifier */
#define RPC_LOC_WIPER_AP_QUALIFIER_BEING_USED 0x1 /* AP is being used by WPS */
#define RPC_LOC_WIPER_AP_QUALIFIER_HIDDEN_SSID 0x2 /* AP does not broadcast SSID */
#define RPC_LOC_WIPER_AP_QUALIFIER_PRIVATE 0x4 /* AP has encryption turned on */
#define RPC_LOC_WIPER_AP_QUALIFIER_INFRASTRUCTURE_MODE 0x8 /* AP is in infrastructure mode and not in ad-hoc/unknown mode */
/* flags for notification */
#define RPC_LOC_NI_CLIENT_NAME_PRESENT 0x0001
#define RPC_LOC_NI_CLIENT_EXTADDR_PRESENT 0x0002
#define RPC_LOC_NI_DEF_LOCATION_TYPE_PRESENT 0x0010
#define RPC_LOC_NI_REQUESTOR_ID_PRESENT 0x0020
#define RPC_LOC_NI_CODEWORD_PRESENT 0x0040
#define RPC_LOC_NI_SERVICE_TYPE_ID_PRESENT 0x0080
#define RPC_LOC_NI_ENCODING_TYPE_PRESENT 0x0100
/* below are for RPC_LOC_IOCTL_SET_LBS_APN_PROFILE data */
/* values for apn_profiles[0].srv_system_type */
#define LOC_APN_PROFILE_SRV_SYS_CDMA 0x01
#define LOC_APN_PROFILE_SRV_SYS_HDR 0x02
#define LOC_APN_PROFILE_SRV_SYS_GSM 0x04
#define LOC_APN_PROFILE_SRV_SYS_WCDMA 0x08
#define LOC_APN_PROFILE_SRV_SYS_LTE 0x10
#define LOC_APN_PROFILE_SRV_SYS_MAX 0x1F
/* values for apn_profiles[0].pdp_type */
#define LOC_APN_PROFILE_PDN_TYPE_IPV4 0x01
#define LOC_APN_PROFILE_PDN_TYPE_IPV6 0x02
#define LOC_APN_PROFILE_PDN_TYPE_IPV4V6 0x03
#define LOC_APN_PROFILE_PDN_TYPE_PPP 0x04
#define LOC_APN_PROFILE_PDN_TYPE_MAX 0x04
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_FIXUP_H */

59
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h
View file

@ -1,59 +0,0 @@
/* Copyright (c) 2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_API_LOG_H
#define LOC_API_LOG_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <ctype.h>
#include "loc_api_rpcgen_common_rpc.h"
extern int loc_callback_log(
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
);
extern const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open);
extern const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask);
extern const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type);
extern const char* loc_get_ioctl_status_name(uint32 status);
extern const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status);
extern const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state);
extern const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state);
extern const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event);
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_LOG_H */

123
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h
View file

@ -1,123 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LOC_API_RPC_GLUE_H
#define LOC_API_RPC_GLUE_H
/* Include RPC headers */
#ifdef USE_LOCAL_RPC
#include "rpc_inc/loc_api_common.h"
#include "rpc_inc/loc_api.h"
#include "rpc_inc/loc_api_cb.h"
#endif
#ifdef USE_QCOM_AUTO_RPC
#include "loc_api_rpcgen_rpc.h"
#include "loc_api_rpcgen_common_rpc.h"
#include "loc_api_rpcgen_cb_rpc.h"
#endif
/* Boolean */
/* Other data types in comdef.h are defined in rpc stubs, so fix it here */
typedef unsigned char boolean;
#define TRUE 1
#define FALSE 0
#include "rpc_inc/loc_api_fixup.h"
#include "rpc_inc/loc_api_sync_call.h"
#include <rpc/clnt.h>
#ifdef __cplusplus
extern "C"
{
#endif
extern int loc_api_glue_init(void);
extern int loc_api_null(void);
typedef int32 (loc_event_cb_f_type)(
void* userData,
rpc_loc_client_handle_type loc_handle, /* handle of the client */
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
);
typedef void (loc_reset_notif_cb_f_type)(
void* userData,
CLIENT* clnt,
enum rpc_reset_event event
);
extern rpc_loc_client_handle_type loc_open(
rpc_loc_event_mask_type event_reg_mask,
loc_event_cb_f_type *event_callback,
loc_reset_notif_cb_f_type *rpc_global_cb,
void* userData
);
extern int32 loc_close
(
rpc_loc_client_handle_type handle
);
extern void loc_clear
(
rpc_loc_client_handle_type handle
);
extern int32 loc_start_fix
(
rpc_loc_client_handle_type handle
);
extern int32 loc_stop_fix
(
rpc_loc_client_handle_type handle
);
extern int32 loc_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data
);
extern int loc_eng_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
);
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_RPC_GLUE_H */

90
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h
View file

@ -1,90 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LOC_API_CB_SYNC_H
#define LOC_API_CB_SYNC_H
#ifdef __cplusplus
extern "C"
{
#endif
#include "loc_api_rpc_glue.h"
#define LOC_SYNC_CALL_SLOTS_MAX 8
typedef struct {
pthread_mutex_t lock;
/* Client ID */
rpc_loc_client_handle_type loc_handle;
/* Callback waiting conditional variable */
pthread_cond_t loc_cb_arrived_cond;
/* Callback waiting data block, protected by loc_cb_data_mutex */
boolean in_use;
boolean signal_sent;
boolean not_available;
rpc_loc_event_mask_type loc_cb_wait_event_mask; /* event to wait for */
rpc_loc_ioctl_e_type ioctl_type; /* ioctl to wait for */
rpc_loc_event_payload_u_type loc_cb_received_payload; /* received payload */
rpc_loc_event_mask_type loc_cb_received_event_mask; /* received event */
} loc_sync_call_slot_s_type;
typedef struct {
int num_of_slots;
loc_sync_call_slot_s_type slots[LOC_SYNC_CALL_SLOTS_MAX];
} loc_sync_call_slot_array_s_type;
/* Init function */
void loc_api_sync_call_init();
/* Destroy function */
void loc_api_sync_call_destroy();
/* Process Loc API callbacks to wake up blocked user threads */
void loc_api_callback_process_sync_call(
rpc_loc_client_handle_type loc_handle, /* handle of the client */
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
);
/* Reentrant synchronous IOCTL call, using Loc API return code */
int loc_api_sync_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
);
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_CB_SYNC_H */

45
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h
View file

@ -1,45 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LOC_APICB_APPINIT_H
#define LOC_APICB_APPINIT_H
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialization function for callbacks */
extern int loc_apicb_app_init();
extern void loc_apicb_app_deinit();
#ifdef __cplusplus
}
#endif
#endif /* LOC_APICB_APPINIT_H */

1220
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpcAdapter.cpp
View file

File diff suppressed because it is too large Load diff

52
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c
View file

@ -1,52 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <rpc/rpc.h>
#include "loc_api_fixup.h"
#ifdef ADD_XDR_FLOAT
int
xdr_float(xdrp, fp)
XDR *xdrp;
float *fp;
{
return xdr_long(xdrp, (long*)fp);
}
int
xdr_double(xdrp, dp)
XDR *xdrp;
double *dp;
{
return xdr_long(xdrp, (long*)dp + 1)
&& xdr_long(xdrp, (long*)dp);
}
#endif /* ADD_XDR_FLOAT */

344
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c
View file

@ -1,344 +0,0 @@
/* Copyright (c) 2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_api_rpc_glue"
#include "loc_api_log.h"
#include "loc_log.h"
#include "log_util.h"
#include "rpc/rpc.h"
#include "loc_api_fixup.h"
/* Event names */
loc_name_val_s_type loc_event_name[] =
{
NAME_VAL( RPC_LOC_EVENT_PARSED_POSITION_REPORT ),
NAME_VAL( RPC_LOC_EVENT_SATELLITE_REPORT ),
NAME_VAL( RPC_LOC_EVENT_NMEA_1HZ_REPORT ),
NAME_VAL( RPC_LOC_EVENT_NMEA_POSITION_REPORT ),
NAME_VAL( RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST ),
NAME_VAL( RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST ),
NAME_VAL( RPC_LOC_EVENT_LOCATION_SERVER_REQUEST ),
NAME_VAL( RPC_LOC_EVENT_IOCTL_REPORT ),
NAME_VAL( RPC_LOC_EVENT_STATUS_REPORT ),
NAME_VAL( RPC_LOC_EVENT_WPS_NEEDED_REQUEST ),
};
int loc_event_num = sizeof loc_event_name / sizeof(loc_name_val_s_type);
/* Event names */
loc_name_val_s_type loc_event_atl_open_name[] =
{
NAME_VAL( RPC_LOC_SERVER_REQUEST_OPEN ),
NAME_VAL( RPC_LOC_SERVER_REQUEST_CLOSE ),
NAME_VAL( RPC_LOC_SERVER_REQUEST_MULTI_OPEN )
};
int loc_event_atl_open_num = sizeof loc_event_atl_open_name / sizeof(loc_name_val_s_type);
/* Finds the first event found in the mask */
const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open)
{
return loc_get_name_from_val(loc_event_atl_open_name, loc_event_atl_open_num,
(long) loc_event_atl_open);
}
/* IOCTL Type names */
loc_name_val_s_type loc_ioctl_type_name[] =
{
NAME_VAL( RPC_LOC_IOCTL_GET_API_VERSION ),
NAME_VAL( RPC_LOC_IOCTL_SET_FIX_CRITERIA ),
NAME_VAL( RPC_LOC_IOCTL_GET_FIX_CRITERIA ),
NAME_VAL( RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE ),
NAME_VAL( RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA ),
NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY ),
NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE ),
NAME_VAL( RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD ),
NAME_VAL( RPC_LOC_IOCTL_INJECT_UTC_TIME ),
NAME_VAL( RPC_LOC_IOCTL_INJECT_RTC_VALUE ),
NAME_VAL( RPC_LOC_IOCTL_INJECT_POSITION ),
NAME_VAL( RPC_LOC_IOCTL_QUERY_ENGINE_STATE ),
NAME_VAL( RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG),
NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS ),
NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS ),
NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS ),
NAME_VAL( RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT ),
NAME_VAL( RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS ),
NAME_VAL( RPC_LOC_IOCTL_SET_ENGINE_LOCK ),
NAME_VAL( RPC_LOC_IOCTL_GET_ENGINE_LOCK ),
NAME_VAL( RPC_LOC_IOCTL_SET_SBAS_CONFIG ),
NAME_VAL( RPC_LOC_IOCTL_GET_SBAS_CONFIG ),
NAME_VAL( RPC_LOC_IOCTL_SET_NMEA_TYPES ),
NAME_VAL( RPC_LOC_IOCTL_GET_NMEA_TYPES ),
NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_SET_ON_DEMAND_LPM ),
NAME_VAL( RPC_LOC_IOCTL_GET_ON_DEMAND_LPM ),
NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL ),
NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL ),
NAME_VAL( RPC_LOC_IOCTL_SET_LBS_APN_PROFILE ),
NAME_VAL( RPC_LOC_IOCTL_GET_LBS_APN_PROFILE ),
NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE ),
NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE ),
NAME_VAL( RPC_LOC_IOCTL_SET_DATA_ENABLE ),
NAME_VAL( RPC_LOC_IOCTL_SET_SUPL_VERSION ),
NAME_VAL( RPC_LOC_IOCTL_GET_SUPL_VERSION ),
NAME_VAL( RPC_LOC_IOCTL_DELETE_ASSIST_DATA ),
NAME_VAL( RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR ),
NAME_VAL( RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR ),
};
int loc_ioctl_type_num = sizeof loc_ioctl_type_name / sizeof(loc_name_val_s_type);
/* IOCTL Status names */
loc_name_val_s_type loc_ioctl_status_name[] =
{
NAME_VAL( RPC_LOC_API_SUCCESS ),
NAME_VAL( RPC_LOC_API_GENERAL_FAILURE ),
NAME_VAL( RPC_LOC_API_UNSUPPORTED ),
NAME_VAL( RPC_LOC_API_INVALID_HANDLE ),
NAME_VAL( RPC_LOC_API_INVALID_PARAMETER ),
NAME_VAL( RPC_LOC_API_ENGINE_BUSY ),
NAME_VAL( RPC_LOC_API_PHONE_OFFLINE ),
NAME_VAL( RPC_LOC_API_TIMEOUT ),
NAME_VAL( RPC_LOC_API_RPC_FAILURE ),
NAME_VAL( RPC_LOC_API_RPC_MODEM_RESTART )
};
int loc_ioctl_status_num = sizeof loc_ioctl_status_name / sizeof(loc_name_val_s_type);
/* Fix session status names */
loc_name_val_s_type loc_sess_status_name[] =
{
NAME_VAL( RPC_LOC_SESS_STATUS_SUCCESS ),
NAME_VAL( RPC_LOC_SESS_STATUS_IN_PROGESS ),
NAME_VAL( RPC_LOC_SESS_STATUS_GENERAL_FAILURE ),
NAME_VAL( RPC_LOC_SESS_STATUS_TIMEOUT ),
NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
NAME_VAL( RPC_LOC_SESS_STATUS_BAD_PARAMETER ),
NAME_VAL( RPC_LOC_SESS_STATUS_PHONE_OFFLINE ),
NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
NAME_VAL( RPC_LOC_SESS_STATUS_ENGINE_LOCKED )
};
int loc_sess_status_num = sizeof loc_sess_status_name / sizeof(loc_name_val_s_type);
/* Engine state names */
loc_name_val_s_type loc_engine_state_name[] =
{
NAME_VAL( RPC_LOC_ENGINE_STATE_ON ),
NAME_VAL( RPC_LOC_ENGINE_STATE_OFF )
};
int loc_engine_state_num = sizeof loc_engine_state_name / sizeof(loc_name_val_s_type);
/* Fix session state names */
loc_name_val_s_type loc_fix_session_state_name[] =
{
NAME_VAL( RPC_LOC_FIX_SESSION_STATE_BEGIN ),
NAME_VAL( RPC_LOC_FIX_SESSION_STATE_END )
};
int loc_fix_session_state_num = sizeof loc_fix_session_state_name / sizeof(loc_name_val_s_type);
static const char* log_final_interm_string(int is_final)
{
return is_final ? "final" : "intermediate";
}
/* Logs parsed report */
static void log_parsed_report(const rpc_loc_parsed_position_s_type *parsed_report)
{
rpc_loc_session_status_e_type status = parsed_report->session_status;
LOC_LOGD("Session status: %s Valid mask: 0x%X\n",
loc_get_sess_status_name(status),
(uint) parsed_report->valid_mask);
LOC_LOGD("Latitude: %.7f (%s)\n", parsed_report->latitude,
log_final_interm_string(
(parsed_report->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
parsed_report->session_status == RPC_LOC_SESS_STATUS_SUCCESS));
LOC_LOGD("Longitude: %.7f\n", parsed_report->longitude);
LOC_LOGD("Accuracy: %.7f\n", parsed_report->hor_unc_circular);
}
/* Logs status report */
static void log_status_report(const rpc_loc_status_event_s_type *status_event)
{
rpc_loc_status_event_e_type event = status_event->event;
switch (event) {
case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
LOC_LOGD("Engine state: %s\n",
loc_get_engine_state_name(
status_event->payload.rpc_loc_status_event_payload_u_type_u.engine_state));
break;
case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
LOC_LOGD("Fix session state: %s\n",
loc_get_fix_session_state_name(
status_event->payload.rpc_loc_status_event_payload_u_type_u.fix_session_state));
break;
default:
break;
}
}
/* Logs valid fields in the GNSS SV constellation report */
static void log_satellite_report(const rpc_loc_gnss_info_s_type *gnss)
{
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP)
{
LOC_LOGV("position dop: %.3f\n", (float) gnss->position_dop);
}
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP)
{
LOC_LOGV("horizontal dop: %.3f\n", (float) gnss->horizontal_dop);
}
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP)
{
LOC_LOGV("vertical dop: %.3f\n", (float) gnss->vertical_dop);
}
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED)
{
LOC_LOGV("altitude assumed: %d\n", (int) gnss->altitude_assumed);
}
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
{
LOC_LOGD("sv count: %d\n", (int) gnss->sv_count);
}
if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
{
LOC_LOGV("sv list: ");
if (gnss->sv_count)
{
LOC_LOGV("\n\tsys\tprn\thlth\tproc\teph\talm\telev\tazi\tsnr\n");
}
else {
LOC_LOGV("empty\n");
}
int i;
for (i = 0; i < gnss->sv_count; i++)
{
const rpc_loc_sv_info_s_type *sv = &gnss->sv_list.sv_list_val[i];
rpc_loc_sv_info_valid_mask_type mask = sv->valid_mask;
LOC_LOGV(" %d: \t%d\t%d\t%d\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\n", i,
CHECK_MASK(int, sv->system, mask, RPC_LOC_SV_INFO_VALID_SYSTEM),
CHECK_MASK(int, sv->prn, mask, RPC_LOC_SV_INFO_VALID_PRN),
CHECK_MASK(int, sv->health_status, mask, RPC_LOC_SV_INFO_VALID_HEALTH_STATUS),
CHECK_MASK(int, sv->process_status, mask, RPC_LOC_SV_INFO_VALID_PROCESS_STATUS),
CHECK_MASK(int, sv->has_eph, mask, RPC_LOC_SV_INFO_VALID_HAS_EPH),
CHECK_MASK(int, sv->has_alm, mask, RPC_LOC_SV_INFO_VALID_HAS_ALM),
CHECK_MASK(float, sv->elevation, mask, RPC_LOC_SV_INFO_VALID_ELEVATION),
CHECK_MASK(float, sv->azimuth, mask, RPC_LOC_SV_INFO_VALID_AZIMUTH),
CHECK_MASK(float, sv->snr, mask, RPC_LOC_SV_INFO_VALID_SNR)
);
}
}
}
/* Logs a callback event */
int loc_callback_log(
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
)
{
switch (loc_event)
{
case RPC_LOC_EVENT_SATELLITE_REPORT:
log_satellite_report(&loc_event_payload->
rpc_loc_event_payload_u_type_u.gnss_report);
break;
case RPC_LOC_EVENT_STATUS_REPORT:
log_status_report(&loc_event_payload->
rpc_loc_event_payload_u_type_u.status_report);
break;
case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
log_parsed_report(&loc_event_payload->
rpc_loc_event_payload_u_type_u.parsed_location_report);
break;
default:
break;
}
return 0;
}
/* Finds the first event found in the mask */
const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask)
{
return loc_get_name_from_mask(loc_event_name, loc_event_num,
(long) loc_event_mask);
}
/* Finds IOCTL type name */
const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type)
{
return loc_get_name_from_val(loc_ioctl_type_name, loc_ioctl_type_num,
(long) ioctl_type);
}
/* Finds IOCTL status name */
const char* loc_get_ioctl_status_name(uint32 status)
{
return loc_get_name_from_val(loc_ioctl_status_name, loc_ioctl_status_num,
(long) status);
}
/* Finds session status name */
const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status)
{
return loc_get_name_from_val(loc_sess_status_name, loc_sess_status_num,
(long) status);
}
/* Find engine state name */
const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state)
{
return loc_get_name_from_val(loc_engine_state_name, loc_engine_state_num,
(long) state);
}
/* Find engine state name */
const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state)
{
return loc_get_name_from_val(loc_fix_session_state_name, loc_fix_session_state_num,
(long) state);
}
/* Event names */
loc_name_val_s_type rpc_reset_event_name[] =
{
NAME_VAL( RPC_SUBSYSTEM_RESTART_BEGIN ),
NAME_VAL( RPC_SUBSYSTEM_RESTART_END )
};
int rpc_reset_event_num = sizeof rpc_reset_event_name / sizeof(loc_name_val_s_type);
const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event)
{
return loc_get_name_from_val(rpc_reset_event_name, rpc_reset_event_num, event);
}

621
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c
View file

@ -1,621 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*=====================================================================
INCLUDE FILES FOR MODULE
======================================================================*/
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <loc_api_log.h>
#include <rpc/rpc.h>
/* Include RPC headers */
#include "rpc_inc/loc_api_rpc_glue.h"
/* Callback init */
#include "rpc_inc/loc_apicb_appinit.h"
/* Logging */
#define LOG_TAG "LocSvc_api_rpc_glue"
#define LOG_NDDEBUG 0
#include <utils/Log.h>
/* Logging Improvement */
#include "log_util.h"
/* Uncomment to force LOGD messages */
// #define LOGD LOGI
/*=====================================================================
External declarations
======================================================================*/
CLIENT* loc_api_clnt = NULL;
/* Callback ID and pointer */
#define LOC_API_CB_MAX_CLIENTS 16
typedef struct
{
uint32 cb_id; /* same as rpc/types.h */
loc_event_cb_f_type *cb_func; /* callback func */
loc_reset_notif_cb_f_type *rpc_cb; /* callback from RPC */
rpc_loc_client_handle_type handle; /* stores handle for client closing */
void* user; /* user's own data handle */
} loc_glue_cb_entry_s_type;
loc_glue_cb_entry_s_type loc_glue_callback_table[LOC_API_CB_MAX_CLIENTS];
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_FUNC_VERSION(a,b) RPC_FUNC_VERSION_BASE(a,b)
#define RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b) a ## v ## b
#define RPC_CALLBACK_FUNC_VERSION(a,v,b) RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b)
#define LOC_GLUE_CHECK_INIT(ret_type) \
if (loc_api_clnt == NULL) { EXIT_LOG_CALLFLOW(%d, RPC_LOC_API_RPC_FAILURE); return (ret_type) RPC_LOC_API_RPC_FAILURE; }
#define LOC_GLUE_CHECK_RESULT(stat, ret_type) \
if (stat != RPC_SUCCESS) { \
LOC_LOGE("%s:%d] failure code %d", __func__, __LINE__, stat); \
return (ret_type)((stat == RPC_SUBSYSTEM_RESTART) ? \
RPC_LOC_API_RPC_MODEM_RESTART : RPC_LOC_API_RPC_FAILURE); \
}
/* Callback functions */
/* Returns 1 if successful */
bool_t rpc_loc_event_cb_f_type_svc(
rpc_loc_event_cb_f_type_args *argp,
rpc_loc_event_cb_f_type_rets *ret,
struct svc_req *req)
{
// The lower word of cd_id is the index
int index = argp->cb_id & 0xFFFF;
/* Callback not registered, or unexpected ID (shouldn't happen) */
if (index >= LOC_API_CB_MAX_CLIENTS || loc_glue_callback_table[index].cb_func == NULL)
{
LOC_LOGE("Warning: No callback handler %d.\n", index);
ret->loc_event_cb_f_type_result = 0;
return 1; /* simply return */
}
LOC_LOGV("proc: %x prog: %x vers: %x\n",
(int) req->rq_proc,
(int) req->rq_prog,
(int) req->rq_vers);
LOC_LOGV("Callback received: %x (cb_id=%p handle=%d ret_ptr=%d)\n",
(int) argp->loc_event,
argp->cb_id,
(int) argp->loc_handle,
(int) ret);
/* Forward callback to real callback procedure */
rpc_loc_client_handle_type loc_handle = argp->loc_handle;
rpc_loc_event_mask_type loc_event = argp->loc_event;
const rpc_loc_event_payload_u_type* loc_event_payload =
(const rpc_loc_event_payload_u_type*) argp->loc_event_payload;
/* Gives control to synchronous call handler */
loc_api_callback_process_sync_call(loc_handle, loc_event, loc_event_payload);
int32 rc = (loc_glue_callback_table[index].cb_func)(loc_glue_callback_table[index].user,
loc_handle, loc_event, loc_event_payload);
LOC_LOGV("cb_func=%p", loc_glue_callback_table[index].cb_func);
ret->loc_event_cb_f_type_result = rc;
return 1; /* ok */
}
int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
{
xdr_free (xdr_result, result);
/*
* Insert additional freeing code here, if needed
*/
// LOC_LOGD("***** loc_apicbprog_freeresult\n");
return 1;
}
/*===========================================================================
FUNCTION rpc_loc_event_cb_f_type_<version>_svc (MACRO)
DESCRIPTION
Callback function for Loc API
RETURN VALUE
1 for success
0 for failure
===========================================================================*/
bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_event_cb_f_type_, RPC_LOC_EVENT_CB_F_TYPE_VERSION, _svc) (
rpc_loc_event_cb_f_type_args *argp,
rpc_loc_event_cb_f_type_rets *ret,
struct svc_req *req)
{
return rpc_loc_event_cb_f_type_svc(argp, ret, req);
}
/*===========================================================================
FUNCTION loc_apicbprog_<version>_freeresult (MACRO)
DESCRIPTION
Free up RPC data structure
RETURN VALUE
1 for success
0 for failure
===========================================================================*/
#define VERSION_CONCAT(MAJOR,MINOR) MAJOR##MINOR
#define loc_apicb_prog_VER_freeresult(M,N) \
int RPC_CALLBACK_FUNC_VERSION(loc_apicbprog_, VERSION_CONCAT(M,N), _freeresult) \
(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) \
{ \
return loc_apicbprog_freeresult(transp, xdr_result, result); \
}
/* Define all of the possible minors */
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0001);
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0002);
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0003);
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0004);
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0005);
loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0006);
/*===========================================================================
FUNCTION rpc_loc_api_cb_null_<version>_svc (MACRO) [Patch for wrong RPCGEN stubs]
DESCRIPTION
Null callback function for Loc API
RETURN VALUE
1 for success
===========================================================================*/
#define rpc_loc_api_cb_null_VER_svc(M,N) \
bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_api_cb_null_, VERSION_CONCAT(M,N), _svc) ( \
void *a, int *b, struct svc_req *req) \
{ \
return 1; \
}
/* Define all of the possible minors */
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0001);
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0002);
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0003);
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0004);
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0005);
rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0006);
static void loc_api_glue_rpc_cb(CLIENT* client, enum rpc_reset_event event)
{
int i;
for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++) {
if (NULL != loc_glue_callback_table[i].rpc_cb) {
loc_glue_callback_table[i].rpc_cb(loc_glue_callback_table[i].user, client, event);
}
}
}
/*===========================================================================
FUNCTION loc_api_glue_init
DESCRIPTION
Initiates the RPC client
RETURN VALUE
1 for success
0 for failure
===========================================================================*/
int loc_api_glue_init(void)
{
if (loc_api_clnt == NULL)
{
/* Initialize data */
int i;
int pid = getpid();
for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
{
loc_glue_callback_table[i].cb_id = i | (pid << 16);
loc_glue_callback_table[i].cb_func = NULL;
loc_glue_callback_table[i].handle = -1;
loc_glue_callback_table[i].rpc_cb = NULL;
loc_glue_callback_table[i].user = NULL;
}
/* Print msg */
LOC_LOGV("Trying to create RPC client...\n");
loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL);
LOC_LOGV("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
if (loc_api_clnt == NULL)
{
LOC_LOGE("Error: cannot create RPC client.\n");
return 0;
}
/* Init RPC callbacks */
loc_api_sync_call_init();
int rc = loc_apicb_app_init();
if (rc >= 0)
{
LOC_LOGD("Loc API RPC client initialized.\n");
clnt_register_reset_notification_cb(loc_api_clnt, loc_api_glue_rpc_cb);
}
else {
LOC_LOGE("Loc API callback initialization failed.\n");
return 0;
}
}
return 1;
}
rpc_loc_client_handle_type loc_open (
rpc_loc_event_mask_type event_reg_mask,
loc_event_cb_f_type *event_callback,
loc_reset_notif_cb_f_type *rpc_cb,
void* userData
)
{
ENTRY_LOG();
LOC_GLUE_CHECK_INIT(rpc_loc_client_handle_type);
rpc_loc_client_handle_type ret_val;
rpc_loc_open_args args;
args.event_reg_mask = event_reg_mask;
int i;
for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
{
if (loc_glue_callback_table[i].cb_func == event_callback ||
loc_glue_callback_table[i].user == userData)
{
LOC_LOGW("Client already opened service (callback=%p)...\n",
event_callback);
break;
}
}
if (i == LOC_API_CB_MAX_CLIENTS)
{
for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
{
if (loc_glue_callback_table[i].cb_func == NULL)
{
loc_glue_callback_table[i].cb_func = event_callback;
loc_glue_callback_table[i].rpc_cb = rpc_cb;
loc_glue_callback_table[i].user = userData;
break;
}
}
}
if (i == LOC_API_CB_MAX_CLIENTS)
{
LOC_LOGE("Too many clients opened at once...\n");
return RPC_LOC_CLIENT_HANDLE_INVALID;
}
args.event_callback = loc_glue_callback_table[i].cb_id;
LOC_LOGV("cb_id=%d, func=0x%x", i, (unsigned int) event_callback);
rpc_loc_open_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
EXIT_LOG_CALLFLOW(%s, "loc client open");
stat = RPC_FUNC_VERSION(rpc_loc_open_, RPC_LOC_OPEN_VERSION)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
/* save the handle in the table */
loc_glue_callback_table[i].handle = (rpc_loc_client_handle_type) rets.loc_open_result;
ret_val = (rpc_loc_client_handle_type) rets.loc_open_result;
return ret_val;
}
int32 loc_close
(
rpc_loc_client_handle_type handle
)
{
ENTRY_LOG();
LOC_GLUE_CHECK_INIT(int32);
int32 ret_val;
rpc_loc_close_args args;
args.handle = handle;
rpc_loc_close_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
EXIT_LOG_CALLFLOW(%s, "loc client close");
stat = RPC_FUNC_VERSION(rpc_loc_close_, RPC_LOC_CLOSE_VERSION)(&args, &rets, loc_api_clnt);
loc_clear(handle);
LOC_GLUE_CHECK_RESULT(stat, int32);
ret_val = (int32) rets.loc_close_result;
return ret_val;
}
void loc_clear(rpc_loc_client_handle_type handle) {
/* Clean the client's callback function in callback table */
int i;
for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
{
if (loc_glue_callback_table[i].handle == handle)
{
/* Found the client */
loc_glue_callback_table[i].cb_func = NULL;
loc_glue_callback_table[i].rpc_cb = NULL;
loc_glue_callback_table[i].handle = -1;
break;
}
}
if (i == LOC_API_CB_MAX_CLIENTS)
{
LOC_LOGW("Handle not found (handle=%d)...\n", (int) handle);
}
}
int32 loc_start_fix
(
rpc_loc_client_handle_type handle
)
{
ENTRY_LOG();
LOC_GLUE_CHECK_INIT(int32);
int32 ret_val;
rpc_loc_start_fix_args args;
args.handle = handle;
rpc_loc_start_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
EXIT_LOG_CALLFLOW(%s, "loc start fix");
stat = RPC_FUNC_VERSION(rpc_loc_start_fix_, RPC_LOC_START_FIX_VERSION)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
ret_val = (int32) rets.loc_start_fix_result;
return ret_val;
}
int32 loc_stop_fix
(
rpc_loc_client_handle_type handle
)
{
ENTRY_LOG();
LOC_GLUE_CHECK_INIT(int32);
int32 ret_val;
rpc_loc_stop_fix_args args;
args.handle = handle;
rpc_loc_stop_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
EXIT_LOG_CALLFLOW(%s, "loc stop fix");
stat = RPC_FUNC_VERSION(rpc_loc_stop_fix_, RPC_LOC_STOP_FIX_VERSION)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
ret_val = (int32) rets.loc_stop_fix_result;
return ret_val;
}
int32 loc_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data
)
{
ENTRY_LOG();
LOC_GLUE_CHECK_INIT(int32);
int32 ret_val;
rpc_loc_ioctl_args args;
args.handle = handle;
args.ioctl_data = ioctl_data;
args.ioctl_type = ioctl_type;
if (ioctl_data != NULL)
{
/* Assign ioctl union discriminator */
ioctl_data->disc = ioctl_type;
/* In case the user hasn't filled in other disc fields,
automatically fill them in here */
switch (ioctl_type)
{
case RPC_LOC_IOCTL_GET_API_VERSION:
break;
case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
break;
case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
break;
case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
break;
case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
break;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
break;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
break;
case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
break;
case RPC_LOC_IOCTL_INJECT_UTC_TIME:
break;
case RPC_LOC_IOCTL_INJECT_RTC_VALUE:
break;
case RPC_LOC_IOCTL_INJECT_POSITION:
break;
case RPC_LOC_IOCTL_QUERY_ENGINE_STATE:
break;
case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
break;
case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
break;
case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
break;
case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
break;
case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
break;
case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
break;
case RPC_LOC_IOCTL_SET_NMEA_TYPES:
break;
case RPC_LOC_IOCTL_GET_NMEA_TYPES:
break;
case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_info.disc =
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_type;
break;
case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
break;
case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
break;
case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
break;
case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
break;
default:
break;
} /* switch */
} /* ioctl_data != NULL */
rpc_loc_ioctl_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
EXIT_LOG_CALLFLOW(%s, loc_get_ioctl_type_name(ioctl_type));
stat = RPC_FUNC_VERSION(rpc_loc_ioctl_, RPC_LOC_IOCTL_VERSION)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
ret_val = (int32) rets.loc_ioctl_result;
return ret_val;
}
/* Returns 0 if error */
int32 loc_api_null(void)
{
LOC_GLUE_CHECK_INIT(int32);
int32 rets;
enum clnt_stat stat = RPC_SUCCESS;
clnt_unregister_reset_notification_cb(loc_api_clnt);
stat = RPC_FUNC_VERSION(rpc_loc_api_null_, RPC_LOC_API_NULL_VERSION)(NULL, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets;
}
/*===========================================================================
FUNCTION loc_eng_ioctl
DESCRIPTION
This function calls loc_ioctl and waits for the callback result before
returning back to the user.
DEPENDENCIES
N/A
RETURN VALUE
TRUE if successful
FALSE if failed
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
)
{
int ret_val = RPC_LOC_API_SUCCESS;
ret_val = loc_api_sync_ioctl(handle, ioctl_type, ioctl_data_ptr, timeout_msec, cb_data_ptr);
LOC_LOGD("loc_eng_ioctl result: client = %d, ioctl_type = %s, returt %s\n",
(int32) handle,
loc_get_ioctl_type_name(ioctl_type),
loc_get_ioctl_status_name(ret_val) );
return ret_val;
}

510
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c
View file

@ -1,510 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <sys/time.h>
#include <string.h>
#include <pthread.h>
#include <rpc/rpc.h>
#include <loc_api_rpc_glue.h>
#include "loc_api_sync_call.h"
/* Logging */
#define LOG_TAG "LocSvc_api_rpc_glue"
// #define LOG_NDDEBUG 0
#include <utils/Log.h>
/***************************************************************************
* DATA FOR ASYNCHRONOUS RPC PROCESSING
**************************************************************************/
loc_sync_call_slot_array_s_type loc_sync_data;
pthread_mutex_t loc_sync_call_mutex = PTHREAD_MUTEX_INITIALIZER;
boolean loc_sync_call_inited = 0;
/*===========================================================================
FUNCTION loc_api_sync_call_init
DESCRIPTION
Initialize this module
DEPENDENCIES
N/A
RETURN VALUE
none
SIDE EFFECTS
N/A
===========================================================================*/
void loc_api_sync_call_init()
{
pthread_mutex_lock(&loc_sync_call_mutex);
if (loc_sync_call_inited == 1) {
pthread_mutex_unlock(&loc_sync_call_mutex);
return;
}
loc_sync_call_inited = 1;
loc_sync_data.num_of_slots = LOC_SYNC_CALL_SLOTS_MAX;
int i;
for (i = 0; i < loc_sync_data.num_of_slots; i++)
{
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
pthread_mutex_init(&slot->lock, NULL);
pthread_cond_init(&slot->loc_cb_arrived_cond, NULL);
slot->not_available = 0;
slot->in_use = 0;
slot->loc_handle = -1;
slot->loc_cb_wait_event_mask = 0; /* event to wait */
slot->loc_cb_received_event_mask = 0; /* received event */
}
pthread_mutex_unlock(&loc_sync_call_mutex);
}
/*===========================================================================
FUNCTION loc_api_sync_call_destroy
DESCRIPTION
Initialize this module
DEPENDENCIES
N/A
RETURN VALUE
none
SIDE EFFECTS
N/A
===========================================================================*/
void loc_api_sync_call_destroy()
{
int i;
pthread_mutex_lock(&loc_sync_call_mutex);
if (loc_sync_call_inited == 0) {
pthread_mutex_unlock(&loc_sync_call_mutex);
return;
}
loc_sync_call_inited = 0;
for (i = 0; i < loc_sync_data.num_of_slots; i++)
{
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
pthread_mutex_lock(&slot->lock);
slot->not_available = 1;
pthread_mutex_unlock(&slot->lock);
pthread_cond_destroy(&slot->loc_cb_arrived_cond);
pthread_mutex_destroy(&slot->lock);
}
pthread_mutex_unlock(&loc_sync_call_mutex);
}
/*===========================================================================
FUNCTION loc_match_callback
DESCRIPTION
Checks if an awaited event has arrived
RETURN VALUE
TRUE arrived
FALSE not matching
===========================================================================*/
static boolean loc_match_callback(
rpc_loc_event_mask_type wait_mask,
rpc_loc_ioctl_e_type wait_ioctl,
rpc_loc_event_mask_type event_mask,
const rpc_loc_event_payload_u_type *callback_payload
)
{
if ((event_mask & wait_mask) == 0) return FALSE;
if (event_mask != RPC_LOC_EVENT_IOCTL_REPORT || wait_ioctl == 0 ||
( (callback_payload != NULL) &&
callback_payload->rpc_loc_event_payload_u_type_u.ioctl_report.type == wait_ioctl) )
return TRUE;
return FALSE;
}
/*===========================================================================
FUNCTION loc_api_callback_process_sync_call
DESCRIPTION
Wakes up blocked API calls to check if the needed callback has arrived
DEPENDENCIES
N/A
RETURN VALUE
none
SIDE EFFECTS
N/A
===========================================================================*/
void loc_api_callback_process_sync_call(
rpc_loc_client_handle_type loc_handle, /* handle of the client */
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
)
{
int i;
LOGV("loc_handle = 0x%lx, loc_event = 0x%lx", loc_handle, loc_event);
for (i = 0; i < loc_sync_data.num_of_slots; i++)
{
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
pthread_mutex_lock(&slot->lock);
if (slot->in_use &&
slot->signal_sent == 0 &&
slot->loc_handle == loc_handle &&
loc_match_callback(slot->loc_cb_wait_event_mask, slot->ioctl_type, loc_event, loc_event_payload))
{
memcpy(&slot->loc_cb_received_payload, loc_event_payload, sizeof (rpc_loc_event_payload_u_type));
slot->loc_cb_received_event_mask = loc_event;
LOGV("signal slot %d in_use %d, loc_handle 0x%lx, event_mask 0x%1x, ioctl_type %d", i, slot->in_use, slot->loc_handle, (int) slot->loc_cb_wait_event_mask, (int) slot->ioctl_type);
pthread_cond_signal(&slot->loc_cb_arrived_cond);
slot->signal_sent = 1;
pthread_mutex_unlock(&slot->lock);
break;
} else {
/* do nothing */
}
pthread_mutex_unlock(&slot->lock);
}
}
/*===========================================================================
FUNCTION loc_lock_a_slot
DESCRIPTION
Allocates a buffer slot for the synchronous API call
DEPENDENCIES
N/A
RETURN VALUE
Select ID (>=0) : successful
-1 : buffer full
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_lock_a_slot()
{
int i, select_id = -1; /* no free buffer */
for (i = 0; i < loc_sync_data.num_of_slots; i++)
{
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
if (pthread_mutex_trylock(&slot->lock) == EBUSY)
{
LOGV("trylock EBUSY : %d", i);
continue;
}
if (!slot->in_use && !slot->not_available)
{
select_id = i;
slot->in_use = 1;
slot->signal_sent = 0;
/* Return from here and leave the mutex locked.
* will unlock it in loc_unlock_slot()
*/
break;
}
/* LOGV("slot %d in_use = %d, not_available = %d : %d", i, slot->in_use, slot->not_available, i); */
pthread_mutex_unlock(&slot->lock);
}
return select_id;
}
/*===========================================================================
FUNCTION loc_unlock_slot
DESCRIPTION
Frees a buffer slot after the synchronous API call
DEPENDENCIES
N/A
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_unlock_slot(int select_id)
{
loc_sync_data.slots[select_id].in_use = 0;
pthread_mutex_unlock(&loc_sync_data.slots[select_id].lock);
}
/*===========================================================================
FUNCTION loc_api_save_callback
DESCRIPTION
Selects which callback or IOCTL event to wait for.
The event_mask specifies the event(s). If it is RPC_LOC_EVENT_IOCTL_REPORT,
then ioctl_type specifies the IOCTL event.
If ioctl_type is non-zero, RPC_LOC_EVENT_IOCTL_REPORT is automatically added.
DEPENDENCIES
N/A
RETURN VALUE
Select ID (>=0) : successful
-1 : out of buffer
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_api_save_callback(
int select_id, /* Selected slot */
rpc_loc_client_handle_type loc_handle, /* Client handle */
rpc_loc_event_mask_type event_mask, /* Event mask to wait for */
rpc_loc_ioctl_e_type ioctl_type /* IOCTL type to wait for */
)
{
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
slot->loc_handle = loc_handle;
slot->loc_cb_wait_event_mask = event_mask;
slot->ioctl_type = ioctl_type;
if (ioctl_type) slot->loc_cb_wait_event_mask |= RPC_LOC_EVENT_IOCTL_REPORT;
return;
}
/*===========================================================================
FUNCTION loc_save_user_payload
DESCRIPTION
Saves received payload into user data structures
RETURN VALUE
None
===========================================================================*/
static void loc_save_user_payload(
rpc_loc_event_payload_u_type *user_cb_payload,
rpc_loc_ioctl_callback_s_type *user_ioctl_buffer,
const rpc_loc_event_payload_u_type *received_cb_payload
)
{
if (user_cb_payload)
{
memcpy(user_cb_payload, received_cb_payload,
sizeof (rpc_loc_event_payload_u_type));
}
if (user_ioctl_buffer)
{
memcpy(user_ioctl_buffer,
&received_cb_payload->rpc_loc_event_payload_u_type_u.ioctl_report,
sizeof *user_ioctl_buffer);
}
}
/*===========================================================================
FUNCTION loc_api_wait_callback
DESCRIPTION
Waits for a selected callback. The wait expires in timeout_seconds seconds.
If the function is called before an existing wait has finished, it will
immediately return EBUSY.
DEPENDENCIES
N/A
RETURN VALUE
RPC_LOC_API_SUCCESS if successful (0)
RPC_LOC_API_TIMEOUT if timed out
RPC_LOC_API_ENGINE_BUSY if already in a wait
RPC_LOC_API_INVALID_PARAMETER if callback is not yet selected
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_api_wait_callback(
int select_id, /* ID from loc_select_callback() */
int timeout_seconds, /* Timeout in this number of seconds */
rpc_loc_event_payload_u_type *callback_payload, /* Pointer to callback payload buffer, can be NULL */
rpc_loc_ioctl_callback_s_type *ioctl_payload /* Pointer to IOCTL payload, can be NULL */
)
{
int ret_val = RPC_LOC_API_SUCCESS; /* the return value of this function: 0 = no error */
int rc; /* return code from pthread calls */
struct timespec expire_time;
loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
clock_gettime(CLOCK_REALTIME, &expire_time);
expire_time.tv_sec += timeout_seconds;
/* Waiting */
while (slot->signal_sent == 0 && rc != ETIMEDOUT) {
rc = pthread_cond_timedwait(&slot->loc_cb_arrived_cond,
&slot->lock, &expire_time);
}
if (rc == ETIMEDOUT)
{
ret_val = RPC_LOC_API_TIMEOUT; /* Timed out */
LOGE("TIMEOUT: %d", select_id);
}
else {
/* Obtained the first awaited callback */
ret_val = RPC_LOC_API_SUCCESS; /* Successful */
loc_save_user_payload(callback_payload, ioctl_payload, &slot->loc_cb_received_payload);
}
return ret_val;
}
/*===========================================================================
FUNCTION loc_api_sync_ioctl
DESCRIPTION
Synchronous IOCTL call (reentrant version)
DEPENDENCIES
N/A
RETURN VALUE
Loc API error code (0 = success)
SIDE EFFECTS
N/A
===========================================================================*/
int loc_api_sync_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
)
{
int rc = -1;
int select_id;
rpc_loc_ioctl_callback_s_type callback_data;
select_id = loc_lock_a_slot();
if (select_id < 0 || select_id >= loc_sync_data.num_of_slots)
{
LOGE("slot not available ioctl_type = %s",
loc_get_ioctl_type_name(ioctl_type));
return rc;
}
// Select the callback we are waiting for
loc_api_save_callback(select_id, handle, 0, ioctl_type);
rc = loc_ioctl(handle, ioctl_type, ioctl_data_ptr);
if (rc != RPC_LOC_API_SUCCESS)
{
LOGE("loc_ioctl failed select_id = %d, ioctl_type %s, returned %s",
select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
}
else {
LOGV("select_id = %d, ioctl_type %d, returned RPC_LOC_API_SUCCESS",
select_id, ioctl_type);
// Wait for the callback of loc_ioctl
if ((rc = loc_api_wait_callback(select_id, timeout_msec / 1000, NULL, &callback_data)) != 0)
{
// Callback waiting failed
LOGE("callback wait failed select_id = %d, ioctl_type %s, returned %s",
select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
}
else
{
if (cb_data_ptr) memcpy(cb_data_ptr, &callback_data, sizeof *cb_data_ptr);
if (callback_data.status != RPC_LOC_API_SUCCESS)
{
rc = callback_data.status;
LOGE("callback status failed select_id = %d, ioctl_type %s, returned %s",
select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
} else {
LOGV("callback status success select_id = %d, ioctl_type %d, returned %d",
select_id, ioctl_type, rc);
}
} /* wait callback */
} /* loc_ioctl */
loc_unlock_slot(select_id);
return rc;
}

86
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c
View file

@ -1,86 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "rpc/rpc.h"
/* Include RPC headers */
#ifdef USE_LOCAL_RPC
#include "rpc_inc/loc_api_common.h"
#include "rpc_inc/loc_api.h"
#include "rpc_inc/loc_api_cb.h"
#endif
#ifdef USE_QCOM_AUTO_RPC
#include "loc_api_rpcgen_rpc.h"
#include "loc_api_rpcgen_common_rpc.h"
#include "loc_api_rpcgen_cb_rpc.h"
#endif
#include "rpc_inc/loc_api_fixup.h"
#include "loc_apicb_appinit.h"
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
static SVCXPRT* svrPort = NULL;
extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
int loc_apicb_app_init(void)
{
/* Register a callback server to use the loc_apicbprog_* function */
if (svrPort == NULL) {
svrPort = svcrtr_create();
}
if (!svrPort) return -1;
xprt_register(svrPort);
if(svc_register(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
{
return 0;
}
else
{
return -1;
}
}
void loc_apicb_app_deinit(void)
{
if (svrPort == NULL)
{
return;
}
svc_unregister(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001);
xprt_unregister(svrPort);
svc_destroy(svrPort);
svrPort = NULL;
}

35
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
View file

@ -1,35 +0,0 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
# functions
LOC_RPCGEN_APIS_PATH := $(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
LOC_RPCGEN_APIS_PATH_FL := ../../../../../$(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
LOCAL_MODULE := libloc_api_rpcgen
LOCAL_SHARED_LIBRARIES := \
librpc \
libcommondefs
LOCAL_SRC_FILES += \
src/loc_api_rpcgen_cb_xdr.c \
src/loc_api_rpcgen_common_xdr.c \
src/loc_api_rpcgen_cb_svc.c \
src/loc_api_rpcgen_clnt.c \
src/loc_api_rpcgen_xdr.c
LOCAL_C_INCLUDES += hardware/msm7k/librpc
LOCAL_C_INCLUDES += $(LOC_RPCGEN_APIS_PATH)/../../SHARED_LIBRARIES/libcommondefs_intermediates/inc
LOCAL_C_INCLUDES += $(LOCAL_PATH)/inc
LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc
LOCAL_COPY_HEADERS_TO := loc_api/rpcgen/inc
LOCAL_COPY_HEADERS := inc/loc_api_rpcgen_rpc.h
LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_common_rpc.h
LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_cb_rpc.h
LOCAL_COPY_HEADERS += inc/loc_apicb_appinit.h
LOCAL_LDLIBS += -lpthread
LOCAL_PRELINK_MODULE := false
include $(BUILD_STATIC_LIBRARY)

156
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h
View file

@ -1,156 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_CB_RPC_H_RPCGEN
#define _LOC_API_CB_RPC_H_RPCGEN
#include "librpc.h"
#include "commondefs_rpcgen_rpc.h"
#include "loc_api_rpcgen_common_rpc.h"
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
typedef struct rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_args;
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
typedef struct rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_rets;
#define LOC_APICBVERS 0x00050006
#define LOC_APICBPROG 0x3100008C
#define LOC_APICBVERS_0001 0x00050001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, CLIENT *);
extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, struct svc_req *);
extern int loc_apicbprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001();
extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc();
extern int loc_apicbprog_0x00050001_freeresult ();
#endif /* K&R C */
#define LOC_APICBVERS_0002 0x00050002
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_api_cb_null 0xffffff00
extern enum clnt_stat rpc_loc_api_cb_null_0x00050002(void *, int *, CLIENT *);
extern bool_t rpc_loc_api_cb_null_0x00050002_svc(void *, int *, struct svc_req *);
extern int loc_apicbprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_api_cb_null 0xffffff00
extern enum clnt_stat rpc_loc_api_cb_null_0x00050002();
extern bool_t rpc_loc_api_cb_null_0x00050002_svc();
extern int loc_apicbprog_0x00050002_freeresult ();
#endif /* K&R C */
#define LOC_APICBVERS_0003 0x00050003
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_cb_null_0x00050003(void *, int *, CLIENT *);
extern bool_t rpc_loc_api_cb_null_0x00050003_svc(void *, int *, struct svc_req *);
extern int loc_apicbprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_cb_null_0x00050003();
extern bool_t rpc_loc_api_cb_null_0x00050003_svc();
extern int loc_apicbprog_0x00050003_freeresult ();
#endif /* K&R C */
#define LOC_APICBVERS_0004 0x00050004
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_cb_null_0x00050004(void *, int *, CLIENT *);
extern bool_t rpc_loc_api_cb_null_0x00050004_svc(void *, int *, struct svc_req *);
extern int loc_apicbprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_cb_null_0x00050004();
extern bool_t rpc_loc_api_cb_null_0x00050004_svc();
extern int loc_apicbprog_0x00050004_freeresult ();
#endif /* K&R C */
#define LOC_APICBVERS_0005 0x00050005
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_cb_null_0x00050005(void *, int *, CLIENT *);
extern bool_t rpc_loc_api_cb_null_0x00050005_svc(void *, int *, struct svc_req *);
extern int loc_apicbprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_cb_null_0x00050005();
extern bool_t rpc_loc_api_cb_null_0x00050005_svc();
extern int loc_apicbprog_0x00050005_freeresult ();
#endif /* K&R C */
#define LOC_APICBVERS_0006 0x00050006
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_cb_null_0x00050006(void *, int *, CLIENT *);
extern bool_t rpc_loc_api_cb_null_0x00050006_svc(void *, int *, struct svc_req *);
extern int loc_apicbprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_cb_null_0x00050006();
extern bool_t rpc_loc_api_cb_null_0x00050006_svc();
extern int loc_apicbprog_0x00050006_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_event_cb_f_type_args (XDR *, rpc_loc_event_cb_f_type_args*);
extern bool_t xdr_rpc_loc_event_cb_f_type_rets (XDR *, rpc_loc_event_cb_f_type_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_event_cb_f_type_args ();
extern bool_t xdr_rpc_loc_event_cb_f_type_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_CB_RPC_H_RPCGEN */

1261
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h
View file

File diff suppressed because it is too large Load diff

288
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h
View file

@ -1,288 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_RPC_H_RPCGEN
#define _LOC_API_RPC_H_RPCGEN
#include "librpc.h"
#include "commondefs_rpcgen_rpc.h"
#include "loc_api_rpcgen_common_rpc.h"
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
u_int rpc_loc_api_api_versions_return_type_len;
rpc_uint32 *rpc_loc_api_api_versions_return_type_val;
} rpc_loc_api_api_versions_return_type;
typedef rpc_uint32 rpc_loc_event_cb_f_type;
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
typedef struct rpc_loc_open_args rpc_loc_open_args;
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_close_args rpc_loc_close_args;
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_start_fix_args rpc_loc_start_fix_args;
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_stop_fix_args rpc_loc_stop_fix_args;
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
typedef struct rpc_loc_ioctl_args rpc_loc_ioctl_args;
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
typedef struct rpc_loc_api_api_version_s_args rpc_loc_api_api_version_s_args;
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers;
rpc_uint32 features;
rpc_uint32 proghash;
rpc_uint32 cbproghash;
};
typedef struct rpc_loc_api_rpc_glue_code_info_remote_rets rpc_loc_api_rpc_glue_code_info_remote_rets;
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
typedef struct rpc_loc_open_rets rpc_loc_open_rets;
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
typedef struct rpc_loc_close_rets rpc_loc_close_rets;
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
typedef struct rpc_loc_start_fix_rets rpc_loc_start_fix_rets;
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
typedef struct rpc_loc_stop_fix_rets rpc_loc_stop_fix_rets;
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
typedef struct rpc_loc_ioctl_rets rpc_loc_ioctl_rets;
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
typedef struct rpc_loc_api_api_versions_rets rpc_loc_api_api_versions_rets;
#define LOC_APIVERS 0x00050006
#define LOC_APIPROG 0x3000008C
#define LOC_APIVERS_0001 0x00050001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00050001(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050001_svc(void *, void *, struct svc_req *);
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, CLIENT *);
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, struct svc_req *);
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00050001(rpc_loc_open_args *, rpc_loc_open_rets *, CLIENT *);
extern bool_t rpc_loc_open_0x00050001_svc(rpc_loc_open_args *, rpc_loc_open_rets *, struct svc_req *);
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00050001(rpc_loc_close_args *, rpc_loc_close_rets *, CLIENT *);
extern bool_t rpc_loc_close_0x00050001_svc(rpc_loc_close_args *, rpc_loc_close_rets *, struct svc_req *);
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, CLIENT *);
extern bool_t rpc_loc_start_fix_0x00050001_svc(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, struct svc_req *);
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, CLIENT *);
extern bool_t rpc_loc_stop_fix_0x00050001_svc(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, struct svc_req *);
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, CLIENT *);
extern bool_t rpc_loc_ioctl_0x00050001_svc(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, struct svc_req *);
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00050001(void *, rpc_loc_api_api_versions_rets *, CLIENT *);
extern bool_t rpc_loc_api_api_versions_0x00050001_svc(void *, rpc_loc_api_api_versions_rets *, struct svc_req *);
extern int loc_apiprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00050001();
extern bool_t rpc_loc_api_null_0x00050001_svc();
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001();
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc();
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00050001();
extern bool_t rpc_loc_open_0x00050001_svc();
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00050001();
extern bool_t rpc_loc_close_0x00050001_svc();
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00050001();
extern bool_t rpc_loc_start_fix_0x00050001_svc();
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00050001();
extern bool_t rpc_loc_stop_fix_0x00050001_svc();
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00050001();
extern bool_t rpc_loc_ioctl_0x00050001_svc();
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00050001();
extern bool_t rpc_loc_api_api_versions_0x00050001_svc();
extern int loc_apiprog_0x00050001_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0002 0x00050002
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00050002(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050002_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00050002();
extern bool_t rpc_loc_api_null_0x00050002_svc();
extern int loc_apiprog_0x00050002_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0003 0x00050003
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00050003(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050003_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00050003();
extern bool_t rpc_loc_api_null_0x00050003_svc();
extern int loc_apiprog_0x00050003_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0004 0x00050004
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00050004(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050004_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00050004();
extern bool_t rpc_loc_api_null_0x00050004_svc();
extern int loc_apiprog_0x00050004_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0005 0x00050005
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00050005(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050005_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00050005();
extern bool_t rpc_loc_api_null_0x00050005_svc();
extern int loc_apiprog_0x00050005_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0006 0x00050006
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00050006(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00050006_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00050006();
extern bool_t rpc_loc_api_null_0x00050006_svc();
extern int loc_apiprog_0x00050006_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_api_api_versions_return_type (XDR *, rpc_loc_api_api_versions_return_type*);
extern bool_t xdr_rpc_loc_event_cb_f_type (XDR *, rpc_loc_event_cb_f_type*);
extern bool_t xdr_rpc_loc_open_args (XDR *, rpc_loc_open_args*);
extern bool_t xdr_rpc_loc_close_args (XDR *, rpc_loc_close_args*);
extern bool_t xdr_rpc_loc_start_fix_args (XDR *, rpc_loc_start_fix_args*);
extern bool_t xdr_rpc_loc_stop_fix_args (XDR *, rpc_loc_stop_fix_args*);
extern bool_t xdr_rpc_loc_ioctl_args (XDR *, rpc_loc_ioctl_args*);
extern bool_t xdr_rpc_loc_api_api_version_s_args (XDR *, rpc_loc_api_api_version_s_args*);
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *, rpc_loc_api_rpc_glue_code_info_remote_rets*);
extern bool_t xdr_rpc_loc_open_rets (XDR *, rpc_loc_open_rets*);
extern bool_t xdr_rpc_loc_close_rets (XDR *, rpc_loc_close_rets*);
extern bool_t xdr_rpc_loc_start_fix_rets (XDR *, rpc_loc_start_fix_rets*);
extern bool_t xdr_rpc_loc_stop_fix_rets (XDR *, rpc_loc_stop_fix_rets*);
extern bool_t xdr_rpc_loc_ioctl_rets (XDR *, rpc_loc_ioctl_rets*);
extern bool_t xdr_rpc_loc_api_api_versions_rets (XDR *, rpc_loc_api_api_versions_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_api_api_versions_return_type ();
extern bool_t xdr_rpc_loc_event_cb_f_type ();
extern bool_t xdr_rpc_loc_open_args ();
extern bool_t xdr_rpc_loc_close_args ();
extern bool_t xdr_rpc_loc_start_fix_args ();
extern bool_t xdr_rpc_loc_stop_fix_args ();
extern bool_t xdr_rpc_loc_ioctl_args ();
extern bool_t xdr_rpc_loc_api_api_version_s_args ();
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets ();
extern bool_t xdr_rpc_loc_open_rets ();
extern bool_t xdr_rpc_loc_close_rets ();
extern bool_t xdr_rpc_loc_start_fix_rets ();
extern bool_t xdr_rpc_loc_stop_fix_rets ();
extern bool_t xdr_rpc_loc_ioctl_rets ();
extern bool_t xdr_rpc_loc_api_api_versions_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_RPC_H_RPCGEN */

34
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h
View file

@ -1,34 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* Initialization function for callbacks */
int loc_apicb_app_init();
void loc_apicb_app_deinit();

327
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c
View file

@ -1,327 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_rpcgen_cb_rpc.h"
#include <stdio.h>
#include <stdlib.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#ifndef SIG_PF
#define SIG_PF void(*)(int)
#endif
void
loc_apicbprog_0x00050001(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_0x00050001_arg;
} argument;
union {
rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_0x00050001_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_event_cb_f_type:
_xdr_argument = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_args;
_xdr_result = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_rets;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_event_cb_f_type_0x00050001_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050001_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}
void
loc_apicbprog_0x00050002(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
union {
int rpc_loc_api_cb_null_0x00050002_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_api_cb_null:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_int;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050002_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050002_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}
void
loc_apicbprog_0x00050003(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
union {
int rpc_loc_api_cb_null_0x00050003_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_api_cb_null:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_int;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050003_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050003_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}
void
loc_apicbprog_0x00050004(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
union {
int rpc_loc_api_cb_null_0x00050004_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_api_cb_null:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_int;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050004_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050004_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}
void
loc_apicbprog_0x00050005(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
union {
int rpc_loc_api_cb_null_0x00050005_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_api_cb_null:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_int;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050005_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050005_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}
void
loc_apicbprog_0x00050006(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
int fill;
} argument;
union {
int rpc_loc_api_cb_null_0x00050006_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_api_cb_null:
_xdr_argument = (xdrproc_t) xdr_void;
_xdr_result = (xdrproc_t) xdr_int;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050006_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00050006_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}

60
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c
View file

@ -1,60 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_rpcgen_cb_rpc.h"
bool_t
xdr_rpc_loc_event_cb_f_type_args (XDR *xdrs, rpc_loc_event_cb_f_type_args *objp)
{
;
if (!xdr_rpc_uint32 (xdrs, &objp->cb_id))
return FALSE;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_handle))
return FALSE;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->loc_event))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->loc_event_payload, sizeof (rpc_loc_event_payload_u_type), (xdrproc_t) xdr_rpc_loc_event_payload_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type_rets (XDR *xdrs, rpc_loc_event_cb_f_type_rets *objp)
{
;
if (!xdr_rpc_int32 (xdrs, &objp->loc_event_cb_f_type_result))
return FALSE;
return TRUE;
}

155
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c
View file

@ -1,155 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include <memory.h> /* for memset */
#include "loc_api_rpcgen_rpc.h"
/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };
enum clnt_stat
rpc_loc_api_null_0x00050001(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *argp, rpc_loc_api_rpc_glue_code_info_remote_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_rpc_glue_code_info_remote,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_rpc_glue_code_info_remote_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_open_0x00050001(rpc_loc_open_args *argp, rpc_loc_open_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_open,
(xdrproc_t) xdr_rpc_loc_open_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_open_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_close_0x00050001(rpc_loc_close_args *argp, rpc_loc_close_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_close,
(xdrproc_t) xdr_rpc_loc_close_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_close_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *argp, rpc_loc_start_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_start_fix,
(xdrproc_t) xdr_rpc_loc_start_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_start_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *argp, rpc_loc_stop_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_stop_fix,
(xdrproc_t) xdr_rpc_loc_stop_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_stop_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *argp, rpc_loc_ioctl_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_ioctl,
(xdrproc_t) xdr_rpc_loc_ioctl_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_ioctl_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_api_versions_0x00050001(void *argp, rpc_loc_api_api_versions_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_api_versions,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_api_versions_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00050002(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00050003(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00050004(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00050005(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00050006(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}

1775
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c
View file

File diff suppressed because it is too large Load diff

199
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c
View file

@ -1,199 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_rpcgen_rpc.h"
bool_t
xdr_rpc_loc_api_api_versions_return_type (XDR *xdrs, rpc_loc_api_api_versions_return_type *objp)
{
;
if (!xdr_array (xdrs, (char **)&objp->rpc_loc_api_api_versions_return_type_val, (u_int *) &objp->rpc_loc_api_api_versions_return_type_len, ~0,
sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type (XDR *xdrs, rpc_loc_event_cb_f_type *objp)
{
;
if (!xdr_rpc_uint32 (xdrs, objp))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_args (XDR *xdrs, rpc_loc_open_args *objp)
{
;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->event_reg_mask))
return FALSE;
if (!xdr_rpc_loc_event_cb_f_type (xdrs, &objp->event_callback))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_args (XDR *xdrs, rpc_loc_close_args *objp)
{
;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_args (XDR *xdrs, rpc_loc_start_fix_args *objp)
{
;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_args (XDR *xdrs, rpc_loc_stop_fix_args *objp)
{
;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_args (XDR *xdrs, rpc_loc_ioctl_args *objp)
{
;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->ioctl_type))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->ioctl_data, sizeof (rpc_loc_ioctl_data_u_type), (xdrproc_t) xdr_rpc_loc_ioctl_data_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_version_s_args (XDR *xdrs, rpc_loc_api_api_version_s_args *objp)
{
;
if (!xdr_rpc_boolean (xdrs, &objp->len_not_null))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *xdrs, rpc_loc_api_rpc_glue_code_info_remote_rets *objp)
{
;
if (!xdr_rpc_uint32 (xdrs, &objp->toolvers))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->features))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->proghash))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->cbproghash))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_rets (XDR *xdrs, rpc_loc_open_rets *objp)
{
;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_open_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_rets (XDR *xdrs, rpc_loc_close_rets *objp)
{
;
if (!xdr_rpc_int32 (xdrs, &objp->loc_close_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_rets (XDR *xdrs, rpc_loc_start_fix_rets *objp)
{
;
if (!xdr_rpc_int32 (xdrs, &objp->loc_start_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_rets (XDR *xdrs, rpc_loc_stop_fix_rets *objp)
{
;
if (!xdr_rpc_int32 (xdrs, &objp->loc_stop_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_rets (XDR *xdrs, rpc_loc_ioctl_rets *objp)
{
;
if (!xdr_rpc_int32 (xdrs, &objp->loc_ioctl_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_versions_rets (XDR *xdrs, rpc_loc_api_api_versions_rets *objp)
{
;
if (!xdr_rpc_loc_api_api_versions_return_type (xdrs, &objp->loc_api_api_versions_result))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->len, sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}

74
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c
View file

@ -1,74 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "librpc.h"
#include "loc_api_rpcgen_rpc.h"
#include "loc_api_rpcgen_cb_rpc.h"
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
static SVCXPRT* svrPort = NULL;
extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
int loc_apicb_app_init(void)
{
/* Register a callback server to use the loc_apicbprog_0x00010001 */
if (svrPort == NULL) {
svrPort = svcrtr_create();
}
if (!svrPort) return -1;
xprt_register(svrPort);
if(svc_register(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
{
return 0;
}
else
{
return -1;
}
}
void loc_apicb_app_deinit(void)
{
if (svrPort == NULL)
{
return;
}
svc_unregister(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001);
}

261
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr
View file

@ -1,261 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* LOC_API TOOL VERSION: 4.48 */
/* GENERATED: TUE JUN 14 2011 */
/*=============================================================================
L O C _ A P I . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
the loc_api API.
---------------------------------------------------------------------------
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
loc_api Definition File(s):
Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
typedef rpc_uint32 rpc_loc_api_api_versions_return_type<>;
/*
* Declare an rpc_uint32 type for each callback type in the API
*/
typedef rpc_uint32 rpc_loc_event_cb_f_type;
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
/*
* These are struct declarations for the function results
*/
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers; /* Tool version */
rpc_uint32 features; /* Features turned on in the code.
* 0x00000001 ONCRPC Server Cleanup Support
*/
rpc_uint32 proghash; /* Unique hash value for the API XDR definition */
rpc_uint32 cbproghash; /* Unique hash value for the Callbacks' XDR definition */
};
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
/*
* XDR definition of the LOC_API program ( vers. 0x00050006 )
*/
program LOC_APIPROG {
version LOC_APIVERS_0001 {
void
rpc_loc_api_null( void ) = 0;
rpc_loc_api_rpc_glue_code_info_remote_rets
rpc_loc_api_rpc_glue_code_info_remote( void ) = 1;
rpc_loc_open_rets
rpc_loc_open( rpc_loc_open_args ) = 2;
rpc_loc_close_rets
rpc_loc_close( rpc_loc_close_args ) = 3;
rpc_loc_start_fix_rets
rpc_loc_start_fix( rpc_loc_start_fix_args ) = 4;
rpc_loc_stop_fix_rets
rpc_loc_stop_fix( rpc_loc_stop_fix_args ) = 5;
rpc_loc_ioctl_rets
rpc_loc_ioctl( rpc_loc_ioctl_args ) = 6;
rpc_loc_api_api_versions_rets
rpc_loc_api_api_versions( void ) = 0xFFFFFFFF;
} = 0x00050001;
version LOC_APIVERS_0002 {
/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
*/
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
RPC_LOC_IOCTL_RESERVED_CMD
RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00050002;
version LOC_APIVERS_0003 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
RPC_LOC_IOCTL_SET_DATA_ENABLE
RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00050003;
version LOC_APIVERS_0004 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
RPC_LOC_IOCTL_GET_SUPL_VERSION
RPC_LOC_IOCTL_SET_SUPL_VERSION
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00050004;
version LOC_APIVERS_0005 {
/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
RPC_LOC_SERVER_ADDR_IPV6
*/
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00050005;
version LOC_APIVERS_0006 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
*/
/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
RPC_LOC_SERVER_REQUEST_MULTI_OPEN
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00050006;
} = 0x3000008C;
const LOC_APIVERS = 0x00050006;

187
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr
View file

@ -1,187 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* LOC_API TOOL VERSION: 4.48 */
/* GENERATED: TUE JUN 14 2011 */
/*=============================================================================
L O C _ A P I _ C B . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
an api that represents the grouping of the different callback functions the
loc_api API supports.
---------------------------------------------------------------------------
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
loc_api Definition File(s):
Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
/*
* These are struct declaratios for the function results
*/
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
/*
* XDR definition of the LOC_API callback program ( vers. 0x00050006 )
*/
program LOC_APICBPROG {
version LOC_APICBVERS_0001 {
rpc_loc_event_cb_f_type_rets
rpc_loc_event_cb_f_type( rpc_loc_event_cb_f_type_args ) = 1;
} = 0x00050001;
version LOC_APICBVERS_0002 {
/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
*/
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
RPC_LOC_IOCTL_RESERVED_CMD
RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
*/
int
rpc_loc_api_cb_null( void ) = 0xffffff00;
} = 0x00050002;
version LOC_APICBVERS_0003 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
RPC_LOC_IOCTL_SET_DATA_ENABLE
RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
*/
int
rpc_loc_api_cb_null( void ) = 0xffffff00;
} = 0x00050003;
version LOC_APICBVERS_0004 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
RPC_LOC_IOCTL_GET_SUPL_VERSION
RPC_LOC_IOCTL_SET_SUPL_VERSION
*/
int
rpc_loc_api_cb_null( void ) = 0xffffff00;
} = 0x00050004;
version LOC_APICBVERS_0005 {
/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
RPC_LOC_SERVER_ADDR_IPV6
*/
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
*/
int
rpc_loc_api_cb_null( void ) = 0xffffff00;
} = 0x00050005;
version LOC_APICBVERS_0006 {
/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
*/
/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
RPC_LOC_SERVER_REQUEST_MULTI_OPEN
*/
int
rpc_loc_api_cb_null( void ) = 0xffffff00;
} = 0x00050006;
} = 0x3100008C;
const LOC_APICBVERS = 0x00050006;

1021
loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr
View file

File diff suppressed because it is too large Load diff

60
loc_api/libloc_api-rpc/Android.mk
View file

@ -1,60 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
AMSS_VERSION:=$(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION)
RPC_INC:=inc-$(AMSS_VERSION)
generated_files:= \
gen-$(AMSS_VERSION)/loc_api_clnt.c \
gen-$(AMSS_VERSION)/loc_api_cb_xdr.c \
gen-$(AMSS_VERSION)/loc_api_common_xdr.c \
gen-$(AMSS_VERSION)/loc_api_cb_svc.c \
gen-$(AMSS_VERSION)/loc_api_xdr.c \
gen-$(AMSS_VERSION)/loc_api_fixup.c \
gen-$(AMSS_VERSION)/loc_api_rpc_glue.c \
src/loc_apicb_appinit.c
LOCAL_SRC_FILES:= $(generated_files)
# removed from library build since the client should implement this code.
# src/loc_api_cb_server.c
LOCAL_CFLAGS:=-fno-short-enums
LOCAL_CFLAGS+=-include $(RPC_INC)/loc_api_common.h
LOCAL_CFLAGS+=-DDEBUG
# LOCAL_CFLAGS+=-DDEBUG -DVERBOSE
LOCAL_CFLAGS+=-DADD_XDR_FLOAT -DADD_XDR_BOOL
LOCAL_SHARED_LIBRARIES:= librpc
LOCAL_STATIC_LIBRARIES:= libcommondefs-rpc
LOCAL_COPY_HEADERS_TO:= libloc_api-rpc/inc
LOCAL_COPY_HEADERS:= \
$(RPC_INC)/loc_api_cb.h \
$(RPC_INC)/loc_api_common.h \
$(RPC_INC)/loc_api.h \
$(RPC_INC)/loc_api_fixup.h \
$(RPC_INC)/loc_apicb_appinit.h \
inc/debug.h \
inc/loc_api_rpc_glue.h
LOCAL_C_INCLUDES:= \
$(LOCAL_PATH) \
$(LOCAL_PATH)/inc \
$(LOCAL_PATH)/$(RPC_INC) \
$(TARGET_OUT_HEADERS)/libcommondefs-rpc \
$(TARGET_OUT_HEADERS)/librpc
LOCAL_MODULE:= libloc_api-rpc
include $(BUILD_STATIC_LIBRARY)
endif
endif

29
loc_api/libloc_api-rpc/gen-1240/Makefile.xdr
View file

@ -1,29 +0,0 @@
CLIENTS:= loc_api
SERVERS:= loc_api_cb
COMMON:= loc_api_common
RPC_INC:= inc-$(AMSS_VERSION)
all: $(CLIENTS) $(SERVERS) $(COMMON) fixup
$(CLIENTS) $(SERVERS) $(COMMON):: xdr = $(@:=.xdr)
$(CLIENTS) $(SERVERS) $(COMMON)::
rpcgen -h -M $(xdr) -o ../$(RPC_INC)/$(addsuffix .h, $@)
rpcgen -c -M $(xdr) -o $(addsuffix _xdr.c, $@)
$(CLIENTS)::
rpcgen -l -M $(xdr) -o $(addsuffix _clnt.c, $@)
$(SERVERS)::
rpcgen -m -M $(xdr) -o $(addsuffix _svc.c, $@)
fixup:
mv ../$(RPC_INC)/loc_api_common.h ../$(RPC_INC)/loc_api_common.h.bak
sed ../$(RPC_INC)/loc_api_common.h.bak -e "/#include <rpc/a#include \"loc_api_fixup.h\"" > ../$(RPC_INC)/loc_api_common.h
rm -f ../$(RPC_INC)/loc_api_common.h.bak
clean:
rm -f $(addsuffix _clnt.c, $(CLIENTS))
rm -f $(addsuffix _svc.c, $(SERVERS))
rm -f $(addsuffix _xdr.c, $(CLIENTS) $(SERVERS) $(COMMON))
rm -f $(addprefix ../$(RPC_INC)/, $(addsuffix .h, $(CLIENTS) $(SERVERS) $(COMMON)))

172
loc_api/libloc_api-rpc/gen-1240/loc_api.xdr
View file

@ -1,172 +0,0 @@
/* LOC_API TOOL VERSION: 4.36 */
/*=============================================================================
L O C _ A P I . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
the loc_api API.
---------------------------------------------------------------------------
Copyright (c) 2010 QUALCOMM Incorporated.
All Rights Reserved. QUALCOMM Proprietary and Confidential.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/htorpc.pl#20
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Start.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Output.pm#29
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Parser.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Metacomments.pm#6
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/SymbolTable.pm#3
loc_api Definition File(s):
Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#16
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
typedef rpc_uint32 rpc_loc_api_api_versions_return_type<>;
/*
* Declare an rpc_uint32 type for each callback type in the API
*/
typedef rpc_uint32 rpc_loc_event_cb_f_type;
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
/*
* These are struct declarations for the function results
*/
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers; /* Tool version */
rpc_uint32 features; /* Features turned on in the code.
* 0x00000001 ONCRPC Server Cleanup Support
*/
rpc_uint32 proghash; /* Unique hash value for the API XDR definition */
rpc_uint32 cbproghash; /* Unique hash value for the Callbacks' XDR definition */
};
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
/*
* XDR definition of the LOC_API program ( vers. 0x00040002 )
*/
program LOC_APIPROG {
version LOC_APIVERS_0001 {
void
rpc_loc_api_null( void ) = 0;
rpc_loc_api_rpc_glue_code_info_remote_rets
rpc_loc_api_rpc_glue_code_info_remote( void ) = 1;
rpc_loc_open_rets
rpc_loc_open( rpc_loc_open_args ) = 2;
rpc_loc_close_rets
rpc_loc_close( rpc_loc_close_args ) = 3;
rpc_loc_start_fix_rets
rpc_loc_start_fix( rpc_loc_start_fix_args ) = 4;
rpc_loc_stop_fix_rets
rpc_loc_stop_fix( rpc_loc_stop_fix_args ) = 5;
rpc_loc_ioctl_rets
rpc_loc_ioctl( rpc_loc_ioctl_args ) = 6;
rpc_loc_api_api_versions_rets
rpc_loc_api_api_versions( void ) = 0xFFFFFFFF;
} = 0x00040001;
version LOC_APIVERS_0002 {
/* Following elements added in enum rpc_loc_ni_event_e_type in 0x00040002
RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ
*/
void
rpc_loc_api_null( void ) = 0;
} = 0x00040002;
} = 0x3000008c;
const LOC_APIVERS = 0x00040002;

85
loc_api/libloc_api-rpc/gen-1240/loc_api_cb.xdr
View file

@ -1,85 +0,0 @@
/* LOC_API TOOL VERSION: 4.36 */
/*=============================================================================
L O C _ A P I _ C B . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
an api that represents the grouping of the different callback functions the
loc_api API supports.
---------------------------------------------------------------------------
Copyright (c) 2010 QUALCOMM Incorporated.
All Rights Reserved. QUALCOMM Proprietary and Confidential.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/htorpc.pl#20
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Start.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Output.pm#29
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Parser.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Metacomments.pm#6
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/SymbolTable.pm#3
loc_api Definition File(s):
Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#16
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
/*
* These are struct declaratios for the function results
*/
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
/*
* XDR definition of the LOC_API callback program ( vers. 0x00040002 )
*/
program LOC_APICBPROG {
version LOC_APICBVERS_0001 {
rpc_loc_event_cb_f_type_rets
rpc_loc_event_cb_f_type( rpc_loc_event_cb_f_type_args ) = 1;
} = 0x00040001;
} = 0x3100008c;
const LOC_APICBVERS = 0x00040002;

64
loc_api/libloc_api-rpc/gen-1240/loc_api_cb_svc.c
View file

@ -1,64 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_cb.h"
#include <stdio.h>
#include <stdlib.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#ifndef SIG_PF
#define SIG_PF void(*)(int)
#endif
void
loc_apicbprog_0x00040001(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_0x00040001_arg;
} argument;
union {
rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_0x00040001_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_event_cb_f_type:
_xdr_argument = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_args;
_xdr_result = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_rets;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_event_cb_f_type_0x00040001_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00040001_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}

32
loc_api/libloc_api-rpc/gen-1240/loc_api_cb_xdr.c
View file

@ -1,32 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_cb.h"
bool_t
xdr_rpc_loc_event_cb_f_type_args (XDR *xdrs, rpc_loc_event_cb_f_type_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, &objp->cb_id))
return FALSE;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_handle))
return FALSE;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->loc_event))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->loc_event_payload, sizeof (rpc_loc_event_payload_u_type), (xdrproc_t) xdr_rpc_loc_event_payload_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type_rets (XDR *xdrs, rpc_loc_event_cb_f_type_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_event_cb_f_type_result))
return FALSE;
return TRUE;
}

91
loc_api/libloc_api-rpc/gen-1240/loc_api_clnt.c
View file

@ -1,91 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include <memory.h> /* for memset */
#include "loc_api.h"
/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };
enum clnt_stat
rpc_loc_api_null_0x00040001(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_rpc_glue_code_info_remote_0x00040001(void *argp, rpc_loc_api_rpc_glue_code_info_remote_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_rpc_glue_code_info_remote,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_rpc_glue_code_info_remote_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_open_0x00040001(rpc_loc_open_args *argp, rpc_loc_open_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_open,
(xdrproc_t) xdr_rpc_loc_open_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_open_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_close_0x00040001(rpc_loc_close_args *argp, rpc_loc_close_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_close,
(xdrproc_t) xdr_rpc_loc_close_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_close_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_start_fix_0x00040001(rpc_loc_start_fix_args *argp, rpc_loc_start_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_start_fix,
(xdrproc_t) xdr_rpc_loc_start_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_start_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_stop_fix_0x00040001(rpc_loc_stop_fix_args *argp, rpc_loc_stop_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_stop_fix,
(xdrproc_t) xdr_rpc_loc_stop_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_stop_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_ioctl_0x00040001(rpc_loc_ioctl_args *argp, rpc_loc_ioctl_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_ioctl,
(xdrproc_t) xdr_rpc_loc_ioctl_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_ioctl_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_api_versions_0x00040001(void *argp, rpc_loc_api_api_versions_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_api_versions,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_api_versions_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_null_0x00040002(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}

906
loc_api/libloc_api-rpc/gen-1240/loc_api_common.xdr
View file

@ -1,906 +0,0 @@
/* LOC_API TOOL VERSION: 4.36 */
/*=============================================================================
L O C _ A P I _ C O M M O N . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
an api that represents the grouping of the different callback functions the
loc_api API supports.
---------------------------------------------------------------------------
Copyright (c) 2010 QUALCOMM Incorporated.
All Rights Reserved. QUALCOMM Proprietary and Confidential.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/htorpc.pl#20
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Start.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Output.pm#29
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Parser.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/Metacomments.pm#6
Id: //source/qcom/qct/core/mproc/tools/rel/04.01/htorpc/lib/Htorpc/SymbolTable.pm#3
loc_api Definition File(s):
Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#16
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
const LOC_API_TOOLVERS = 0x00040024;
const LOC_API_FEATURES = 0x00000001;
const RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST = 0x00000010;
const RPC_LOC_EVENT_WPS_NEEDED_REQUEST = 0x00000200;
const RPC_LOC_EVENT_IOCTL_REPORT = 0x00000080;
const RPC_LOC_EVENT_LOCATION_SERVER_REQUEST = 0x00000040;
const RPC_LOC_EVENT_RESERVED = 0x8000000000000000;
const RPC_LOC_EVENT_PARSED_POSITION_REPORT = 0x00000001;
const RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST = 0x00000020;
const RPC_LOC_EVENT_NMEA_POSITION_REPORT = 0x00000008;
const RPC_LOC_EVENT_SATELLITE_REPORT = 0x00000002;
const RPC_LOC_EVENT_STATUS_REPORT = 0x00000100;
const RPC_LOC_EVENT_CB_F_TYPE_VERSION = 0x00040001;
const RPC_LOC_OPEN_VERSION = 0x00040001;
const RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION = 0x00040001;
const RPC_LOC_API_NULL_VERSION = 0x00040001;
const RPC_LOC_STOP_FIX_VERSION = 0x00040001;
const RPC_LOC_IOCTL_VERSION = 0x00040001;
const RPC_LOC_START_FIX_VERSION = 0x00040001;
const RPC_LOC_CLOSE_VERSION = 0x00040001;
const RPC_LOC_API_API_VERSIONS_VERSION = 0x00040001;
const RPC_LOC_API_API_MAJOR_NUM = 0x0004;
const RPC_LOC_APIAPI_VERSION_IS_HASHKEY = 0;
typedef bool rpc_boolean;
typedef unsigned long rpc_uint32;
typedef unsigned short rpc_uint16;
typedef unsigned char rpc_uint8;
typedef long rpc_int32;
typedef unsigned char rpc_byte;
typedef unsigned hyper rpc_uint64;
typedef rpc_int32 rpc_loc_client_handle_type;
typedef rpc_uint64 rpc_loc_event_mask_type;
typedef rpc_uint64 rpc_loc_position_valid_mask_type;
typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
enum rpc_loc_session_status_e_type {
RPC_LOC_SESS_STATUS_SUCCESS = 0,
RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
RPC_LOC_SESS_STATUS_TIMEOUT = 3,
RPC_LOC_SESS_STATUS_USER_END = 4,
RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
RPC_LOC_SESS_STATUS_MAX = 268435456
};
struct rpc_loc_calendar_time_s_type {
rpc_uint16 year;
unsigned char month;
unsigned char day_of_week;
unsigned char day;
unsigned char hour;
unsigned char minute;
unsigned char second;
rpc_uint16 millisecond;
};
struct rpc_loc_parsed_position_s_type {
rpc_loc_position_valid_mask_type valid_mask;
rpc_loc_session_status_e_type session_status;
rpc_loc_calendar_time_s_type timestamp_calendar;
rpc_uint64 timestamp_utc;
rpc_uint8 leap_seconds;
float time_unc;
double latitude;
double longitude;
float altitude_wrt_ellipsoid;
float altitude_wrt_mean_sea_level;
float speed_horizontal;
float speed_vertical;
float heading;
float hor_unc_circular;
float hor_unc_ellipse_semi_major;
float hor_unc_ellipse_semi_minor;
float hor_unc_ellipse_orient_azimuth;
float vert_unc;
float speed_unc;
float heading_unc;
unsigned char confidence_horizontal;
unsigned char confidence_vertical;
float magnetic_deviation;
rpc_loc_pos_technology_mask_type technology_mask;
};
enum rpc_loc_sv_system_e_type {
RPC_LOC_SV_SYSTEM_GPS = 1,
RPC_LOC_SV_SYSTEM_GALILEO = 2,
RPC_LOC_SV_SYSTEM_SBAS = 3,
RPC_LOC_SV_SYSTEM_COMPASS = 4,
RPC_LOC_SV_SYSTEM_GLONASS = 5,
RPC_LOC_SV_SYSTEM_MAX = 268435456
};
enum rpc_loc_sv_status_e_type {
RPC_LOC_SV_STATUS_IDLE = 1,
RPC_LOC_SV_STATUS_SEARCH = 2,
RPC_LOC_SV_STATUS_TRACK = 3,
RPC_LOC_SV_STATUS_MAX = 268435456
};
typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
struct rpc_loc_sv_info_s_type {
rpc_loc_sv_info_valid_mask_type valid_mask;
rpc_loc_sv_system_e_type system;
rpc_uint8 prn;
rpc_uint8 health_status;
rpc_loc_sv_status_e_type process_status;
rpc_boolean has_eph;
rpc_boolean has_alm;
float elevation;
float azimuth;
float snr;
};
typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
struct rpc_loc_gnss_info_s_type {
rpc_loc_gnss_info_valid_mask_type valid_mask;
float position_dop;
float horizontal_dop;
float vertical_dop;
rpc_boolean altitude_assumed;
rpc_uint16 sv_count;
rpc_loc_sv_info_s_type sv_list<80>; /* EVAL:[LOC_API_MAX_SV_COUNT]*/
};
struct rpc_loc_nmea_report_s_type {
rpc_uint16 length;
opaque nmea_sentences[1200]; /* EVAL:[1200]*/
};
enum rpc_loc_status_event_e_type {
RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE = 2,
RPC_LOC_STATUS_EVENT_MAX = 268435456
};
enum rpc_loc_engine_state_e_type {
RPC_LOC_ENGINE_STATE_ON = 1,
RPC_LOC_ENGINE_STATE_OFF = 2,
RPC_LOC_ENGINE_STATE_MAX = 268435456
};
enum rpc_loc_fix_session_state_e_type {
RPC_LOC_FIX_SESSION_STATE_BEGIN = 1,
RPC_LOC_FIX_SESSION_STATE_END = 2,
RPC_LOC_FIX_SESSION_STATE_MAX = 268435456
};
union rpc_loc_status_event_payload_u_type switch (rpc_loc_status_event_e_type disc) {
case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
rpc_loc_engine_state_e_type engine_state;
case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
rpc_loc_fix_session_state_e_type fix_session_state;
default:
void;
};
struct rpc_loc_status_event_s_type {
rpc_loc_status_event_e_type event;
rpc_loc_status_event_payload_u_type payload;
};
enum rpc_loc_server_addr_e_type {
RPC_LOC_SERVER_ADDR_IPV4 = 1,
RPC_LOC_SERVER_ADDR_URL = 2,
RPC_LOC_SERVER_ADDR_MAX = 268435456
};
struct rpc_loc_server_addr_ipv4_type {
rpc_uint32 addr;
rpc_uint16 port;
};
struct rpc_loc_server_addr_url_type {
rpc_uint16 length;
opaque addr[256]; /* EVAL:[256]*/
};
union rpc_loc_server_addr_u_type switch (rpc_loc_server_addr_e_type disc) {
case RPC_LOC_SERVER_ADDR_IPV4:
rpc_loc_server_addr_ipv4_type ipv4;
case RPC_LOC_SERVER_ADDR_URL:
rpc_loc_server_addr_url_type url;
default:
void;
};
struct rpc_loc_server_info_s_type {
rpc_loc_server_addr_e_type addr_type;
rpc_loc_server_addr_u_type addr_info;
};
enum rpc_loc_ni_notify_verify_e_type {
RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456
};
enum rpc_loc_ni_event_e_type {
RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ = 4,
RPC_LOC_NI_EVENT_MAX = 268435456
};
enum rpc_loc_ni_datacoding_scheme_e_type {
RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
RPC_LOC_NI_PRESUPL_ISO8859 = 1,
RPC_LOC_NI_PRESUPL_UTF8 = 2,
RPC_LOC_NI_PRESUPL_UTF16 = 3,
RPC_LOC_NI_PRESUPL_UCS2 = 4,
RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
RPC_LOC_NI_PRESUPL_JIS = 7,
RPC_LOC_NI_PRESUPL_EUC = 8,
RPC_LOC_NI_PRESUPL_GB2312 = 9,
RPC_LOC_NI_PRESUPL_CNS11643 = 10,
RPC_LOC_NI_PRESUPL_KSC1001 = 11,
RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
RPC_LOC_NI_SS_GERMAN = 12,
RPC_LOC_NI_SS_ENGLISH = 13,
RPC_LOC_NI_SS_ITALIAN = 14,
RPC_LOC_NI_SS_FRENCH = 15,
RPC_LOC_NI_SS_SPANISH = 16,
RPC_LOC_NI_SS_DUTCH = 17,
RPC_LOC_NI_SS_SWEDISH = 18,
RPC_LOC_NI_SS_DANISH = 19,
RPC_LOC_NI_SS_PORTUGUESE = 20,
RPC_LOC_NI_SS_FINNISH = 21,
RPC_LOC_NI_SS_NORWEGIAN = 22,
RPC_LOC_NI_SS_GREEK = 23,
RPC_LOC_NI_SS_TURKISH = 24,
RPC_LOC_NI_SS_HUNGARIAN = 25,
RPC_LOC_NI_SS_POLISH = 26,
RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
RPC_LOC_NI_SUPL_UTF8 = 28,
RPC_LOC_NI_SUPL_UCS2 = 29,
RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647
};
enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
RPC_LOC_NI_VX_OCTET = 0,
RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
RPC_LOC_NI_VX_ASCII = 2,
RPC_LOC_NI_VX_IA5 = 3,
RPC_LOC_NI_VX_UNICODE = 4,
RPC_LOC_NI_VX_SHIFT_JIS = 5,
RPC_LOC_NI_VX_KOREAN = 6,
RPC_LOC_NI_VX_LATIN_HEBREW = 7,
RPC_LOC_NI_VX_LATIN = 8,
RPC_LOC_NI_VX_GSM = 9,
RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456
};
enum rpc_loc_ni_vx_pos_mode_e_type {
RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
RPC_LOC_VX_MS_BASED_ONLY = 2,
RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
RPC_LOC_VX_POS_MODE_MAX = 268435456
};
struct rpc_loc_ni_vx_requester_id_s_type {
unsigned char requester_id_length;
opaque requester_id[200]; /* EVAL:[200]*/
};
struct rpc_loc_ni_vx_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
unsigned char pos_qos_incl;
unsigned char pos_qos;
rpc_uint32 num_fixes;
rpc_uint32 tbf;
rpc_loc_ni_vx_pos_mode_e_type pos_mode;
rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
rpc_loc_ni_vx_requester_id_s_type requester_id;
rpc_uint16 user_resp_timer_val;
};
enum rpc_loc_ni_supl_pos_method_e_type {
RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
RPC_LOC_NI_POSMETHOD_AFLT = 6,
RPC_LOC_NI_POSMETHOD_ECID = 7,
RPC_LOC_NI_POSMETHOD_EOTD = 8,
RPC_LOC_NI_POSMETHOD_OTDOA = 9,
RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
RPC_LOC_NI_POSMETHOD_MAX = 268435456
};
struct rpc_loc_ni_supl_slp_session_id_s_type {
unsigned char presence;
opaque session_id[4]; /* EVAL:[4]*/
rpc_loc_server_info_s_type slp_address;
};
struct rpc_loc_ni_requestor_id_s_type {
unsigned char data_coding_scheme;
opaque requestor_id_string[200]; /* EVAL:[200]*/
unsigned char string_len;
};
struct rpc_loc_ni_supl_client_name_s_type {
unsigned char data_coding_scheme;
opaque client_name_string[64]; /* EVAL:[64]*/
unsigned char string_len;
};
struct rpc_loc_ni_supl_qop_s_type {
unsigned char bit_mask;
unsigned char horacc;
unsigned char veracc;
rpc_uint16 maxLocAge;
unsigned char delay;
};
struct rpc_loc_ni_supl_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
rpc_uint16 flags;
rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
opaque supl_hash[8]; /* EVAL:[8]*/
rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
rpc_loc_ni_supl_pos_method_e_type pos_method;
rpc_loc_ni_requestor_id_s_type requestor_id;
rpc_loc_ni_supl_client_name_s_type client_name;
rpc_loc_ni_supl_qop_s_type supl_qop;
rpc_uint16 user_response_timer;
};
struct rpc_loc_ni_ext_client_address_s_type {
unsigned char ext_client_address_len;
opaque ext_client_address[20]; /* EVAL:[20]*/
};
enum rpc_loc_ni_location_type_e_type {
RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456
};
struct rpc_loc_ni_deferred_location_s_type {
unsigned char unused_bits;
unsigned char ms_available;
};
struct rpc_loc_ni_codeword_string_s_type {
unsigned char data_coding_scheme;
opaque lcs_codeword_string[20]; /* EVAL:[20]*/
unsigned char string_len;
};
struct rpc_loc_ni_service_type_id_s_type {
unsigned char lcs_service_type_id;
};
struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
unsigned char invoke_id;
rpc_uint16 flags;
unsigned char notification_length;
opaque notification_text[64]; /* EVAL:[64]*/
rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
rpc_loc_ni_location_type_e_type location_type;
rpc_loc_ni_deferred_location_s_type deferred_location;
rpc_loc_ni_requestor_id_s_type requestor_id;
rpc_loc_ni_codeword_string_s_type codeword_string;
rpc_loc_ni_service_type_id_s_type service_type_id;
rpc_uint16 user_response_timer;
};
enum rpc_loc_ni_service_interaction_e_type {
RPC_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO = 1,
RPC_LOC_NI_SERVICE_INTERACTION_MAX = 268435456
};
struct rpc_loc_ni_vx_service_interaction_req_s_type {
rpc_loc_ni_vx_notify_verify_req_s_type ni_vx_req;
rpc_loc_ni_service_interaction_e_type service_interation_type;
};
union rpc_loc_ni_event_payload_u_type switch (rpc_loc_ni_event_e_type disc) {
case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ:
rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req;
default:
void;
};
struct rpc_loc_ni_event_s_type {
rpc_loc_ni_event_e_type event;
rpc_loc_ni_event_payload_u_type payload;
};
enum rpc_loc_assist_data_request_e_type {
RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
RPC_LOC_ASSIST_DATA_MAX = 268435456
};
typedef string rpc_struct_loc_time_download_source_s_type_servers_ptr<256>; /* EVAL:[LOC_API_MAX_SERVER_ADDR_LENGTH]*/
typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3]; /* EVAL:[3]*/
struct rpc_loc_time_download_source_s_type {
rpc_uint32 delay_threshold;
rpc_struct_loc_time_download_source_s_type_servers servers;
};
typedef string rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr<256>; /* EVAL:[LOC_API_MAX_SERVER_ADDR_LENGTH]*/
typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3]; /* EVAL:[3]*/
struct rpc_loc_predicted_orbits_data_source_s_type {
rpc_uint32 max_file_size;
rpc_uint32 max_part_size;
rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
};
union rpc_loc_assist_data_request_payload_u_type switch (rpc_loc_assist_data_request_e_type disc) {
case RPC_LOC_ASSIST_DATA_TIME_REQ:
rpc_loc_time_download_source_s_type time_download;
case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
rpc_loc_predicted_orbits_data_source_s_type data_download;
default:
void;
};
struct rpc_loc_assist_data_request_s_type {
rpc_loc_assist_data_request_e_type event;
rpc_loc_assist_data_request_payload_u_type payload;
};
typedef rpc_uint32 rpc_loc_server_connection_handle;
enum rpc_loc_server_protocol_e_type {
RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
RPC_LOC_SERVER_PROTOCOL_MAX = 16777216
};
enum rpc_loc_server_request_e_type {
RPC_LOC_SERVER_REQUEST_OPEN = 1,
RPC_LOC_SERVER_REQUEST_CLOSE = 2,
RPC_LOC_SERVER_REQUEST_MAX = 268435456
};
struct rpc_loc_server_open_req_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_protocol_e_type protocol;
};
struct rpc_loc_server_close_req_s_type {
rpc_loc_server_connection_handle conn_handle;
};
union rpc_loc_server_request_u_type switch (rpc_loc_server_request_e_type disc) {
case RPC_LOC_SERVER_REQUEST_OPEN:
rpc_loc_server_open_req_s_type open_req;
case RPC_LOC_SERVER_REQUEST_CLOSE:
rpc_loc_server_close_req_s_type close_req;
default:
void;
};
struct rpc_loc_server_request_s_type {
rpc_loc_server_request_e_type event;
rpc_loc_server_request_u_type payload;
};
enum rpc_loc_qwip_request_e_type {
RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0,
RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM,
RPC_LOC_QWIP_STOP_PERIODIC_FIXES,
RPC_LOC_QWIP_SUSPEND,
RPC_LOC_QWIP_REQUEST_MAX = 268435456
};
struct rpc_loc_qwip_request_s_type {
rpc_loc_qwip_request_e_type request_type;
rpc_uint16 tbf_ms;
};
struct rpc_loc_reserved_payload_s_type {
rpc_uint16 data_size;
opaque data<>;
};
enum rpc_loc_ioctl_e_type {
RPC_LOC_IOCTL_GET_API_VERSION = 1,
RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
RPC_LOC_IOCTL_INJECT_POSITION = 407,
RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT = 411,
RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS = 412,
RPC_LOC_IOCTL_ACCESS_EFS_DATA = 413,
RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824
};
struct rpc_loc_api_version_s_type {
unsigned char major;
unsigned char minor;
};
enum rpc_loc_fix_recurrence_e_type {
RPC_LOC_PERIODIC_FIX = 1,
RPC_LOC_SINGLE_FIX = 2,
RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456
};
enum rpc_loc_operation_mode_e_type {
RPC_LOC_OPER_MODE_DEFAULT = 1,
RPC_LOC_OPER_MODE_MSB = 2,
RPC_LOC_OPER_MODE_MSA = 3,
RPC_LOC_OPER_MODE_STANDALONE = 4,
RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
RPC_LOC_OPER_MODE_CELL_ID = 8,
RPC_LOC_OPER_MODE_MAX = 268435456
};
enum rpc_loc_notify_e_type {
RPC_LOC_NOTIFY_ON_INTERVAL = 1,
RPC_LOC_NOTIFY_ON_DISTANCE = 2,
RPC_LOC_NOTIFY_ON_ANY = 3,
RPC_LOC_NOTIFY_ON_ALL = 4,
RPC_LOC_NOTIFY_TYPE_MAX = 268435456
};
struct rpc_loc_fix_criteria_s_type {
rpc_uint32 valid_mask;
rpc_loc_fix_recurrence_e_type recurrence_type;
rpc_loc_operation_mode_e_type preferred_operation_mode;
rpc_uint32 preferred_accuracy;
rpc_uint32 preferred_response_time;
rpc_boolean intermediate_pos_report_enabled;
rpc_loc_notify_e_type notify_type;
rpc_uint32 min_interval;
float min_distance;
rpc_uint32 min_dist_sample_interval;
};
enum rpc_loc_ni_user_resp_e_type {
RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456
};
struct rpc_loc_user_verify_s_type {
rpc_loc_ni_user_resp_e_type user_resp;
rpc_loc_ni_event_s_type ni_event_pass_back;
};
enum rpc_loc_predicted_orbits_data_format_e_type {
RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456
};
struct rpc_loc_predicted_orbits_data_s_type {
rpc_loc_predicted_orbits_data_format_e_type format_type;
rpc_uint32 total_size;
rpc_uint8 total_parts;
rpc_uint8 part;
rpc_uint16 part_len;
opaque data_ptr<>;
};
struct rpc_loc_predicted_orbits_data_validity_report_s_type {
rpc_uint64 start_time_utc;
rpc_uint16 valid_duration_hrs;
};
struct rpc_loc_predicted_orbits_auto_download_config_s_type {
rpc_boolean enable;
unsigned char auto_check_every_hrs;
};
struct rpc_loc_assist_data_time_s_type {
rpc_uint64 time_utc;
rpc_uint32 uncertainty;
};
typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
struct rpc_loc_assist_data_pos_s_type {
rpc_loc_assist_pos_valid_mask_type valid_mask;
rpc_uint64 timestamp_utc;
double latitude;
double longitude;
float altitude_wrt_ellipsoid;
float altitude_wrt_mean_sea_level;
float hor_unc_circular;
float vert_unc;
unsigned char confidence_horizontal;
unsigned char confidence_vertical;
rpc_int32 timestamp_age;
};
enum rpc_loc_server_open_status_e_type {
RPC_LOC_SERVER_OPEN_SUCCESS = 1,
RPC_LOC_SERVER_OPEN_FAIL = 2,
RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456
};
struct rpc_loc_server_open_status_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_open_status_e_type open_status;
opaque apn_name[100]; /* EVAL:[100]*/
};
enum rpc_loc_server_close_status_e_type {
RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
RPC_LOC_SERVER_CLOSE_FAIL = 2,
RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456
};
struct rpc_loc_server_close_status_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_close_status_e_type close_status;
};
struct rpc_loc_wiper_fix_time_s_type {
rpc_uint32 slow_clock_count;
};
struct rpc_loc_wiper_fix_pos_s_type {
rpc_int32 lat;
rpc_int32 lon;
rpc_uint16 HEPE;
rpc_uint8 num_of_aps_used;
rpc_uint8 fix_error_code;
};
struct rpc_loc_wiper_ap_info_s_type {
opaque mac_addr[6]; /* EVAL:[6]*/
rpc_int32 rssi;
rpc_uint16 channel;
rpc_uint8 ap_qualifier;
};
struct rpc_loc_wiper_ap_set_s_type {
rpc_uint8 num_of_aps;
rpc_loc_wiper_ap_info_s_type ap_info[50]; /* EVAL:[50]*/
};
struct rpc_loc_wiper_position_report_s_type {
rpc_uint8 wiper_valid_info_flag;
rpc_loc_wiper_fix_time_s_type wiper_fix_time;
rpc_loc_wiper_fix_pos_s_type wiper_fix_position;
rpc_loc_wiper_ap_set_s_type wiper_ap_set;
};
enum rpc_loc_wiper_status_e_type {
RPC_LOC_WIPER_STATUS_AVAILABLE = 1,
RPC_LOC_WIPER_STATUS_UNAVAILABLE = 2,
RPC_LOC_WIPER_STATUS_E_SIZE = 268435456
};
enum rpc_loc_fs_operation_e_type {
RPC_LOC_FS_CREATE_WRITE_FILE = 1,
RPC_LOC_FS_APPEND_FILE = 2,
RPC_LOC_FS_DELETE_FILE = 3,
RPC_LOC_FS_READ_FILE = 4,
RPC_LOC_FS_MAX = 268435456
};
struct rpc_loc_efs_data_s_type {
opaque filename[64]; /* EVAL:[64]*/
rpc_loc_fs_operation_e_type operation;
rpc_uint32 total_size;
opaque data_ptr<>;
rpc_uint32 part_len;
rpc_uint8 part;
rpc_uint8 total_parts;
rpc_uint32 reserved;
};
enum rpc_loc_lock_e_type {
RPC_LOC_LOCK_NONE = 1,
RPC_LOC_LOCK_MI = 2,
RPC_LOC_LOCK_MT = 3,
RPC_LOC_LOCK_ALL = 4,
RPC_LOC_LOCK_MAX = 268435456
};
typedef rpc_uint32 rpc_loc_nmea_sentence_type;
typedef rpc_uint32 rpc_loc_assist_data_type;
struct rpc_loc_assist_data_delete_s_type {
rpc_loc_assist_data_type type;
rpc_uint32 reserved[8]; /* EVAL:[8]*/
};
union rpc_loc_ioctl_data_u_type switch (rpc_loc_ioctl_e_type disc) {
case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
rpc_loc_fix_criteria_s_type fix_criteria;
case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
rpc_loc_user_verify_s_type user_verify_resp;
case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
case RPC_LOC_IOCTL_INJECT_UTC_TIME:
rpc_loc_assist_data_time_s_type assistance_data_time;
case RPC_LOC_IOCTL_INJECT_POSITION:
rpc_loc_assist_data_pos_s_type assistance_data_position;
case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
rpc_loc_server_open_status_s_type conn_open_status;
case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
rpc_loc_server_close_status_s_type conn_close_status;
case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT:
rpc_loc_wiper_position_report_s_type wiper_pos;
case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS:
rpc_loc_wiper_status_e_type wiper_status;
case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
rpc_loc_lock_e_type engine_lock;
case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
rpc_boolean sbas_mode;
case RPC_LOC_IOCTL_SET_NMEA_TYPES:
rpc_loc_nmea_sentence_type nmea_types;
case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
rpc_boolean on_demand_lpm;
case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
rpc_loc_server_info_s_type server_addr;
case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
rpc_loc_assist_data_delete_s_type assist_data_delete;
case RPC_LOC_IOCTL_ACCESS_EFS_DATA:
rpc_loc_efs_data_s_type efs_data;
default:
void;
};
union rpc_loc_ioctl_callback_data_u_type switch (rpc_loc_ioctl_e_type disc) {
case RPC_LOC_IOCTL_GET_API_VERSION:
rpc_loc_api_version_s_type api_version;
case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
rpc_loc_fix_criteria_s_type fix_criteria;
case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
rpc_loc_lock_e_type engine_lock;
case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
rpc_boolean sbas_mode;
case RPC_LOC_IOCTL_GET_NMEA_TYPES:
rpc_loc_nmea_sentence_type nmea_types;
case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
rpc_boolean on_demand_lpm;
case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
rpc_loc_server_info_s_type server_addr;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
default:
void;
};
struct rpc_loc_ioctl_callback_s_type {
rpc_loc_ioctl_e_type type;
rpc_int32 status;
rpc_loc_ioctl_callback_data_u_type data;
};
union rpc_loc_event_payload_u_type switch (unsigned hyper disc) {
case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
rpc_loc_parsed_position_s_type parsed_location_report;
case RPC_LOC_EVENT_SATELLITE_REPORT:
rpc_loc_gnss_info_s_type gnss_report;
case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
rpc_loc_nmea_report_s_type nmea_report;
case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
rpc_loc_ni_event_s_type ni_request;
case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
rpc_loc_assist_data_request_s_type assist_data_request;
case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
rpc_loc_server_request_s_type loc_server_request;
case RPC_LOC_EVENT_IOCTL_REPORT:
rpc_loc_ioctl_callback_s_type ioctl_report;
case RPC_LOC_EVENT_STATUS_REPORT:
rpc_loc_status_event_s_type status_report;
case RPC_LOC_EVENT_WPS_NEEDED_REQUEST:
rpc_loc_qwip_request_s_type qwip_request;
case RPC_LOC_EVENT_RESERVED:
rpc_loc_reserved_payload_s_type reserved;
default:
void;
};

1650
loc_api/libloc_api-rpc/gen-1240/loc_api_common_xdr.c
View file

File diff suppressed because it is too large Load diff

48
loc_api/libloc_api-rpc/gen-1240/loc_api_fixup.c
View file

@ -1,48 +0,0 @@
/*=============================================================================
L O C _ A P I _ F I X U P . C
GENERAL DESCRIPTION
This file adds API constants that are not automatically transmitted to
the RPC stubs, and it also fixes other RPC-related problems.
---------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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 <rpc/rpc.h>
#include "loc_api_fixup.h"
#ifdef ADD_XDR_FLOAT
int
xdr_float(xdrp, fp)
XDR *xdrp;
float *fp;
{
return xdr_long(xdrp, (long*)fp);
}
int
xdr_double(xdrp, dp)
XDR *xdrp;
double *dp;
{
return xdr_long(xdrp, (long*)dp + 1)
&& xdr_long(xdrp, (long*)dp);
}
#endif /* ADD_XDR_FLOAT */

339
loc_api/libloc_api-rpc/gen-1240/loc_api_rpc_glue.c
View file

@ -1,339 +0,0 @@
/******************************************************************************
@file loc_api_rpc_glue.c
@brief Android Loc API glue code using rpcgen.
DESCRIPTION
Loc API glue code for Android
-----------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
-----------------------------------------------------------------------------
******************************************************************************/
/*=====================================================================
EDIT HISTORY FOR MODULE
This section contains comments describing changes made to the module.
Notice that changes are listed in reverse chronological order.
when who what, where, why
-------- --- -------------------------------------------------------
03/05/2009 dx Initial version
======================================================================*/
/*=====================================================================
INCLUDE FILES FOR MODULE
======================================================================*/
//#define LOG_NDDEBUG 0
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <rpc/rpc.h>
#include <rpc/clnt.h>
/* Include RPC headers */
#include "loc_api_rpc_glue.h"
/* Callback init */
#include "loc_apicb_appinit.h"
/* Logging */
#define LOG_TAG "lib_api_rpc_glue"
#include <utils/Log.h>
/* Comment this out to enable logging */
#undef LOGD
#define LOGD(...) {}
/*=====================================================================
External declarations
======================================================================*/
CLIENT* loc_api_clnt = NULL;
/* Callback ID and pointer */
#define LOC_API_CB_ID 1
loc_event_cb_f_type *loc_api_saved_cb = NULL; /* the only callback of Loc API client */
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_FUNC_VERSION(a,b) RPC_FUNC_VERSION_BASE(a,b)
#define LOC_GLUE_CHECK_INIT(ret_type) \
if (loc_api_clnt == NULL) { return (ret_type) RPC_LOC_API_RPC_FAILURE; }
#define LOC_GLUE_CHECK_RESULT(stat, ret_type) \
if (stat != RPC_SUCCESS) { return (ret_type) RPC_LOC_API_RPC_FAILURE; }
/* Callback functions */
/* Returns 1 if successful */
bool_t rpc_loc_event_cb_f_type_0x00040001_svc(
rpc_loc_event_cb_f_type_args *argp,
rpc_loc_event_cb_f_type_rets *ret,
struct svc_req *req)
{
/* Callback not registered, or unexpected ID (shouldn't happen) */
if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID)
{
LOGD("Warning: No callback handler.\n");
ret->loc_event_cb_f_type_result = 0;
return 1; /* simply return */
}
LOGD("proc: %x prog: %x vers: %x\n",
(int) req->rq_proc,
(int) req->rq_prog,
(int) req->rq_vers);
LOGD("Callback received: %x (handle=%d ret_ptr=%d)\n",
(int) argp->loc_event,
(int) argp->loc_handle,
(int) ret);
/* Forward callback to real callback procedure */
rpc_loc_client_handle_type loc_handle = argp->loc_handle;
rpc_loc_event_mask_type loc_event = argp->loc_event;
const rpc_loc_event_payload_u_type* loc_event_payload =
(const rpc_loc_event_payload_u_type*) argp->loc_event_payload;
int32 rc = loc_api_saved_cb(loc_handle, loc_event, loc_event_payload);
ret->loc_event_cb_f_type_result = rc;
return 1; /* ok */
}
int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
{
xdr_free (xdr_result, result);
/*
* Insert additional freeing code here, if needed
*/
// LOGD("***** loc_apicbprog_freeresult\n");
return 1;
}
int loc_apicbprog_0x00040001_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
{
return loc_apicbprog_freeresult (transp, xdr_result, result);
}
/*===========================================================================
FUNCTION loc_api_glue_init
DESCRIPTION
Initiates the RPC client
RETURN VALUE
1 for success
0 for failure
===========================================================================*/
int loc_api_glue_init(void)
{
if (loc_api_clnt == NULL)
{
/* Print msg */
LOGD("Trying to create RPC client...\n");
loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL);
LOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
if (loc_api_clnt == NULL)
{
fprintf(stderr, "Error: cannot create RPC client.\n");
return 0;
}
/* Init RPC callbacks */
int rc = loc_apicb_app_init();
if (rc >= 0)
{
LOGD("Loc API callback initialized.\n");
} else {
fprintf(stderr, "Loc API callback initialization failed.\n");
return 0;
}
}
return 1;
}
rpc_loc_client_handle_type loc_open (
rpc_loc_event_mask_type event_reg_mask,
loc_event_cb_f_type *event_callback
)
{
LOC_GLUE_CHECK_INIT(rpc_loc_client_handle_type);
rpc_loc_open_args args;
args.event_reg_mask = event_reg_mask;
args.event_callback = LOC_API_CB_ID;
loc_api_saved_cb = event_callback;
rpc_loc_open_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_open_, /* LOC_APIVERS */ 0x00040001)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (rpc_loc_client_handle_type) rets.loc_open_result;
}
int32 loc_close(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_close_args args;
args.handle = handle;
rpc_loc_close_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_close_, /* LOC_APIVERS */ 0x00040001)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_close_result;
}
int32 loc_start_fix(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_start_fix_args args;
args.handle = handle;
rpc_loc_start_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_start_fix_, /* LOC_APIVERS */ 0x00040001)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_start_fix_result;
}
int32 loc_stop_fix(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_stop_fix_args args;
args.handle = handle;
rpc_loc_stop_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_stop_fix_, /* LOC_APIVERS */ 0x00040001)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_stop_fix_result;
}
int32 loc_ioctl(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data
)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_ioctl_args args;
args.handle = handle;
args.ioctl_data = ioctl_data;
args.ioctl_type = ioctl_type;
if (ioctl_data != NULL)
{
/* Assign ioctl union discriminator */
ioctl_data->disc = ioctl_type;
/* In case the user hasn't filled in other disc fields,
automatically fill them in here */
switch (ioctl_type)
{
case RPC_LOC_IOCTL_GET_API_VERSION:
case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
case RPC_LOC_IOCTL_INJECT_UTC_TIME:
case RPC_LOC_IOCTL_INJECT_RTC_VALUE:
case RPC_LOC_IOCTL_INJECT_POSITION:
case RPC_LOC_IOCTL_QUERY_ENGINE_STATE:
case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
case RPC_LOC_IOCTL_SET_NMEA_TYPES:
case RPC_LOC_IOCTL_GET_NMEA_TYPES:
break;
case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_info.disc =
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_type;
break;
case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
break;
case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
default:
break;
} /* switch */
} /* ioctl_data != NULL */
rpc_loc_ioctl_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_ioctl_, /* LOC_APIVERS */ 0x00040001)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_ioctl_result;
}
/* Returns 0 if error */
int32 loc_api_null(void)
{
LOC_GLUE_CHECK_INIT(int32);
int32 rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_api_null_, LOC_APIVERS)(NULL, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets;
}

171
loc_api/libloc_api-rpc/gen-1240/loc_api_xdr.c
View file

@ -1,171 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api.h"
bool_t
xdr_rpc_loc_api_api_versions_return_type (XDR *xdrs, rpc_loc_api_api_versions_return_type *objp)
{
register int32_t *buf;
if (!xdr_array (xdrs, (char **)&objp->rpc_loc_api_api_versions_return_type_val, (u_int *) &objp->rpc_loc_api_api_versions_return_type_len, ~0,
sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type (XDR *xdrs, rpc_loc_event_cb_f_type *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, objp))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_args (XDR *xdrs, rpc_loc_open_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->event_reg_mask))
return FALSE;
if (!xdr_rpc_loc_event_cb_f_type (xdrs, &objp->event_callback))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_args (XDR *xdrs, rpc_loc_close_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_args (XDR *xdrs, rpc_loc_start_fix_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_args (XDR *xdrs, rpc_loc_stop_fix_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_args (XDR *xdrs, rpc_loc_ioctl_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->ioctl_type))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->ioctl_data, sizeof (rpc_loc_ioctl_data_u_type), (xdrproc_t) xdr_rpc_loc_ioctl_data_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_version_s_args (XDR *xdrs, rpc_loc_api_api_version_s_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_boolean (xdrs, &objp->len_not_null))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *xdrs, rpc_loc_api_rpc_glue_code_info_remote_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, &objp->toolvers))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->features))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->proghash))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->cbproghash))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_rets (XDR *xdrs, rpc_loc_open_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_open_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_rets (XDR *xdrs, rpc_loc_close_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_close_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_rets (XDR *xdrs, rpc_loc_start_fix_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_start_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_rets (XDR *xdrs, rpc_loc_stop_fix_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_stop_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_rets (XDR *xdrs, rpc_loc_ioctl_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_ioctl_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_versions_rets (XDR *xdrs, rpc_loc_api_api_versions_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_api_api_versions_return_type (xdrs, &objp->loc_api_api_versions_result))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->len, sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}

29
loc_api/libloc_api-rpc/gen-3200/Makefile.xdr
View file

@ -1,29 +0,0 @@
CLIENTS:= loc_api
SERVERS:= loc_api_cb
COMMON:= loc_api_common
RPC_INC:= inc-$(AMSS_VERSION)
all: $(CLIENTS) $(SERVERS) $(COMMON) fixup
$(CLIENTS) $(SERVERS) $(COMMON):: xdr = $(@:=.xdr)
$(CLIENTS) $(SERVERS) $(COMMON)::
rpcgen -h -M $(xdr) -o ../$(RPC_INC)/$(addsuffix .h, $@)
rpcgen -c -M $(xdr) -o $(addsuffix _xdr.c, $@)
$(CLIENTS)::
rpcgen -l -M $(xdr) -o $(addsuffix _clnt.c, $@)
$(SERVERS)::
rpcgen -m -M $(xdr) -o $(addsuffix _svc.c, $@)
fixup:
mv ../$(RPC_INC)/loc_api_common.h ../$(RPC_INC)/loc_api_common.h.bak
sed ../$(RPC_INC)/loc_api_common.h.bak -e "/#include <rpc/a#include \"loc_api_fixup.h\"" > ../$(RPC_INC)/loc_api_common.h
rm -f ../$(RPC_INC)/loc_api_common.h.bak
clean:
rm -f $(addsuffix _clnt.c, $(CLIENTS))
rm -f $(addsuffix _svc.c, $(SERVERS))
rm -f $(addsuffix _xdr.c, $(CLIENTS) $(SERVERS) $(COMMON))
rm -f $(addprefix ../$(RPC_INC)/, $(addsuffix .h, $(CLIENTS) $(SERVERS) $(COMMON)))

164
loc_api/libloc_api-rpc/gen-3200/loc_api.xdr
View file

@ -1,164 +0,0 @@
/* LOC_API TOOL VERSION: 3.28 */
/*=============================================================================
L O C _ A P I . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
the loc_api API.
---------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/htorpc.pl#9
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Start.pm#4
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Output.pm#26
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Parser.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Metacomments.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/SymbolTable.pm#4
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
typedef rpc_uint32 rpc_loc_api_api_versions_return_type<>;
/*
* Declare an rpc_uint32 type for each callback type in the API
*/
typedef rpc_uint32 rpc_loc_event_cb_f_type;
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
/*
* These are struct declarations for the function results
*/
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers; /* Tool version */
rpc_uint32 features; /* Features turned on in the code.
* 0x00000001 ONCRPC Server Cleanup Support
*/
rpc_uint32 proghash; /* Unique hash value for the API XDR definition */
rpc_uint32 cbproghash; /* Unique hash value for the Callbacks' XDR definition */
};
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
/*
* XDR definition of the LOC_API program ( vers. 0x00010001 )
*/
program LOC_APIPROG {
version LOC_APIVERS_0001 {
void
rpc_loc_api_null( void ) = 0;
rpc_loc_api_rpc_glue_code_info_remote_rets
rpc_loc_api_rpc_glue_code_info_remote( void ) = 1;
rpc_loc_open_rets
rpc_loc_open( rpc_loc_open_args ) = 2;
rpc_loc_close_rets
rpc_loc_close( rpc_loc_close_args ) = 3;
rpc_loc_start_fix_rets
rpc_loc_start_fix( rpc_loc_start_fix_args ) = 4;
rpc_loc_stop_fix_rets
rpc_loc_stop_fix( rpc_loc_stop_fix_args ) = 5;
rpc_loc_ioctl_rets
rpc_loc_ioctl( rpc_loc_ioctl_args ) = 6;
rpc_loc_api_api_versions_rets
rpc_loc_api_api_versions( void ) = 0xFFFFFFFF;
} = 0x00010001;
} = 0x3000008c;
const LOC_APIVERS = 0x00010001;

90
loc_api/libloc_api-rpc/gen-3200/loc_api_cb.xdr
View file

@ -1,90 +0,0 @@
/* LOC_API TOOL VERSION: 3.28 */
/*=============================================================================
L O C _ A P I _ C B . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
an api that represents the grouping of the different callback functions the
loc_api API supports.
---------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/htorpc.pl#9
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Start.pm#4
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Output.pm#26
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Parser.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Metacomments.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/SymbolTable.pm#4
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
/*
* These are struct declarations for the function arguments
*/
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
/*
* These are struct declaratios for the function results
*/
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
/*
* XDR definition of the LOC_API callback program ( vers. 0x00010001 )
*/
program LOC_APICBPROG {
version LOC_APICBVERS_0001 {
rpc_loc_event_cb_f_type_rets
rpc_loc_event_cb_f_type( rpc_loc_event_cb_f_type_args ) = 1;
} = 0x00010001;
} = 0x3100008c;
const LOC_APICBVERS = 0x00010001;

64
loc_api/libloc_api-rpc/gen-3200/loc_api_cb_svc.c
View file

@ -1,64 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_cb.h"
#include <stdio.h>
#include <stdlib.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#ifndef SIG_PF
#define SIG_PF void(*)(int)
#endif
void
loc_apicbprog_0x00010001(struct svc_req *rqstp, register SVCXPRT *transp)
{
union {
rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_0x00010001_arg;
} argument;
union {
rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_0x00010001_res;
} result;
bool_t retval;
xdrproc_t _xdr_argument, _xdr_result;
bool_t (*local)(char *, void *, struct svc_req *);
switch (rqstp->rq_proc) {
case NULLPROC:
(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
return;
case rpc_loc_event_cb_f_type:
_xdr_argument = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_args;
_xdr_result = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_rets;
local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_event_cb_f_type_0x00010001_svc;
break;
default:
svcerr_noproc (transp);
return;
}
memset ((char *)&argument, 0, sizeof (argument));
if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
svcerr_decode (transp);
return;
}
retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
svcerr_systemerr (transp);
}
if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
fprintf (stderr, "%s", "unable to free arguments");
exit (1);
}
if (!loc_apicbprog_0x00010001_freeresult (transp, _xdr_result, (caddr_t) &result))
fprintf (stderr, "%s", "unable to free results");
return;
}

32
loc_api/libloc_api-rpc/gen-3200/loc_api_cb_xdr.c
View file

@ -1,32 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api_cb.h"
bool_t
xdr_rpc_loc_event_cb_f_type_args (XDR *xdrs, rpc_loc_event_cb_f_type_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, &objp->cb_id))
return FALSE;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_handle))
return FALSE;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->loc_event))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->loc_event_payload, sizeof (rpc_loc_event_payload_u_type), (xdrproc_t) xdr_rpc_loc_event_payload_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type_rets (XDR *xdrs, rpc_loc_event_cb_f_type_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_event_cb_f_type_result))
return FALSE;
return TRUE;
}

82
loc_api/libloc_api-rpc/gen-3200/loc_api_clnt.c
View file

@ -1,82 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include <memory.h> /* for memset */
#include "loc_api.h"
/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };
enum clnt_stat
rpc_loc_api_null_0x00010001(void *argp, void *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_null,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_rpc_glue_code_info_remote_0x00010001(void *argp, rpc_loc_api_rpc_glue_code_info_remote_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_rpc_glue_code_info_remote,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_rpc_glue_code_info_remote_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_open_0x00010001(rpc_loc_open_args *argp, rpc_loc_open_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_open,
(xdrproc_t) xdr_rpc_loc_open_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_open_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_close_0x00010001(rpc_loc_close_args *argp, rpc_loc_close_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_close,
(xdrproc_t) xdr_rpc_loc_close_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_close_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_start_fix_0x00010001(rpc_loc_start_fix_args *argp, rpc_loc_start_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_start_fix,
(xdrproc_t) xdr_rpc_loc_start_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_start_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_stop_fix_0x00010001(rpc_loc_stop_fix_args *argp, rpc_loc_stop_fix_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_stop_fix,
(xdrproc_t) xdr_rpc_loc_stop_fix_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_stop_fix_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_ioctl_0x00010001(rpc_loc_ioctl_args *argp, rpc_loc_ioctl_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_ioctl,
(xdrproc_t) xdr_rpc_loc_ioctl_args, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_ioctl_rets, (caddr_t) clnt_res,
TIMEOUT));
}
enum clnt_stat
rpc_loc_api_api_versions_0x00010001(void *argp, rpc_loc_api_api_versions_rets *clnt_res, CLIENT *clnt)
{
return (clnt_call(clnt, rpc_loc_api_api_versions,
(xdrproc_t) xdr_void, (caddr_t) argp,
(xdrproc_t) xdr_rpc_loc_api_api_versions_rets, (caddr_t) clnt_res,
TIMEOUT));
}

803
loc_api/libloc_api-rpc/gen-3200/loc_api_common.xdr
View file

@ -1,803 +0,0 @@
/* LOC_API TOOL VERSION: 3.28 */
/*=============================================================================
L O C _ A P I _ C O M M O N . X D R
GENERAL DESCRIPTION
This is an AUTO GENERATED file that provides an xdr compatible definition of
an api that represents the grouping of the different callback functions the
loc_api API supports.
---------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
---------------------------------------------------------------------------
=============================================================================*/
/*=============================================================================
Edit History
AUTO GENERATED
Generated by following versions of Htorpc modules:
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/htorpc.pl#9
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Start.pm#4
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Htoxdr.pm#1
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/XDR.pm#7
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Output.pm#26
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Parser.pm#3
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/Metacomments.pm#2
Id: //source/qcom/qct/core/mproc/tools/rel/03.01/htorpc/lib/Htorpc/SymbolTable.pm#4
=============================================================================*/
/*=============================================================================
$Header$
=============================================================================*/
const RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST = 0x00000010;
const RPC_LOC_EVENT_IOCTL_REPORT = 0x00000080;
const RPC_LOC_EVENT_LOCATION_SERVER_REQUEST = 0x00000040;
const RPC_LOC_EVENT_RESERVED = 0x8000000000000000;
const RPC_LOC_EVENT_PARSED_POSITION_REPORT = 0x00000001;
const RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST = 0x00000020;
const RPC_LOC_EVENT_NMEA_POSITION_REPORT = 0x00000008;
const RPC_LOC_EVENT_SATELLITE_REPORT = 0x00000002;
const RPC_LOC_EVENT_STATUS_REPORT = 0x00000100;
const RPC_LOC_OPEN_VERSION = 0x00010001;
const RPC_LOC_CLOSE_VERSION = 0x00010001;
const RPC_LOC_START_FIX_VERSION = 0x00010001;
const RPC_LOC_STOP_FIX_VERSION = 0x00010001;
const RPC_LOC_IOCTL_VERSION = 0x00010001;
const RPC_LOC_EVENT_CB_F_TYPE_VERSION = 0x00010001;
const RPC_LOC_APIAPI_VERSION_IS_HASHKEY = 0;
const RPC_LOC_API_API_MAJOR_NUM = 0x0001;
typedef bool rpc_boolean;
typedef unsigned long rpc_uint32;
typedef unsigned short rpc_uint16;
typedef unsigned char rpc_uint8;
typedef long rpc_int32;
typedef unsigned char rpc_byte;
typedef unsigned hyper rpc_uint64;
typedef rpc_int32 rpc_loc_client_handle_type;
typedef rpc_uint64 rpc_loc_event_mask_type;
typedef rpc_uint64 rpc_loc_position_valid_mask_type;
typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
enum rpc_loc_session_status_e_type {
RPC_LOC_SESS_STATUS_SUCCESS = 0,
RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
RPC_LOC_SESS_STATUS_TIMEOUT = 3,
RPC_LOC_SESS_STATUS_USER_END = 4,
RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
RPC_LOC_SESS_STATUS_MAX = 268435456
};
struct rpc_loc_calendar_time_s_type {
rpc_uint16 year;
unsigned char month;
unsigned char day_of_week;
unsigned char day;
unsigned char hour;
unsigned char minute;
unsigned char second;
rpc_uint16 millisecond;
};
struct rpc_loc_parsed_position_s_type {
rpc_loc_position_valid_mask_type valid_mask;
rpc_loc_session_status_e_type session_status;
rpc_loc_calendar_time_s_type timestamp_calendar;
rpc_uint64 timestamp_utc;
rpc_uint8 leap_seconds;
float time_unc;
double latitude;
double longitude;
float altitude_wrt_ellipsoid;
float altitude_wrt_mean_sea_level;
float speed_horizontal;
float speed_vertical;
float heading;
float hor_unc_circular;
float hor_unc_ellipse_semi_major;
float hor_unc_ellipse_semi_minor;
float hor_unc_ellipse_orient_azimuth;
float vert_unc;
float speed_unc;
float heading_unc;
unsigned char confidence_horizontal;
unsigned char confidence_vertical;
float magnetic_deviation;
rpc_loc_pos_technology_mask_type technology_mask;
};
enum rpc_loc_sv_system_e_type {
RPC_LOC_SV_SYSTEM_GPS = 1,
RPC_LOC_SV_SYSTEM_GALILEO = 2,
RPC_LOC_SV_SYSTEM_SBAS = 3,
RPC_LOC_SV_SYSTEM_COMPASS = 4,
RPC_LOC_SV_SYSTEM_GLONASS = 5,
RPC_LOC_SV_SYSTEM_MAX = 268435456
};
enum rpc_loc_sv_status_e_type {
RPC_LOC_SV_STATUS_IDLE = 1,
RPC_LOC_SV_STATUS_SEARCH = 2,
RPC_LOC_SV_STATUS_TRACK = 3,
RPC_LOC_SV_STATUS_MAX = 268435456
};
typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
struct rpc_loc_sv_info_s_type {
rpc_loc_sv_info_valid_mask_type valid_mask;
rpc_loc_sv_system_e_type system;
rpc_uint8 prn;
rpc_uint8 health_status;
rpc_loc_sv_status_e_type process_status;
rpc_boolean has_eph;
rpc_boolean has_alm;
float elevation;
float azimuth;
float snr;
};
typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
struct rpc_loc_gnss_info_s_type {
rpc_loc_gnss_info_valid_mask_type valid_mask;
float position_dop;
float horizontal_dop;
float vertical_dop;
rpc_boolean altitude_assumed;
rpc_uint16 sv_count;
rpc_loc_sv_info_s_type sv_list<RPC_LOC_API_MAX_SV_COUNT>;
};
struct rpc_loc_nmea_report_s_type {
rpc_uint16 length;
opaque nmea_sentences<RPC_LOC_API_MAX_NMEA_STRING_LENGTH>;
};
enum rpc_loc_status_event_e_type {
RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
RPC_LOC_STATUS_EVENT_MAX = 268435456
};
enum rpc_loc_engine_state_e_type {
RPC_LOC_ENGINE_STATE_ON = 1,
RPC_LOC_ENGINE_STATE_OFF = 2,
RPC_LOC_ENGINE_STATE_MAX = 268435456
};
union rpc_loc_status_event_payload_u_type switch (rpc_loc_status_event_e_type disc) {
case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
rpc_loc_engine_state_e_type engine_state;
default:
void;
};
struct rpc_loc_status_event_s_type {
rpc_loc_status_event_e_type event;
rpc_loc_status_event_payload_u_type payload;
};
enum rpc_loc_server_addr_e_type {
RPC_LOC_SERVER_ADDR_IPV4 = 1,
RPC_LOC_SERVER_ADDR_URL = 2,
RPC_LOC_SERVER_ADDR_MAX = 268435456
};
struct rpc_loc_server_addr_ipv4_type {
rpc_uint32 addr;
rpc_uint16 port;
};
struct rpc_loc_server_addr_url_type {
rpc_uint16 length;
opaque addr<RPC_LOC_API_MAX_SERVER_ADDR_LENGTH>;
};
union rpc_loc_server_addr_u_type switch (rpc_loc_server_addr_e_type disc) {
case RPC_LOC_SERVER_ADDR_IPV4:
rpc_loc_server_addr_ipv4_type ipv4;
case RPC_LOC_SERVER_ADDR_URL:
rpc_loc_server_addr_url_type url;
default:
void;
};
struct rpc_loc_server_info_s_type {
rpc_loc_server_addr_e_type addr_type;
rpc_loc_server_addr_u_type addr_info;
};
enum rpc_loc_ni_notify_verify_e_type {
RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456
};
enum rpc_loc_ni_event_e_type {
RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
RPC_LOC_NI_EVENT_MAX = 268435456
};
enum rpc_loc_ni_datacoding_scheme_e_type {
RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
RPC_LOC_NI_PRESUPL_ISO8859 = 1,
RPC_LOC_NI_PRESUPL_UTF8 = 2,
RPC_LOC_NI_PRESUPL_UTF16 = 3,
RPC_LOC_NI_PRESUPL_UCS2 = 4,
RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
RPC_LOC_NI_PRESUPL_JIS = 7,
RPC_LOC_NI_PRESUPL_EUC = 8,
RPC_LOC_NI_PRESUPL_GB2312 = 9,
RPC_LOC_NI_PRESUPL_CNS11643 = 10,
RPC_LOC_NI_PRESUPL_KSC1001 = 11,
RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
RPC_LOC_NI_SS_GERMAN = 12,
RPC_LOC_NI_SS_ENGLISH = 13,
RPC_LOC_NI_SS_ITALIAN = 14,
RPC_LOC_NI_SS_FRENCH = 15,
RPC_LOC_NI_SS_SPANISH = 16,
RPC_LOC_NI_SS_DUTCH = 17,
RPC_LOC_NI_SS_SWEDISH = 18,
RPC_LOC_NI_SS_DANISH = 19,
RPC_LOC_NI_SS_PORTUGUESE = 20,
RPC_LOC_NI_SS_FINNISH = 21,
RPC_LOC_NI_SS_NORWEGIAN = 22,
RPC_LOC_NI_SS_GREEK = 23,
RPC_LOC_NI_SS_TURKISH = 24,
RPC_LOC_NI_SS_HUNGARIAN = 25,
RPC_LOC_NI_SS_POLISH = 26,
RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
RPC_LOC_NI_SUPL_UTF8 = 28,
RPC_LOC_NI_SUPL_UCS2 = 29,
RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647
};
enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
RPC_LOC_NI_VX_OCTET = 0,
RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
RPC_LOC_NI_VX_ASCII = 2,
RPC_LOC_NI_VX_IA5 = 3,
RPC_LOC_NI_VX_UNICODE = 4,
RPC_LOC_NI_VX_SHIFT_JIS = 5,
RPC_LOC_NI_VX_KOREAN = 6,
RPC_LOC_NI_VX_LATIN_HEBREW = 7,
RPC_LOC_NI_VX_LATIN = 8,
RPC_LOC_NI_VX_GSM = 9,
RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456
};
enum rpc_loc_ni_vx_pos_mode_e_type {
RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
RPC_LOC_VX_MS_BASED_ONLY = 2,
RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
RPC_LOC_VX_POS_MODE_MAX = 268435456
};
struct rpc_loc_ni_vx_requester_id_s_type {
unsigned char requester_id_length;
opaque requester_id[200];
};
struct rpc_loc_ni_vx_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
unsigned char pos_qos_incl;
unsigned char pos_qos;
rpc_uint32 num_fixes;
rpc_uint32 tbf;
rpc_loc_ni_vx_pos_mode_e_type pos_mode;
rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
rpc_loc_ni_vx_requester_id_s_type requester_id;
rpc_uint16 user_resp_timer_val;
};
enum rpc_loc_ni_supl_pos_method_e_type {
RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
RPC_LOC_NI_POSMETHOD_AFLT = 6,
RPC_LOC_NI_POSMETHOD_ECID = 7,
RPC_LOC_NI_POSMETHOD_EOTD = 8,
RPC_LOC_NI_POSMETHOD_OTDOA = 9,
RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
RPC_LOC_NI_POSMETHOD_MAX = 268435456
};
struct rpc_loc_ni_supl_slp_session_id_s_type {
unsigned char presence;
opaque session_id[4];
rpc_loc_server_info_s_type slp_address;
};
struct rpc_loc_ni_requestor_id_s_type {
unsigned char data_coding_scheme;
opaque requestor_id_string<RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH>;
unsigned char string_len;
};
struct rpc_loc_ni_supl_client_name_s_type {
unsigned char data_coding_scheme;
opaque client_name_string<RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH>;
unsigned char string_len;
};
struct rpc_loc_ni_supl_qop_s_type {
unsigned char bit_mask;
unsigned char horacc;
unsigned char veracc;
unsigned char maxLocAge;
unsigned char delay;
};
struct rpc_loc_ni_supl_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
rpc_uint16 flags;
rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
opaque supl_hash[8];
rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
rpc_loc_ni_supl_pos_method_e_type pos_method;
rpc_loc_ni_requestor_id_s_type requestor_id;
rpc_loc_ni_supl_client_name_s_type client_name;
rpc_loc_ni_supl_qop_s_type supl_qop;
rpc_uint16 user_response_timer;
};
struct rpc_loc_ni_ext_client_address_s_type {
unsigned char ext_client_address_len;
opaque ext_client_address<RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS>;
};
enum rpc_loc_ni_location_type_e_type {
RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456
};
struct rpc_loc_ni_deferred_location_s_type {
unsigned char unused_bits;
unsigned char ms_available;
};
struct rpc_loc_ni_codeword_string_s_type {
unsigned char data_coding_scheme;
opaque lcs_codeword_string<RPC_LOC_NI_CODEWORD_LENGTH>;
unsigned char string_len;
};
struct rpc_loc_ni_service_type_id_s_type {
unsigned char lcs_service_type_id;
};
struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
rpc_loc_ni_notify_verify_e_type notification_priv_type;
unsigned char invoke_id;
rpc_uint16 flags;
unsigned char notification_length;
opaque notification_text<RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH>;
rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
rpc_loc_ni_location_type_e_type location_type;
rpc_loc_ni_deferred_location_s_type deferred_location;
rpc_loc_ni_requestor_id_s_type requestor_id;
rpc_loc_ni_codeword_string_s_type codeword_string;
rpc_loc_ni_service_type_id_s_type service_type_id;
rpc_uint16 user_response_timer;
};
union rpc_loc_ni_event_payload_u_type switch (rpc_loc_ni_event_e_type disc) {
case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
default:
void;
};
struct rpc_loc_ni_event_s_type {
rpc_loc_ni_event_e_type event;
rpc_loc_ni_event_payload_u_type payload;
};
enum rpc_loc_assist_data_request_e_type {
RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
RPC_LOC_ASSIST_DATA_MAX = 268435456
};
typedef string rpc_struct_loc_time_download_source_s_type_servers_ptr<RPC_LOC_API_MAX_SERVER_ADDR_LENGTH>;
typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3];
struct rpc_loc_time_download_source_s_type {
rpc_uint32 delay_threshold;
rpc_struct_loc_time_download_source_s_type_servers servers;
};
typedef string rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr<RPC_LOC_API_MAX_SERVER_ADDR_LENGTH>;
typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3];
struct rpc_loc_predicted_orbits_data_source_s_type {
rpc_uint32 max_file_size;
rpc_uint32 max_part_size;
rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
};
union rpc_loc_assist_data_request_payload_u_type switch (rpc_loc_assist_data_request_e_type disc) {
case RPC_LOC_ASSIST_DATA_TIME_REQ:
rpc_loc_time_download_source_s_type time_download;
case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
rpc_loc_predicted_orbits_data_source_s_type data_download;
default:
void;
};
struct rpc_loc_assist_data_request_s_type {
rpc_loc_assist_data_request_e_type event;
rpc_loc_assist_data_request_payload_u_type payload;
};
typedef rpc_uint32 rpc_loc_server_connection_handle;
enum rpc_loc_server_protocol_e_type {
RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
RPC_LOC_SERVER_PROTOCOL_MAX = 16777216
};
enum rpc_loc_server_request_e_type {
RPC_LOC_SERVER_REQUEST_OPEN = 1,
RPC_LOC_SERVER_REQUEST_CLOSE = 2,
RPC_LOC_SERVER_REQUEST_MAX = 268435456
};
struct rpc_loc_server_open_req_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_protocol_e_type protocol;
};
struct rpc_loc_server_close_req_s_type {
rpc_loc_server_connection_handle conn_handle;
};
union rpc_loc_server_request_u_type switch (rpc_loc_server_request_e_type disc) {
case RPC_LOC_SERVER_REQUEST_OPEN:
rpc_loc_server_open_req_s_type open_req;
case RPC_LOC_SERVER_REQUEST_CLOSE:
rpc_loc_server_close_req_s_type close_req;
default:
void;
};
struct rpc_loc_server_request_s_type {
rpc_loc_server_request_e_type event;
rpc_loc_server_request_u_type payload;
};
struct rpc_loc_reserved_payload_s_type {
rpc_uint16 data_size;
opaque data<>;
};
enum rpc_loc_ioctl_e_type {
RPC_LOC_IOCTL_GET_API_VERSION = 1,
RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
RPC_LOC_IOCTL_INJECT_POSITION = 407,
RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824
};
struct rpc_loc_api_version_s_type {
unsigned char major;
unsigned char minor;
};
enum rpc_loc_fix_recurrence_e_type {
RPC_LOC_PERIODIC_FIX = 1,
RPC_LOC_SINGLE_FIX = 2,
RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456
};
enum rpc_loc_operation_mode_e_type {
RPC_LOC_OPER_MODE_DEFAULT = 1,
RPC_LOC_OPER_MODE_MSB = 2,
RPC_LOC_OPER_MODE_MSA = 3,
RPC_LOC_OPER_MODE_STANDALONE = 4,
RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
RPC_LOC_OPER_MODE_MAX = 268435456
};
enum rpc_loc_notify_e_type {
RPC_LOC_NOTIFY_ON_INTERVAL = 1,
RPC_LOC_NOTIFY_ON_DISTANCE = 2,
RPC_LOC_NOTIFY_ON_ANY = 3,
RPC_LOC_NOTIFY_ON_ALL = 4,
RPC_LOC_NOTIFY_TYPE_MAX = 268435456
};
struct rpc_loc_fix_criteria_s_type {
rpc_uint32 valid_mask;
rpc_loc_fix_recurrence_e_type recurrence_type;
rpc_loc_operation_mode_e_type preferred_operation_mode;
rpc_uint32 preferred_accuracy;
rpc_uint32 preferred_response_time;
rpc_boolean intermediate_pos_report_enabled;
rpc_loc_notify_e_type notify_type;
rpc_uint32 min_interval;
float min_distance;
rpc_uint32 min_dist_sample_interval;
};
enum rpc_loc_ni_user_resp_e_type {
RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456
};
struct rpc_loc_user_verify_s_type {
rpc_loc_ni_user_resp_e_type user_resp;
rpc_loc_ni_event_s_type ni_event_pass_back;
};
enum rpc_loc_predicted_orbits_data_format_e_type {
RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456
};
struct rpc_loc_predicted_orbits_data_s_type {
rpc_loc_predicted_orbits_data_format_e_type format_type;
rpc_uint32 total_size;
rpc_uint8 total_parts;
rpc_uint8 part;
rpc_uint16 part_len;
opaque data_ptr<>;
};
struct rpc_loc_predicted_orbits_data_validity_report_s_type {
rpc_uint64 start_time_utc;
rpc_uint16 valid_duration_hrs;
};
struct rpc_loc_predicted_orbits_auto_download_config_s_type {
rpc_boolean enable;
unsigned char auto_check_every_hrs;
};
struct rpc_loc_assist_data_time_s_type {
rpc_uint64 time_utc;
rpc_uint32 uncertainty;
};
typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
struct rpc_loc_assist_data_pos_s_type {
rpc_loc_assist_pos_valid_mask_type valid_mask;
rpc_uint64 timestamp_utc;
double latitude;
double longitude;
float altitude_wrt_ellipsoid;
float altitude_wrt_mean_sea_level;
float hor_unc_circular;
float vert_unc;
unsigned char confidence_horizontal;
unsigned char confidence_vertical;
};
enum rpc_loc_server_open_status_e_type {
RPC_LOC_SERVER_OPEN_SUCCESS = 1,
RPC_LOC_SERVER_OPEN_FAIL = 2,
RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456
};
struct rpc_loc_server_open_status_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_open_status_e_type open_status;
string apn_name<>;
};
enum rpc_loc_server_close_status_e_type {
RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
RPC_LOC_SERVER_CLOSE_FAIL = 2,
RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456
};
struct rpc_loc_server_close_status_s_type {
rpc_loc_server_connection_handle conn_handle;
rpc_loc_server_close_status_e_type close_status;
};
enum rpc_loc_lock_e_type {
RPC_LOC_LOCK_NONE = 1,
RPC_LOC_LOCK_MI = 2,
RPC_LOC_LOCK_MT = 3,
RPC_LOC_LOCK_ALL = 4,
RPC_LOC_LOCK_MAX = 268435456
};
typedef rpc_uint32 rpc_loc_nmea_sentence_type;
typedef rpc_uint32 rpc_loc_assist_data_type;
struct rpc_loc_assist_data_delete_s_type {
rpc_loc_assist_data_type type;
rpc_uint32 reserved[8];
};
union rpc_loc_ioctl_data_u_type switch (rpc_loc_ioctl_e_type disc) {
case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
rpc_loc_fix_criteria_s_type fix_criteria;
case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
rpc_loc_user_verify_s_type user_verify_resp;
case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
case RPC_LOC_IOCTL_INJECT_UTC_TIME:
rpc_loc_assist_data_time_s_type assistance_data_time;
case RPC_LOC_IOCTL_INJECT_POSITION:
rpc_loc_assist_data_pos_s_type assistance_data_position;
case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
rpc_loc_server_open_status_s_type conn_open_status;
case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
rpc_loc_server_close_status_s_type conn_close_status;
case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
rpc_loc_lock_e_type engine_lock;
case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
rpc_boolean sbas_mode;
case RPC_LOC_IOCTL_SET_NMEA_TYPES:
rpc_loc_nmea_sentence_type nmea_types;
case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
rpc_boolean on_demand_lpm;
case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
rpc_loc_server_info_s_type server_addr;
case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
rpc_loc_assist_data_delete_s_type assist_data_delete;
default:
void;
};
union rpc_loc_ioctl_callback_data_u_type switch (rpc_loc_ioctl_e_type disc) {
case RPC_LOC_IOCTL_GET_API_VERSION:
rpc_loc_api_version_s_type api_version;
case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
rpc_loc_fix_criteria_s_type fix_criteria;
case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
rpc_loc_lock_e_type engine_lock;
case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
rpc_boolean sbas_mode;
case RPC_LOC_IOCTL_GET_NMEA_TYPES:
rpc_loc_nmea_sentence_type nmea_types;
case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
rpc_boolean on_demand_lpm;
case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
rpc_loc_server_info_s_type server_addr;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
default:
void;
};
struct rpc_loc_ioctl_callback_s_type {
rpc_loc_ioctl_e_type type;
rpc_int32 status;
rpc_loc_ioctl_callback_data_u_type data;
};
union rpc_loc_event_payload_u_type switch (unsigned hyper disc) {
case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
rpc_loc_parsed_position_s_type parsed_location_report;
case RPC_LOC_EVENT_SATELLITE_REPORT:
rpc_loc_gnss_info_s_type gnss_report;
case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
rpc_loc_nmea_report_s_type nmea_report;
case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
rpc_loc_ni_event_s_type ni_request;
case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
rpc_loc_assist_data_request_s_type assist_data_request;
case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
rpc_loc_server_request_s_type loc_server_request;
case RPC_LOC_EVENT_IOCTL_REPORT:
rpc_loc_ioctl_callback_s_type ioctl_report;
case RPC_LOC_EVENT_STATUS_REPORT:
rpc_loc_status_event_s_type status_report;
case RPC_LOC_EVENT_RESERVED:
rpc_loc_reserved_payload_s_type reserved;
default:
void;
};
const RPC_LOC_API_NULL_VERSION = 0x00010001;
const RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION = 0x00010001;

1441
loc_api/libloc_api-rpc/gen-3200/loc_api_common_xdr.c
View file

File diff suppressed because it is too large Load diff

48
loc_api/libloc_api-rpc/gen-3200/loc_api_fixup.c
View file

@ -1,48 +0,0 @@
/*=============================================================================
L O C _ A P I _ F I X U P . C
GENERAL DESCRIPTION
This file adds API constants that are not automatically transmitted to
the RPC stubs, and it also fixes other RPC-related problems.
---------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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 <rpc/rpc.h>
#include "loc_api_fixup.h"
#ifdef ADD_XDR_FLOAT
int
xdr_float(xdrp, fp)
XDR *xdrp;
float *fp;
{
return xdr_long(xdrp, (long*)fp);
}
int
xdr_double(xdrp, dp)
XDR *xdrp;
double *dp;
{
return xdr_long(xdrp, (long*)dp + 1)
&& xdr_long(xdrp, (long*)dp);
}
#endif /* ADD_XDR_FLOAT */

339
loc_api/libloc_api-rpc/gen-3200/loc_api_rpc_glue.c
View file

@ -1,339 +0,0 @@
/******************************************************************************
@file loc_api_rpc_glue.c
@brief Android Loc API glue code using rpcgen.
DESCRIPTION
Loc API glue code for Android
-----------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
-----------------------------------------------------------------------------
******************************************************************************/
/*=====================================================================
EDIT HISTORY FOR MODULE
This section contains comments describing changes made to the module.
Notice that changes are listed in reverse chronological order.
when who what, where, why
-------- --- -------------------------------------------------------
03/05/2009 dx Initial version
======================================================================*/
/*=====================================================================
INCLUDE FILES FOR MODULE
======================================================================*/
//#define LOG_NDDEBUG 0
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <rpc/rpc.h>
#include <rpc/clnt.h>
/* Include RPC headers */
#include "loc_api_rpc_glue.h"
/* Callback init */
#include "loc_apicb_appinit.h"
/* Logging */
#define LOG_TAG "lib_api_rpc_glue"
#include <utils/Log.h>
/* Comment this out to enable logging */
#undef LOGD
#define LOGD(...) {}
/*=====================================================================
External declarations
======================================================================*/
CLIENT* loc_api_clnt = NULL;
/* Callback ID and pointer */
#define LOC_API_CB_ID 1
loc_event_cb_f_type *loc_api_saved_cb = NULL; /* the only callback of Loc API client */
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_FUNC_VERSION(a,b) RPC_FUNC_VERSION_BASE(a,b)
#define LOC_GLUE_CHECK_INIT(ret_type) \
if (loc_api_clnt == NULL) { return (ret_type) RPC_LOC_API_RPC_FAILURE; }
#define LOC_GLUE_CHECK_RESULT(stat, ret_type) \
if (stat != RPC_SUCCESS) { return (ret_type) RPC_LOC_API_RPC_FAILURE; }
/* Callback functions */
/* Returns 1 if successful */
bool_t rpc_loc_event_cb_f_type_0x00010001_svc(
rpc_loc_event_cb_f_type_args *argp,
rpc_loc_event_cb_f_type_rets *ret,
struct svc_req *req)
{
/* Callback not registered, or unexpected ID (shouldn't happen) */
if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID)
{
LOGD("Warning: No callback handler.\n");
ret->loc_event_cb_f_type_result = 0;
return 1; /* simply return */
}
LOGD("proc: %x prog: %x vers: %x\n",
(int) req->rq_proc,
(int) req->rq_prog,
(int) req->rq_vers);
LOGD("Callback received: %x (handle=%d ret_ptr=%d)\n",
(int) argp->loc_event,
(int) argp->loc_handle,
(int) ret);
/* Forward callback to real callback procedure */
rpc_loc_client_handle_type loc_handle = argp->loc_handle;
rpc_loc_event_mask_type loc_event = argp->loc_event;
const rpc_loc_event_payload_u_type* loc_event_payload =
(const rpc_loc_event_payload_u_type*) argp->loc_event_payload;
int32 rc = loc_api_saved_cb(loc_handle, loc_event, loc_event_payload);
ret->loc_event_cb_f_type_result = rc;
return 1; /* ok */
}
int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
{
xdr_free (xdr_result, result);
/*
* Insert additional freeing code here, if needed
*/
// LOGD("***** loc_apicbprog_freeresult\n");
return 1;
}
int loc_apicbprog_0x00010001_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
{
return loc_apicbprog_freeresult (transp, xdr_result, result);
}
/*===========================================================================
FUNCTION loc_api_glue_init
DESCRIPTION
Initiates the RPC client
RETURN VALUE
1 for success
0 for failure
===========================================================================*/
int loc_api_glue_init(void)
{
if (loc_api_clnt == NULL)
{
/* Print msg */
LOGD("Trying to create RPC client...\n");
loc_api_clnt = clnt_create(NULL, LOC_APIPROG, /*LOC_APIVERS*/ 0x00010000, NULL);
LOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
if (loc_api_clnt == NULL)
{
fprintf(stderr, "Error: cannot create RPC client.\n");
return 0;
}
/* Init RPC callbacks */
int rc = loc_apicb_app_init();
if (rc >= 0)
{
LOGD("Loc API callback initialized.\n");
} else {
fprintf(stderr, "Loc API callback initialization failed.\n");
return 0;
}
}
return 1;
}
rpc_loc_client_handle_type loc_open (
rpc_loc_event_mask_type event_reg_mask,
loc_event_cb_f_type *event_callback
)
{
LOC_GLUE_CHECK_INIT(rpc_loc_client_handle_type);
rpc_loc_open_args args;
args.event_reg_mask = event_reg_mask;
args.event_callback = LOC_API_CB_ID;
loc_api_saved_cb = event_callback;
rpc_loc_open_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_open_, LOC_APIVERS)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (rpc_loc_client_handle_type) rets.loc_open_result;
}
int32 loc_close(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_close_args args;
args.handle = handle;
rpc_loc_close_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_close_, LOC_APIVERS)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_close_result;
}
int32 loc_start_fix(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_start_fix_args args;
args.handle = handle;
rpc_loc_start_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_start_fix_, LOC_APIVERS)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_start_fix_result;
}
int32 loc_stop_fix(rpc_loc_client_handle_type handle)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_stop_fix_args args;
args.handle = handle;
rpc_loc_stop_fix_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_stop_fix_, LOC_APIVERS)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_stop_fix_result;
}
int32 loc_ioctl(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data
)
{
LOC_GLUE_CHECK_INIT(int32);
rpc_loc_ioctl_args args;
args.handle = handle;
args.ioctl_data = ioctl_data;
args.ioctl_type = ioctl_type;
if (ioctl_data != NULL)
{
/* Assign ioctl union discriminator */
ioctl_data->disc = ioctl_type;
/* In case the user hasn't filled in other disc fields,
automatically fill them in here */
switch (ioctl_type)
{
case RPC_LOC_IOCTL_GET_API_VERSION:
case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
case RPC_LOC_IOCTL_INJECT_UTC_TIME:
case RPC_LOC_IOCTL_INJECT_RTC_VALUE:
case RPC_LOC_IOCTL_INJECT_POSITION:
case RPC_LOC_IOCTL_QUERY_ENGINE_STATE:
case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
case RPC_LOC_IOCTL_SET_NMEA_TYPES:
case RPC_LOC_IOCTL_GET_NMEA_TYPES:
break;
case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_info.disc =
args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_type;
break;
case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
break;
case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
default:
break;
} /* switch */
} /* ioctl_data != NULL */
rpc_loc_ioctl_rets rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_ioctl_, LOC_APIVERS)(&args, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets.loc_ioctl_result;
}
/* Returns 0 if error */
int32 loc_api_null(void)
{
LOC_GLUE_CHECK_INIT(int32);
int32 rets;
enum clnt_stat stat = RPC_SUCCESS;
stat = RPC_FUNC_VERSION(rpc_loc_api_null_, LOC_APIVERS)(NULL, &rets, loc_api_clnt);
LOC_GLUE_CHECK_RESULT(stat, int32);
return (int32) rets;
}

171
loc_api/libloc_api-rpc/gen-3200/loc_api_xdr.c
View file

@ -1,171 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#include "loc_api.h"
bool_t
xdr_rpc_loc_api_api_versions_return_type (XDR *xdrs, rpc_loc_api_api_versions_return_type *objp)
{
register int32_t *buf;
if (!xdr_array (xdrs, (char **)&objp->rpc_loc_api_api_versions_return_type_val, (u_int *) &objp->rpc_loc_api_api_versions_return_type_len, ~0,
sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_event_cb_f_type (XDR *xdrs, rpc_loc_event_cb_f_type *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, objp))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_args (XDR *xdrs, rpc_loc_open_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->event_reg_mask))
return FALSE;
if (!xdr_rpc_loc_event_cb_f_type (xdrs, &objp->event_callback))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_args (XDR *xdrs, rpc_loc_close_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_args (XDR *xdrs, rpc_loc_start_fix_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_args (XDR *xdrs, rpc_loc_stop_fix_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_args (XDR *xdrs, rpc_loc_ioctl_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
return FALSE;
if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->ioctl_type))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->ioctl_data, sizeof (rpc_loc_ioctl_data_u_type), (xdrproc_t) xdr_rpc_loc_ioctl_data_u_type))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_version_s_args (XDR *xdrs, rpc_loc_api_api_version_s_args *objp)
{
register int32_t *buf;
if (!xdr_rpc_boolean (xdrs, &objp->len_not_null))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *xdrs, rpc_loc_api_rpc_glue_code_info_remote_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_uint32 (xdrs, &objp->toolvers))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->features))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->proghash))
return FALSE;
if (!xdr_rpc_uint32 (xdrs, &objp->cbproghash))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_open_rets (XDR *xdrs, rpc_loc_open_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_open_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_close_rets (XDR *xdrs, rpc_loc_close_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_close_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_start_fix_rets (XDR *xdrs, rpc_loc_start_fix_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_start_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_stop_fix_rets (XDR *xdrs, rpc_loc_stop_fix_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_stop_fix_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_ioctl_rets (XDR *xdrs, rpc_loc_ioctl_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_int32 (xdrs, &objp->loc_ioctl_result))
return FALSE;
return TRUE;
}
bool_t
xdr_rpc_loc_api_api_versions_rets (XDR *xdrs, rpc_loc_api_api_versions_rets *objp)
{
register int32_t *buf;
if (!xdr_rpc_loc_api_api_versions_return_type (xdrs, &objp->loc_api_api_versions_result))
return FALSE;
if (!xdr_pointer (xdrs, (char **)&objp->len, sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
return FALSE;
return TRUE;
}

210
loc_api/libloc_api-rpc/inc-1240/loc_api.h
View file

@ -1,210 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_H_RPCGEN
#define _LOC_API_H_RPCGEN
#include <rpc/rpc.h>
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
u_int rpc_loc_api_api_versions_return_type_len;
rpc_uint32 *rpc_loc_api_api_versions_return_type_val;
} rpc_loc_api_api_versions_return_type;
typedef rpc_uint32 rpc_loc_event_cb_f_type;
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
typedef struct rpc_loc_open_args rpc_loc_open_args;
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_close_args rpc_loc_close_args;
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_start_fix_args rpc_loc_start_fix_args;
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_stop_fix_args rpc_loc_stop_fix_args;
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
typedef struct rpc_loc_ioctl_args rpc_loc_ioctl_args;
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
typedef struct rpc_loc_api_api_version_s_args rpc_loc_api_api_version_s_args;
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers;
rpc_uint32 features;
rpc_uint32 proghash;
rpc_uint32 cbproghash;
};
typedef struct rpc_loc_api_rpc_glue_code_info_remote_rets rpc_loc_api_rpc_glue_code_info_remote_rets;
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
typedef struct rpc_loc_open_rets rpc_loc_open_rets;
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
typedef struct rpc_loc_close_rets rpc_loc_close_rets;
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
typedef struct rpc_loc_start_fix_rets rpc_loc_start_fix_rets;
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
typedef struct rpc_loc_stop_fix_rets rpc_loc_stop_fix_rets;
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
typedef struct rpc_loc_ioctl_rets rpc_loc_ioctl_rets;
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
typedef struct rpc_loc_api_api_versions_rets rpc_loc_api_api_versions_rets;
#define LOC_APIVERS 0x00040002
#define LOC_APIPROG 0x3000008c
#define LOC_APIVERS_0001 0x00040001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00040001(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00040001_svc(void *, void *, struct svc_req *);
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00040001(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, CLIENT *);
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00040001_svc(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, struct svc_req *);
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00040001(rpc_loc_open_args *, rpc_loc_open_rets *, CLIENT *);
extern bool_t rpc_loc_open_0x00040001_svc(rpc_loc_open_args *, rpc_loc_open_rets *, struct svc_req *);
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00040001(rpc_loc_close_args *, rpc_loc_close_rets *, CLIENT *);
extern bool_t rpc_loc_close_0x00040001_svc(rpc_loc_close_args *, rpc_loc_close_rets *, struct svc_req *);
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00040001(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, CLIENT *);
extern bool_t rpc_loc_start_fix_0x00040001_svc(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, struct svc_req *);
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00040001(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, CLIENT *);
extern bool_t rpc_loc_stop_fix_0x00040001_svc(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, struct svc_req *);
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00040001(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, CLIENT *);
extern bool_t rpc_loc_ioctl_0x00040001_svc(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, struct svc_req *);
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00040001(void *, rpc_loc_api_api_versions_rets *, CLIENT *);
extern bool_t rpc_loc_api_api_versions_0x00040001_svc(void *, rpc_loc_api_api_versions_rets *, struct svc_req *);
extern int loc_apiprog_0x00040001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00040001();
extern bool_t rpc_loc_api_null_0x00040001_svc();
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00040001();
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00040001_svc();
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00040001();
extern bool_t rpc_loc_open_0x00040001_svc();
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00040001();
extern bool_t rpc_loc_close_0x00040001_svc();
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00040001();
extern bool_t rpc_loc_start_fix_0x00040001_svc();
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00040001();
extern bool_t rpc_loc_stop_fix_0x00040001_svc();
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00040001();
extern bool_t rpc_loc_ioctl_0x00040001_svc();
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00040001();
extern bool_t rpc_loc_api_api_versions_0x00040001_svc();
extern int loc_apiprog_0x00040001_freeresult ();
#endif /* K&R C */
#define LOC_APIVERS_0002 0x00040002
#if defined(__STDC__) || defined(__cplusplus)
extern enum clnt_stat rpc_loc_api_null_0x00040002(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00040002_svc(void *, void *, struct svc_req *);
extern int loc_apiprog_0x00040002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
extern enum clnt_stat rpc_loc_api_null_0x00040002();
extern bool_t rpc_loc_api_null_0x00040002_svc();
extern int loc_apiprog_0x00040002_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_api_api_versions_return_type (XDR *, rpc_loc_api_api_versions_return_type*);
extern bool_t xdr_rpc_loc_event_cb_f_type (XDR *, rpc_loc_event_cb_f_type*);
extern bool_t xdr_rpc_loc_open_args (XDR *, rpc_loc_open_args*);
extern bool_t xdr_rpc_loc_close_args (XDR *, rpc_loc_close_args*);
extern bool_t xdr_rpc_loc_start_fix_args (XDR *, rpc_loc_start_fix_args*);
extern bool_t xdr_rpc_loc_stop_fix_args (XDR *, rpc_loc_stop_fix_args*);
extern bool_t xdr_rpc_loc_ioctl_args (XDR *, rpc_loc_ioctl_args*);
extern bool_t xdr_rpc_loc_api_api_version_s_args (XDR *, rpc_loc_api_api_version_s_args*);
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *, rpc_loc_api_rpc_glue_code_info_remote_rets*);
extern bool_t xdr_rpc_loc_open_rets (XDR *, rpc_loc_open_rets*);
extern bool_t xdr_rpc_loc_close_rets (XDR *, rpc_loc_close_rets*);
extern bool_t xdr_rpc_loc_start_fix_rets (XDR *, rpc_loc_start_fix_rets*);
extern bool_t xdr_rpc_loc_stop_fix_rets (XDR *, rpc_loc_stop_fix_rets*);
extern bool_t xdr_rpc_loc_ioctl_rets (XDR *, rpc_loc_ioctl_rets*);
extern bool_t xdr_rpc_loc_api_api_versions_rets (XDR *, rpc_loc_api_api_versions_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_api_api_versions_return_type ();
extern bool_t xdr_rpc_loc_event_cb_f_type ();
extern bool_t xdr_rpc_loc_open_args ();
extern bool_t xdr_rpc_loc_close_args ();
extern bool_t xdr_rpc_loc_start_fix_args ();
extern bool_t xdr_rpc_loc_stop_fix_args ();
extern bool_t xdr_rpc_loc_ioctl_args ();
extern bool_t xdr_rpc_loc_api_api_version_s_args ();
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets ();
extern bool_t xdr_rpc_loc_open_rets ();
extern bool_t xdr_rpc_loc_close_rets ();
extern bool_t xdr_rpc_loc_start_fix_rets ();
extern bool_t xdr_rpc_loc_stop_fix_rets ();
extern bool_t xdr_rpc_loc_ioctl_rets ();
extern bool_t xdr_rpc_loc_api_api_versions_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_H_RPCGEN */

64
loc_api/libloc_api-rpc/inc-1240/loc_api_cb.h
View file

@ -1,64 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_CB_H_RPCGEN
#define _LOC_API_CB_H_RPCGEN
#include <rpc/rpc.h>
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
typedef struct rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_args;
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
typedef struct rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_rets;
#define LOC_APICBVERS 0x00040002
#define LOC_APICBPROG 0x3100008c
#define LOC_APICBVERS_0001 0x00040001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00040001(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, CLIENT *);
extern bool_t rpc_loc_event_cb_f_type_0x00040001_svc(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, struct svc_req *);
extern int loc_apicbprog_0x00040001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00040001();
extern bool_t rpc_loc_event_cb_f_type_0x00040001_svc();
extern int loc_apicbprog_0x00040001_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_event_cb_f_type_args (XDR *, rpc_loc_event_cb_f_type_args*);
extern bool_t xdr_rpc_loc_event_cb_f_type_rets (XDR *, rpc_loc_event_cb_f_type_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_event_cb_f_type_args ();
extern bool_t xdr_rpc_loc_event_cb_f_type_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_CB_H_RPCGEN */

1154
loc_api/libloc_api-rpc/inc-1240/loc_api_common.h
View file

File diff suppressed because it is too large Load diff

188
loc_api/libloc_api-rpc/inc-1240/loc_api_fixup.h
View file

@ -1,188 +0,0 @@
/******************************************************************************
@file: loc_api_fixup.h
@brief: Loc API Android RPC amendment header
DESCRIPTION
Loc API Android RPC amendment header
INITIALIZATION AND SEQUENCING REQUIREMENTS
-----------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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_API_FIXUP_H
#define LOC_API_FIXUP_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifndef NULLPROC
#define NULLPROC 0
#endif /* NULLPROC */
#ifdef ADD_XDR_FLOAT
extern bool_t xdr_float (XDR *__xdrs, float *__fp);
extern bool_t xdr_double (XDR *__xdrs, double *__dp);
#endif /* ADD_XDR_FLOAT */
#ifdef ADD_XDR_BOOL
extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
#endif /* ADD_XDR_BOOL */
#define RPC_LOC_API_MAJOR_VERSION_NUMBER 1
#define RPC_LOC_API_MINOR_VERSION_NUMBER 0
// Return value for loc_open in case of failure.
#define RPC_LOC_CLIENT_HANDLE_INVALID -1
// Return value of loc api calls for loc_close, loc_start_fix, loc_stop_fix and loc_ioctl
// These are also the status for the ioctl callback
#define RPC_LOC_API_SUCCESS 0
#define RPC_LOC_API_GENERAL_FAILURE 1
#define RPC_LOC_API_UNSUPPORTED 2
#define RPC_LOC_API_INVALID_HANDLE 4
#define RPC_LOC_API_INVALID_PARAMETER 5
#define RPC_LOC_API_ENGINE_BUSY 6
#define RPC_LOC_API_PHONE_OFFLINE 7
#define RPC_LOC_API_TIMEOUT 8
// Special return value for loc api calls in case of RCP failure
#define RPC_LOC_API_RPC_FAILURE (-1234)
#define RPC_LOC_API_MAX_SV_COUNT 80
#define RPC_LOC_API_MAX_NMEA_STRING_LENGTH 1200
// Maximum server address that will be used in location API
#define RPC_LOC_API_MAX_SERVER_ADDR_LENGTH 256
#define RPC_LOC_API_MAX_NUM_PREDICTED_ORBITS_SERVERS 3
#define RPC_LOC_API_MAX_NUM_NTP_SERVERS 3
#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 // Position report comes in loc_parsed_position_s_type
#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 // Satellite in view report
#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 // NMEA report at 1HZ rate
#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 // NMEA report at position report rate
#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 // NI notification/verification request
#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 // Assistance data, eg: time, predicted orbits request
#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 // Request for location server
#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 // Callback report for loc_ioctl
#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 // Misc status report: eg, engine state
#define RPC_LOC_POS_VALID_SESSION_STATUS 0x00000001
#define RPC_LOC_POS_VALID_TIMESTAMP_CALENDAR 0x00000002
#define RPC_LOC_POS_VALID_TIMESTAMP_UTC 0x00000004
#define RPC_LOC_POS_VALID_LEAP_SECONDS 0x00000008
#define RPC_LOC_POS_VALID_TIME_UNC 0x00000010
#define RPC_LOC_POS_VALID_LATITUDE 0x00000020
#define RPC_LOC_POS_VALID_LONGITUDE 0x00000040
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000080
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000100
#define RPC_LOC_POS_VALID_SPEED_HORIZONTAL 0x00000200
#define RPC_LOC_POS_VALID_SPEED_VERTICAL 0x00000400
#define RPC_LOC_POS_VALID_HEADING 0x00000800
#define RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR 0x00001000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MAJ 0x00002000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MIN 0x00004000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_ORIENT_AZIMUTH 0x00008000
#define RPC_LOC_POS_VALID_VERTICAL_UNC 0x00010000
#define RPC_LOC_POS_VALID_SPEED_UNC 0x00020000
#define RPC_LOC_POS_VALID_HEADING_UNC 0x00040000
#define RPC_LOC_POS_VALID_CONFIDENCE_HORIZONTAL 0x00080000
#define RPC_LOC_POS_VALID_CONFIDENCE_VERTICAL 0x00100000
#define RPC_LOC_POS_VALID_MAGNETIC_VARIATION 0x00200000
#define RPC_LOC_POS_VALID_TECHNOLOGY_MASK 0x00400000
#define RPC_LOC_POS_TECH_SATELLITE 0x00000001
#define RPC_LOC_POS_TECH_CELLID 0x00000002
#define RPC_LOC_POS_TECH_WIFI 0x00000004
#define RPC_LOC_SV_INFO_VALID_SYSTEM 0x00000001
#define RPC_LOC_SV_INFO_VALID_PRN 0x00000002
#define RPC_LOC_SV_INFO_VALID_HEALTH_STATUS 0x00000004
#define RPC_LOC_SV_INFO_VALID_PROCESS_STATUS 0x00000008
#define RPC_LOC_SV_INFO_VALID_HAS_EPH 0x00000010
#define RPC_LOC_SV_INFO_VALID_HAS_ALM 0x00000020
#define RPC_LOC_SV_INFO_VALID_ELEVATION 0x00000040
#define RPC_LOC_SV_INFO_VALID_AZIMUTH 0x00000080
#define RPC_LOC_SV_INFO_VALID_SNR 0x00000100
#define RPC_LOC_GNSS_INFO_VALID_POS_DOP 0x00000001
#define RPC_LOC_GNSS_INFO_VALID_HOR_DOP 0x00000002
#define RPC_LOC_GNSS_INFO_VALID_VERT_DOP 0x00000004
#define RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED 0x00000008
#define RPC_LOC_GNSS_INFO_VALID_SV_COUNT 0x00000010
#define RPC_LOC_GNSS_INFO_VALID_SV_LIST 0x00000020
#define RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH 200
#define RPC_LOC_NI_SUPL_HASH_LENGTH 8
#define RPC_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH 4
#define RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH 64
#define RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS 20
#define RPC_LOC_NI_CODEWORD_LENGTH 20
#define RPC_LOC_NI_SUPL_QOP_VALID 0x01
#define RPC_LOC_NI_SUPL_QOP_VERACC_VALID 0x02
#define RPC_LOC_NI_SUPL_QOP_MAXAGE_VALID 0x04
#define RPC_LOC_NI_SUPL_QOP_DELAY_VALID 0x08
#define RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE 0x00000001
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE 0x00000002
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY 0x00000004
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME 0x00000008
#define RPC_LOC_FIX_CRIT_VALID_INTERMEDIATE_POS_REPORT_ENABLED 0x00000010
#define RPC_LOC_FIX_CRIT_VALID_NOTIFY_TYPE 0x00000020
#define RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL 0x00000040
#define RPC_LOC_FIX_CRIT_VALID_MIN_DISTANCE 0x00000080
#define RPC_LOC_FIX_CRIT_VALID_MIN_DIST_SAMPLE_INTERVAL 0x00000100
#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_UTC 0x00000001
#define RPC_LOC_ASSIST_POS_VALID_LATITUDE 0x00000002
#define RPC_LOC_ASSIST_POS_VALID_LONGITUDE 0x00000004
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000008
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000010
#define RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR 0x00000020
#define RPC_LOC_ASSIST_POS_VALID_VERT_UNC 0x00000040
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL 0x00000080
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_VERTICAL 0x00000100
#define RPC_LOC_ASSIST_DATA_ALL 0xFFFFFFFF
#define RPC_LOC_NMEA_MASK_ALL 0xffff
#define RPC_LOC_NMEA_MASK_GGA 0x0001
#define RPC_LOC_NMEA_MASK_RMC 0x0002
#define RPC_LOC_NMEA_MASK_GSV 0x0004
#define RPC_LOC_NMEA_MASK_GSA 0x0008
#define RPC_LOC_NMEA_MASK_VTG 0x0010
/* flags for notification */
#define RPC_LOC_NI_CLIENT_NAME_PRESENT 0x0001
#define RPC_LOC_NI_CLIENT_EXTADDR_PRESENT 0x0002
#define RPC_LOC_NI_DEF_LOCATION_TYPE_PRESENT 0x0010
#define RPC_LOC_NI_REQUESTOR_ID_PRESENT 0x0020
#define RPC_LOC_NI_CODEWORD_PRESENT 0x0040
#define RPC_LOC_NI_SERVICE_TYPE_ID_PRESENT 0x0080
#define RPC_LOC_NI_ENCODING_TYPE_PRESENT 0x0100
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_FIXUP_H */

34
loc_api/libloc_api-rpc/inc-1240/loc_apicb_appinit.h
View file

@ -1,34 +0,0 @@
/* -------------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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_APICB_APPINIT_H
#define LOC_APICB_APPINIT_H
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialization function for callbacks */
extern int loc_apicb_app_init();
extern void loc_apicb_app_deinit();
#ifdef __cplusplus
}
#endif
#endif /* LOC_APICB_APPINIT_H */

198
loc_api/libloc_api-rpc/inc-3200/loc_api.h
View file

@ -1,198 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_H_RPCGEN
#define _LOC_API_H_RPCGEN
#include <rpc/rpc.h>
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
u_int rpc_loc_api_api_versions_return_type_len;
rpc_uint32 *rpc_loc_api_api_versions_return_type_val;
} rpc_loc_api_api_versions_return_type;
typedef rpc_uint32 rpc_loc_event_cb_f_type;
struct rpc_loc_open_args {
rpc_loc_event_mask_type event_reg_mask;
rpc_loc_event_cb_f_type event_callback;
};
typedef struct rpc_loc_open_args rpc_loc_open_args;
struct rpc_loc_close_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_close_args rpc_loc_close_args;
struct rpc_loc_start_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_start_fix_args rpc_loc_start_fix_args;
struct rpc_loc_stop_fix_args {
rpc_loc_client_handle_type handle;
};
typedef struct rpc_loc_stop_fix_args rpc_loc_stop_fix_args;
struct rpc_loc_ioctl_args {
rpc_loc_client_handle_type handle;
rpc_loc_ioctl_e_type ioctl_type;
rpc_loc_ioctl_data_u_type *ioctl_data;
};
typedef struct rpc_loc_ioctl_args rpc_loc_ioctl_args;
struct rpc_loc_api_api_version_s_args {
rpc_boolean len_not_null;
};
typedef struct rpc_loc_api_api_version_s_args rpc_loc_api_api_version_s_args;
struct rpc_loc_api_rpc_glue_code_info_remote_rets {
rpc_uint32 toolvers;
rpc_uint32 features;
rpc_uint32 proghash;
rpc_uint32 cbproghash;
};
typedef struct rpc_loc_api_rpc_glue_code_info_remote_rets rpc_loc_api_rpc_glue_code_info_remote_rets;
struct rpc_loc_open_rets {
rpc_loc_client_handle_type loc_open_result;
};
typedef struct rpc_loc_open_rets rpc_loc_open_rets;
struct rpc_loc_close_rets {
rpc_int32 loc_close_result;
};
typedef struct rpc_loc_close_rets rpc_loc_close_rets;
struct rpc_loc_start_fix_rets {
rpc_int32 loc_start_fix_result;
};
typedef struct rpc_loc_start_fix_rets rpc_loc_start_fix_rets;
struct rpc_loc_stop_fix_rets {
rpc_int32 loc_stop_fix_result;
};
typedef struct rpc_loc_stop_fix_rets rpc_loc_stop_fix_rets;
struct rpc_loc_ioctl_rets {
rpc_int32 loc_ioctl_result;
};
typedef struct rpc_loc_ioctl_rets rpc_loc_ioctl_rets;
struct rpc_loc_api_api_versions_rets {
rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
rpc_uint32 *len;
};
typedef struct rpc_loc_api_api_versions_rets rpc_loc_api_api_versions_rets;
#define LOC_APIVERS 0x00010001
#define LOC_APIPROG 0x3000008c
#define LOC_APIVERS_0001 0x00010001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00010001(void *, void *, CLIENT *);
extern bool_t rpc_loc_api_null_0x00010001_svc(void *, void *, struct svc_req *);
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00010001(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, CLIENT *);
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00010001_svc(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, struct svc_req *);
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00010001(rpc_loc_open_args *, rpc_loc_open_rets *, CLIENT *);
extern bool_t rpc_loc_open_0x00010001_svc(rpc_loc_open_args *, rpc_loc_open_rets *, struct svc_req *);
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00010001(rpc_loc_close_args *, rpc_loc_close_rets *, CLIENT *);
extern bool_t rpc_loc_close_0x00010001_svc(rpc_loc_close_args *, rpc_loc_close_rets *, struct svc_req *);
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00010001(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, CLIENT *);
extern bool_t rpc_loc_start_fix_0x00010001_svc(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, struct svc_req *);
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00010001(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, CLIENT *);
extern bool_t rpc_loc_stop_fix_0x00010001_svc(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, struct svc_req *);
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00010001(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, CLIENT *);
extern bool_t rpc_loc_ioctl_0x00010001_svc(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, struct svc_req *);
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00010001(void *, rpc_loc_api_api_versions_rets *, CLIENT *);
extern bool_t rpc_loc_api_api_versions_0x00010001_svc(void *, rpc_loc_api_api_versions_rets *, struct svc_req *);
extern int loc_apiprog_0x00010001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_api_null 0
extern enum clnt_stat rpc_loc_api_null_0x00010001();
extern bool_t rpc_loc_api_null_0x00010001_svc();
#define rpc_loc_api_rpc_glue_code_info_remote 1
extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00010001();
extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00010001_svc();
#define rpc_loc_open 2
extern enum clnt_stat rpc_loc_open_0x00010001();
extern bool_t rpc_loc_open_0x00010001_svc();
#define rpc_loc_close 3
extern enum clnt_stat rpc_loc_close_0x00010001();
extern bool_t rpc_loc_close_0x00010001_svc();
#define rpc_loc_start_fix 4
extern enum clnt_stat rpc_loc_start_fix_0x00010001();
extern bool_t rpc_loc_start_fix_0x00010001_svc();
#define rpc_loc_stop_fix 5
extern enum clnt_stat rpc_loc_stop_fix_0x00010001();
extern bool_t rpc_loc_stop_fix_0x00010001_svc();
#define rpc_loc_ioctl 6
extern enum clnt_stat rpc_loc_ioctl_0x00010001();
extern bool_t rpc_loc_ioctl_0x00010001_svc();
#define rpc_loc_api_api_versions 0xFFFFFFFF
extern enum clnt_stat rpc_loc_api_api_versions_0x00010001();
extern bool_t rpc_loc_api_api_versions_0x00010001_svc();
extern int loc_apiprog_0x00010001_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_api_api_versions_return_type (XDR *, rpc_loc_api_api_versions_return_type*);
extern bool_t xdr_rpc_loc_event_cb_f_type (XDR *, rpc_loc_event_cb_f_type*);
extern bool_t xdr_rpc_loc_open_args (XDR *, rpc_loc_open_args*);
extern bool_t xdr_rpc_loc_close_args (XDR *, rpc_loc_close_args*);
extern bool_t xdr_rpc_loc_start_fix_args (XDR *, rpc_loc_start_fix_args*);
extern bool_t xdr_rpc_loc_stop_fix_args (XDR *, rpc_loc_stop_fix_args*);
extern bool_t xdr_rpc_loc_ioctl_args (XDR *, rpc_loc_ioctl_args*);
extern bool_t xdr_rpc_loc_api_api_version_s_args (XDR *, rpc_loc_api_api_version_s_args*);
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *, rpc_loc_api_rpc_glue_code_info_remote_rets*);
extern bool_t xdr_rpc_loc_open_rets (XDR *, rpc_loc_open_rets*);
extern bool_t xdr_rpc_loc_close_rets (XDR *, rpc_loc_close_rets*);
extern bool_t xdr_rpc_loc_start_fix_rets (XDR *, rpc_loc_start_fix_rets*);
extern bool_t xdr_rpc_loc_stop_fix_rets (XDR *, rpc_loc_stop_fix_rets*);
extern bool_t xdr_rpc_loc_ioctl_rets (XDR *, rpc_loc_ioctl_rets*);
extern bool_t xdr_rpc_loc_api_api_versions_rets (XDR *, rpc_loc_api_api_versions_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_api_api_versions_return_type ();
extern bool_t xdr_rpc_loc_event_cb_f_type ();
extern bool_t xdr_rpc_loc_open_args ();
extern bool_t xdr_rpc_loc_close_args ();
extern bool_t xdr_rpc_loc_start_fix_args ();
extern bool_t xdr_rpc_loc_stop_fix_args ();
extern bool_t xdr_rpc_loc_ioctl_args ();
extern bool_t xdr_rpc_loc_api_api_version_s_args ();
extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets ();
extern bool_t xdr_rpc_loc_open_rets ();
extern bool_t xdr_rpc_loc_close_rets ();
extern bool_t xdr_rpc_loc_start_fix_rets ();
extern bool_t xdr_rpc_loc_stop_fix_rets ();
extern bool_t xdr_rpc_loc_ioctl_rets ();
extern bool_t xdr_rpc_loc_api_api_versions_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_H_RPCGEN */

64
loc_api/libloc_api-rpc/inc-3200/loc_api_cb.h
View file

@ -1,64 +0,0 @@
/*
* Please do not edit this file.
* It was generated using rpcgen.
*/
#ifndef _LOC_API_CB_H_RPCGEN
#define _LOC_API_CB_H_RPCGEN
#include <rpc/rpc.h>
#include <pthread.h>
#ifdef __cplusplus
extern "C" {
#endif
struct rpc_loc_event_cb_f_type_args {
rpc_uint32 cb_id;
rpc_loc_client_handle_type loc_handle;
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type *loc_event_payload;
};
typedef struct rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_args;
struct rpc_loc_event_cb_f_type_rets {
rpc_int32 loc_event_cb_f_type_result;
};
typedef struct rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_rets;
#define LOC_APICBVERS 0x00010001
#define LOC_APICBPROG 0x3100008c
#define LOC_APICBVERS_0001 0x00010001
#if defined(__STDC__) || defined(__cplusplus)
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00010001(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, CLIENT *);
extern bool_t rpc_loc_event_cb_f_type_0x00010001_svc(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, struct svc_req *);
extern int loc_apicbprog_0x00010001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
#else /* K&R C */
#define rpc_loc_event_cb_f_type 1
extern enum clnt_stat rpc_loc_event_cb_f_type_0x00010001();
extern bool_t rpc_loc_event_cb_f_type_0x00010001_svc();
extern int loc_apicbprog_0x00010001_freeresult ();
#endif /* K&R C */
/* the xdr functions */
#if defined(__STDC__) || defined(__cplusplus)
extern bool_t xdr_rpc_loc_event_cb_f_type_args (XDR *, rpc_loc_event_cb_f_type_args*);
extern bool_t xdr_rpc_loc_event_cb_f_type_rets (XDR *, rpc_loc_event_cb_f_type_rets*);
#else /* K&R C */
extern bool_t xdr_rpc_loc_event_cb_f_type_args ();
extern bool_t xdr_rpc_loc_event_cb_f_type_rets ();
#endif /* K&R C */
#ifdef __cplusplus
}
#endif
#endif /* !_LOC_API_CB_H_RPCGEN */

1031
loc_api/libloc_api-rpc/inc-3200/loc_api_common.h
View file

File diff suppressed because it is too large Load diff

188
loc_api/libloc_api-rpc/inc-3200/loc_api_fixup.h
View file

@ -1,188 +0,0 @@
/******************************************************************************
@file: loc_api_fixup.h
@brief: Loc API Android RPC amendment header
DESCRIPTION
Loc API Android RPC amendment header
INITIALIZATION AND SEQUENCING REQUIREMENTS
-----------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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_API_FIXUP_H
#define LOC_API_FIXUP_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifndef NULLPROC
#define NULLPROC 0
#endif /* NULLPROC */
#ifdef ADD_XDR_FLOAT
extern bool_t xdr_float (XDR *__xdrs, float *__fp);
extern bool_t xdr_double (XDR *__xdrs, double *__dp);
#endif /* ADD_XDR_FLOAT */
#ifdef ADD_XDR_BOOL
extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
#endif /* ADD_XDR_BOOL */
#define RPC_LOC_API_MAJOR_VERSION_NUMBER 1
#define RPC_LOC_API_MINOR_VERSION_NUMBER 0
// Return value for loc_open in case of failure.
#define RPC_LOC_CLIENT_HANDLE_INVALID -1
// Return value of loc api calls for loc_close, loc_start_fix, loc_stop_fix and loc_ioctl
// These are also the status for the ioctl callback
#define RPC_LOC_API_SUCCESS 0
#define RPC_LOC_API_GENERAL_FAILURE 1
#define RPC_LOC_API_UNSUPPORTED 2
#define RPC_LOC_API_INVALID_HANDLE 4
#define RPC_LOC_API_INVALID_PARAMETER 5
#define RPC_LOC_API_ENGINE_BUSY 6
#define RPC_LOC_API_PHONE_OFFLINE 7
#define RPC_LOC_API_TIMEOUT 8
// Special return value for loc api calls in case of RCP failure
#define RPC_LOC_API_RPC_FAILURE (-1234)
#define RPC_LOC_API_MAX_SV_COUNT 80
#define RPC_LOC_API_MAX_NMEA_STRING_LENGTH 1200
// Maximum server address that will be used in location API
#define RPC_LOC_API_MAX_SERVER_ADDR_LENGTH 256
#define RPC_LOC_API_MAX_NUM_PREDICTED_ORBITS_SERVERS 3
#define RPC_LOC_API_MAX_NUM_NTP_SERVERS 3
#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 // Position report comes in loc_parsed_position_s_type
#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 // Satellite in view report
#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 // NMEA report at 1HZ rate
#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 // NMEA report at position report rate
#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 // NI notification/verification request
#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 // Assistance data, eg: time, predicted orbits request
#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 // Request for location server
#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 // Callback report for loc_ioctl
#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 // Misc status report: eg, engine state
#define RPC_LOC_POS_VALID_SESSION_STATUS 0x00000001
#define RPC_LOC_POS_VALID_TIMESTAMP_CALENDAR 0x00000002
#define RPC_LOC_POS_VALID_TIMESTAMP_UTC 0x00000004
#define RPC_LOC_POS_VALID_LEAP_SECONDS 0x00000008
#define RPC_LOC_POS_VALID_TIME_UNC 0x00000010
#define RPC_LOC_POS_VALID_LATITUDE 0x00000020
#define RPC_LOC_POS_VALID_LONGITUDE 0x00000040
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000080
#define RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000100
#define RPC_LOC_POS_VALID_SPEED_HORIZONTAL 0x00000200
#define RPC_LOC_POS_VALID_SPEED_VERTICAL 0x00000400
#define RPC_LOC_POS_VALID_HEADING 0x00000800
#define RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR 0x00001000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MAJ 0x00002000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MIN 0x00004000
#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_ORIENT_AZIMUTH 0x00008000
#define RPC_LOC_POS_VALID_VERTICAL_UNC 0x00010000
#define RPC_LOC_POS_VALID_SPEED_UNC 0x00020000
#define RPC_LOC_POS_VALID_HEADING_UNC 0x00040000
#define RPC_LOC_POS_VALID_CONFIDENCE_HORIZONTAL 0x00080000
#define RPC_LOC_POS_VALID_CONFIDENCE_VERTICAL 0x00100000
#define RPC_LOC_POS_VALID_MAGNETIC_VARIATION 0x00200000
#define RPC_LOC_POS_VALID_TECHNOLOGY_MASK 0x00400000
#define RPC_LOC_POS_TECH_SATELLITE 0x00000001
#define RPC_LOC_POS_TECH_CELLID 0x00000002
#define RPC_LOC_POS_TECH_WIFI 0x00000004
#define RPC_LOC_SV_INFO_VALID_SYSTEM 0x00000001
#define RPC_LOC_SV_INFO_VALID_PRN 0x00000002
#define RPC_LOC_SV_INFO_VALID_HEALTH_STATUS 0x00000004
#define RPC_LOC_SV_INFO_VALID_PROCESS_STATUS 0x00000008
#define RPC_LOC_SV_INFO_VALID_HAS_EPH 0x00000010
#define RPC_LOC_SV_INFO_VALID_HAS_ALM 0x00000020
#define RPC_LOC_SV_INFO_VALID_ELEVATION 0x00000040
#define RPC_LOC_SV_INFO_VALID_AZIMUTH 0x00000080
#define RPC_LOC_SV_INFO_VALID_SNR 0x00000100
#define RPC_LOC_GNSS_INFO_VALID_POS_DOP 0x00000001
#define RPC_LOC_GNSS_INFO_VALID_HOR_DOP 0x00000002
#define RPC_LOC_GNSS_INFO_VALID_VERT_DOP 0x00000004
#define RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED 0x00000008
#define RPC_LOC_GNSS_INFO_VALID_SV_COUNT 0x00000010
#define RPC_LOC_GNSS_INFO_VALID_SV_LIST 0x00000020
#define RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH 200
#define RPC_LOC_NI_SUPL_HASH_LENGTH 8
#define RPC_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH 4
#define RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH 64
#define RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS 20
#define RPC_LOC_NI_CODEWORD_LENGTH 20
#define RPC_LOC_NI_SUPL_QOP_VALID 0x01
#define RPC_LOC_NI_SUPL_QOP_VERACC_VALID 0x02
#define RPC_LOC_NI_SUPL_QOP_MAXAGE_VALID 0x04
#define RPC_LOC_NI_SUPL_QOP_DELAY_VALID 0x08
#define RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE 0x00000001
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE 0x00000002
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY 0x00000004
#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME 0x00000008
#define RPC_LOC_FIX_CRIT_VALID_INTERMEDIATE_POS_REPORT_ENABLED 0x00000010
#define RPC_LOC_FIX_CRIT_VALID_NOTIFY_TYPE 0x00000020
#define RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL 0x00000040
#define RPC_LOC_FIX_CRIT_VALID_MIN_DISTANCE 0x00000080
#define RPC_LOC_FIX_CRIT_VALID_MIN_DIST_SAMPLE_INTERVAL 0x00000100
#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_UTC 0x00000001
#define RPC_LOC_ASSIST_POS_VALID_LATITUDE 0x00000002
#define RPC_LOC_ASSIST_POS_VALID_LONGITUDE 0x00000004
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000008
#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000010
#define RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR 0x00000020
#define RPC_LOC_ASSIST_POS_VALID_VERT_UNC 0x00000040
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL 0x00000080
#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_VERTICAL 0x00000100
#define RPC_LOC_ASSIST_DATA_ALL 0xFFFFFFFF
#define RPC_LOC_NMEA_MASK_ALL 0xffff
#define RPC_LOC_NMEA_MASK_GGA 0x0001
#define RPC_LOC_NMEA_MASK_RMC 0x0002
#define RPC_LOC_NMEA_MASK_GSV 0x0004
#define RPC_LOC_NMEA_MASK_GSA 0x0008
#define RPC_LOC_NMEA_MASK_VTG 0x0010
/* flags for notification */
#define RPC_LOC_NI_CLIENT_NAME_PRESENT 0x0001
#define RPC_LOC_NI_CLIENT_EXTADDR_PRESENT 0x0002
#define RPC_LOC_NI_DEF_LOCATION_TYPE_PRESENT 0x0010
#define RPC_LOC_NI_REQUESTOR_ID_PRESENT 0x0020
#define RPC_LOC_NI_CODEWORD_PRESENT 0x0040
#define RPC_LOC_NI_SERVICE_TYPE_ID_PRESENT 0x0080
#define RPC_LOC_NI_ENCODING_TYPE_PRESENT 0x0100
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_FIXUP_H */

34
loc_api/libloc_api-rpc/inc-3200/loc_apicb_appinit.h
View file

@ -1,34 +0,0 @@
/* -------------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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_APICB_APPINIT_H
#define LOC_APICB_APPINIT_H
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialization function for callbacks */
extern int loc_apicb_app_init();
extern void loc_apicb_app_deinit();
#ifdef __cplusplus
}
#endif
#endif /* LOC_APICB_APPINIT_H */

57
loc_api/libloc_api-rpc/inc/debug.h
View file

@ -1,57 +0,0 @@
/*
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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 DEBUG_H
#define DEBUG_H
#include <stdio.h>
#define LOG_TAG "libgps-rpc"
#include <utils/Log.h>
#define PRINT(x...) do { \
fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \
fprintf(stdout, ##x); \
LOGD(x); \
} while(0)
#ifdef DEBUG
#define D PRINT
#else
#define D(x...) do { } while(0)
#endif
#ifdef VERBOSE
#define V PRINT
#else
#define V(x...) do { } while(0)
#endif
#define E(x...) do { \
fprintf(stderr, "%s(%d) ", __FUNCTION__, __LINE__); \
fprintf(stderr, ##x); \
LOGE(x); \
} while(0)
#define FAILIF(cond, msg...) do { \
if (__builtin_expect (cond, 0)) { \
fprintf(stderr, "%s:%s:(%d): ", __FILE__, __FUNCTION__, __LINE__); \
fprintf(stderr, ##msg); \
LOGE(##msg); \
} \
} while(0)
#endif/*DEBUG_H*/

100
loc_api/libloc_api-rpc/inc/loc_api_rpc_glue.h
View file

@ -1,100 +0,0 @@
/******************************************************************************
@file: loc_api_rpc_glue.h
@brief: Loc API Android glue code header
DESCRIPTION
Loc API Android glue code header
INITIALIZATION AND SEQUENCING REQUIREMENTS
-----------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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.
-----------------------------------------------------------------------------
******************************************************************************/
/*=====================================================================
EDIT HISTORY FOR MODULE
This section contains comments describing changes made to the module.
Notice that changes are listed in reverse chronological order.
when who what, where, why
-------- --- -------------------------------------------------------
03/17/09 dx Initial version
$Id: //source/qcom/qct/modem/gps/cgps/dev/locationmiddleware/locapi/app-linux/source/test/loc_api_test/loc_api_cb_log.h#4 $
======================================================================*/
#ifndef LOC_API_RPC_GLUE_H
#define LOC_API_RPC_GLUE_H
/* Include RPC headers */
#include "loc_api_common.h"
#include "loc_api.h"
#include "loc_api_cb.h"
#include "loc_api_fixup.h"
#ifdef __cplusplus
extern "C"
{
#endif
/* Boolean */
/* Other data types in comdef.h are defined in rpc stubs, so fix it here */
typedef unsigned char boolean;
#define TRUE 1
#define FALSE 0
extern int loc_api_glue_init(void);
extern int loc_api_null(void);
typedef int32 (loc_event_cb_f_type)(
rpc_loc_client_handle_type loc_handle, /* handle of the client */
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
);
extern rpc_loc_client_handle_type loc_open(
rpc_loc_event_mask_type event_reg_mask,
loc_event_cb_f_type *event_callback
);
extern int32 loc_close
(
rpc_loc_client_handle_type handle
);
extern int32 loc_start_fix
(
rpc_loc_client_handle_type handle
);
extern int32 loc_stop_fix
(
rpc_loc_client_handle_type handle
);
extern int32 loc_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data
);
#ifdef __cplusplus
}
#endif
#endif /* LOC_API_RPC_GLUE_H */

61
loc_api/libloc_api-rpc/src/loc_apicb_appinit.c
View file

@ -1,61 +0,0 @@
/* -------------------------------------------------------------------------------
Copyright (c) 2009, QUALCOMM USA, INC.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
· Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
· Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
· Neither the name of the QUALCOMM USA, INC. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED 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 "rpc/rpc.h"
#include "loc_api_common.h"
#include "loc_api.h"
#include "loc_api_cb.h"
#include "loc_api_fixup.h"
#include "loc_apicb_appinit.h"
#define RPC_FUNC_VERSION_BASE(a,b) a ## b
#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
static SVCXPRT* svrPort = NULL;
extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
int loc_apicb_app_init(void)
{
/* Register a callback server to use the loc_apicbprog_* function */
if (svrPort == NULL) {
svrPort = svcrtr_create();
}
if (!svrPort) return -1;
xprt_register(svrPort);
if(svc_register(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
{
return 0;
}
else
{
return -1;
}
}
void loc_apicb_app_deinit(void)
{
if (svrPort == NULL)
{
return;
}
xprt_unregister(svrPort);
svc_destroy(svrPort);
//svc_unregister(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001);
svrPort = NULL;
}

39
loc_api/libloc_api/Android.mk
View file

@ -1,39 +0,0 @@
#Compile the old library version from Google push for Passion builds with old modem image
ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
LOCAL_MODULE_TAGS := optional
LOCAL_STATIC_LIBRARIES:= \
libloc_api-rpc
LOCAL_SHARED_LIBRARIES := \
librpc \
libutils \
libcutils
LOCAL_SRC_FILES += \
loc_eng.cpp \
loc_eng_ioctl.cpp \
loc_eng_xtra.cpp \
loc_eng_ni.cpp \
gps.c
LOCAL_CFLAGS += \
-fno-short-enums \
-DAMSS_VERSION=$(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION)
LOCAL_C_INCLUDES:= \
$(TARGET_OUT_HEADERS)/libloc_api-rpc \
$(TARGET_OUT_HEADERS)/libloc_api-rpc/inc \
$(TARGET_OUT_HEADERS)/libcommondefs-rpc/inc \
$(TARGET_OUT_HEADERS)/librpc
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
include $(BUILD_SHARED_LIBRARY)
endif #BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION = 50001

68
loc_api/libloc_api/gps.c
View file

@ -1,68 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <hardware/gps.h>
#include <stdlib.h>
extern const GpsInterface* get_gps_interface();
const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)
{
return get_gps_interface();
}
static int open_gps(const struct hw_module_t* module, char const* name,
struct hw_device_t** device)
{
struct gps_device_t *dev = malloc(sizeof(struct gps_device_t));
memset(dev, 0, sizeof(*dev));
dev->common.tag = HARDWARE_DEVICE_TAG;
dev->common.version = 0;
dev->common.module = (struct hw_module_t*)module;
dev->get_gps_interface = gps__get_gps_interface;
*device = (struct hw_device_t*)dev;
return 0;
}
static struct hw_module_methods_t gps_module_methods = {
.open = open_gps
};
const struct hw_module_t HAL_MODULE_INFO_SYM = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = GPS_HARDWARE_MODULE_ID,
.name = "loc_api GPS Module",
.author = "Qualcomm USA, Inc.",
.methods = &gps_module_methods,
};

1533
loc_api/libloc_api/loc_eng.cpp
View file

File diff suppressed because it is too large Load diff

115
loc_api/libloc_api/loc_eng.h
View file

@ -1,115 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_H
#define LOC_ENG_H
// Define boolean type to be used by libgps on loc api module
typedef unsigned char boolean;
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#include <loc_eng_ioctl.h>
#include <loc_eng_xtra.h>
#include <hardware/gps.h>
#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds
enum {
DEFERRED_ACTION_EVENT = 0x01,
DEFERRED_ACTION_DELETE_AIDING = 0x02,
DEFERRED_ACTION_AGPS_STATUS = 0x04,
DEFERRED_ACTION_AGPS_DATA_SUCCESS = 0x08,
DEFERRED_ACTION_AGPS_DATA_CLOSED = 0x10,
DEFERRED_ACTION_AGPS_DATA_FAILED = 0x20,
DEFERRED_ACTION_QUIT = 0x40,
};
// Module data
typedef struct
{
rpc_loc_client_handle_type client_handle;
gps_location_callback location_cb;
gps_status_callback status_cb;
gps_sv_status_callback sv_status_cb;
agps_status_callback agps_status_cb;
gps_nmea_callback nmea_cb;
gps_ni_notify_callback ni_notify_cb;
gps_acquire_wakelock acquire_wakelock_cb;
gps_release_wakelock release_wakelock_cb;
int agps_status;
// used to defer stopping the GPS engine until AGPS data calls are done
boolean agps_request_pending;
boolean stop_request_pending;
pthread_mutex_t deferred_stop_mutex;
loc_eng_xtra_data_s_type xtra_module_data;
loc_eng_ioctl_data_s_type ioctl_data;
// data from loc_event_cb
rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type loc_event_payload;
// TBD:
char agps_server_host[256];
int agps_server_port;
uint32 agps_server_address;
char apn_name[100];
int position_mode;
rpc_loc_server_connection_handle conn_handle;
// GPS engine status
GpsStatusValue engine_status;
// Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
GpsAidingData aiding_data_for_deletion;
// Data variables used by deferred action thread
pthread_t deferred_action_thread;
// Mutex used by deferred action thread
pthread_mutex_t deferred_action_mutex;
// Condition variable used by deferred action thread
pthread_cond_t deferred_action_cond;
// flags for pending events for deferred action thread
int deferred_action_flags;
} loc_eng_data_s_type;
extern loc_eng_data_s_type loc_eng_data;
#endif // LOC_ENG_H

354
loc_api/libloc_api/loc_eng_ioctl.cpp
View file

@ -1,354 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <ctype.h>
#include <math.h>
#include <pthread.h>
#include <rpc/rpc.h>
#include <loc_api_rpc_glue.h>
#include <hardware/gps.h>
#include <loc_eng.h>
#define LOG_TAG "lib_locapi"
#include <utils/Log.h>
// comment this out to enable logging
// #undef LOGD
// #define LOGD(...) {}
// Function declarations
static boolean loc_eng_ioctl_setup_cb(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type
);
static boolean loc_eng_ioctl_wait_cb(
int timeout_msec, // Timeout in this number of msec
rpc_loc_ioctl_callback_s_type *cb_data_ptr // Output parameter for IOCTL calls
);
/*===========================================================================
FUNCTION loc_eng_ioctl
DESCRIPTION
This function calls loc_ioctl and waits for the callback result before
returning back to the user.
DEPENDENCIES
N/A
RETURN VALUE
TRUE if successful
FALSE if failed
SIDE EFFECTS
N/A
===========================================================================*/
boolean loc_eng_ioctl(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
)
{
boolean ret_val;
int rpc_ret_val;
loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
LOGV ("loc_eng_ioctl: client = %d, ioctl_type = %d, cb_data =0x%x\n", (int32) handle, ioctl_type, (uint32) cb_data_ptr);
ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
// Select the callback we are waiting for
ret_val = loc_eng_ioctl_setup_cb (handle, ioctl_type);
if (ret_val == TRUE)
{
rpc_ret_val = loc_ioctl (handle,
ioctl_type,
ioctl_data_ptr);
LOGV ("loc_eng_ioctl: loc_ioctl returned %d \n", rpc_ret_val);
if (rpc_ret_val == RPC_LOC_API_SUCCESS)
{
// Wait for the callback of loc_ioctl
ret_val = loc_eng_ioctl_wait_cb (timeout_msec, cb_data_ptr);
}
else
{
ret_val = FALSE;
}
}
// Reset the state when we are done
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
ioctl_cb_data_ptr->cb_is_selected = FALSE;
ioctl_cb_data_ptr->cb_is_waiting = FALSE;
ioctl_cb_data_ptr->cb_has_arrived = FALSE;
pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
return ret_val;
}
/*===========================================================================
FUNCTION loc_eng_ioctl_setup_cb
DESCRIPTION
Selects which callback is going to be waited for
DEPENDENCIES
N/A
RETURN VALUE
TRUE if successful
FALSE if failed
SIDE EFFECTS
N/A
===========================================================================*/
static boolean loc_eng_ioctl_setup_cb(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type
)
{
boolean ret_val;
loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
if (ioctl_cb_data_ptr->cb_is_selected == TRUE)
{
LOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n");
ret_val = FALSE;
}
else
{
ioctl_cb_data_ptr->cb_is_selected = TRUE;
ioctl_cb_data_ptr->cb_is_waiting = FALSE;
ioctl_cb_data_ptr->cb_has_arrived = FALSE;
ioctl_cb_data_ptr->client_handle = handle;
ioctl_cb_data_ptr->ioctl_type = ioctl_type;
memset (&(ioctl_cb_data_ptr->cb_payload), 0, sizeof (rpc_loc_ioctl_callback_s_type));
ret_val = TRUE;
}
pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
return ret_val;
}
/*===========================================================================
FUNCTION loc_eng_ioctl_wait_cb
DESCRIPTION
Waits for a selected callback. The wait expires in timeout_msec.
If the function is called before an existing wait has finished, it will
immediately return EBUSY.
DEPENDENCIES
N/A
RETURN VALUE
TRUE if successful
FALSE if failed
SIDE EFFECTS
N/A
===========================================================================*/
boolean loc_eng_ioctl_wait_cb(
int timeout_msec, // Timeout in this number of msec
rpc_loc_ioctl_callback_s_type *cb_data_ptr
)
{
boolean ret_val = FALSE; // the return value of this function
int rc; // return code from pthread calls
struct timeval present_time;
struct timespec expire_time;
loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
do {
if (ioctl_cb_data_ptr->cb_is_selected == FALSE)
{
LOGD ("loc_eng_ioctl_wait_cb: ERROR called when cb_is_waiting is set to FALSE \n");
ret_val = FALSE;
break;
}
// Calculate absolute expire time
gettimeofday(&present_time, NULL);
expire_time.tv_sec = present_time.tv_sec;
expire_time.tv_sec += timeout_msec / 1000;
if ((present_time.tv_usec + timeout_msec) >= 1000)
{
expire_time.tv_sec += 1;
}
expire_time.tv_nsec = (present_time.tv_usec + timeout_msec) % 1000 * 1000;
// Special case where callback is issued before loc_ioctl ever returns
if (ioctl_cb_data_ptr->cb_has_arrived == TRUE)
{
LOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n");
ret_val = TRUE;
break;
}
ioctl_cb_data_ptr->cb_is_waiting = TRUE;
// Wait for the callback until timeout expires
rc = pthread_cond_timedwait(&ioctl_cb_data_ptr->cb_arrived_cond,
&ioctl_cb_data_ptr->cb_data_mutex,
&expire_time);
if (rc == 0)
{
ret_val = TRUE;
}
else
{
ret_val = FALSE;
}
LOGV ("loc_eng_ioctl_wait_cb: pthread_cond_timedwait returned %d\n", rc);
} while (0);
// Process the ioctl callback data when IOCTL is successful
if (ret_val == TRUE)
{
ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
if (ioctl_cb_data_ptr->cb_payload.status == RPC_LOC_API_SUCCESS)
{
ret_val = TRUE;
if (cb_data_ptr != NULL)
{
memcpy (cb_data_ptr,
&(ioctl_cb_data_ptr->cb_payload),
sizeof (rpc_loc_ioctl_callback_s_type));
}
}
else
{
ret_val = FALSE;
}
}
pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
LOGV ("loc_eng_ioctl_wait_cb: returned %d\n", ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_eng_ioctl_process_cb
DESCRIPTION
This function process the IOCTL callback, parameter specifies the client
that receives the IOCTL callback.
DEPENDENCIES
N/A
RETURN VALUE
TRUE if successful
FALSE if failed
SIDE EFFECTS
N/A
===========================================================================*/
boolean loc_eng_ioctl_process_cb (
rpc_loc_client_handle_type client_handle,
const rpc_loc_ioctl_callback_s_type *cb_data_ptr
)
{
boolean ret_val = FALSE; // the return value of this function
loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
if (client_handle != ioctl_cb_data_ptr->client_handle)
{
LOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n",
(int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle);
ret_val = FALSE;
}
else if (cb_data_ptr->type != ioctl_cb_data_ptr->ioctl_type)
{
LOGD ("loc_eng_ioctl_process_cb: ioctl type mismatch, received = %d, expected = %d \n",
cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type);
ret_val = FALSE;
}
else // both matches
{
memcpy (&(ioctl_cb_data_ptr->cb_payload),
cb_data_ptr,
sizeof (rpc_loc_ioctl_callback_s_type));
ioctl_cb_data_ptr->cb_has_arrived = TRUE;
LOGV ("loc_eng_ioctl_process_cb: callback arrived for client = %d, ioctl = %d, status = %d\n",
(int32) ioctl_cb_data_ptr->client_handle, ioctl_cb_data_ptr->ioctl_type,
(int32) ioctl_cb_data_ptr->cb_payload.status);
ret_val = TRUE;
}
pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
// Signal the waiting thread that callback has arrived
if (ret_val == TRUE)
{
pthread_cond_signal (&ioctl_cb_data_ptr->cb_arrived_cond);
}
return ret_val;
}

69
loc_api/libloc_api/loc_eng_ioctl.h
View file

@ -1,69 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_IOCTL_H
#define LOC_ENG_IOCTL_H
// Module data
typedef struct loc_eng_ioctl_data_s_type
{
// We are waiting for an ioctl callback
boolean cb_is_selected;
// The thread has been put in a wait state for an ioctl callback
boolean cb_is_waiting;
// Loc client handle that is waiting for the callback
rpc_loc_client_handle_type client_handle;
// IOCTL type that the loc client is waiting for
rpc_loc_ioctl_e_type ioctl_type;
// The IOCLT report has arrived for the waiting client
boolean cb_has_arrived;
// The payload for the RPC_LOC_EVENT_IOCTL_REPORT
rpc_loc_ioctl_callback_s_type cb_payload;
// Mutex to access this data structure
pthread_mutex_t cb_data_mutex;
// LOC ioctl callback arrived mutex
pthread_cond_t cb_arrived_cond;
} loc_eng_ioctl_data_s_type;
extern boolean loc_eng_ioctl
(
rpc_loc_client_handle_type handle,
rpc_loc_ioctl_e_type ioctl_type,
rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
uint32 timeout_msec,
rpc_loc_ioctl_callback_s_type *cb_data_ptr
);
extern boolean loc_eng_ioctl_process_cb
(
rpc_loc_client_handle_type client_handle,
const rpc_loc_ioctl_callback_s_type *cb_data_ptr
);
#endif // LOC_ENG_IOCTL_H

609
loc_api/libloc_api/loc_eng_ni.cpp
View file

@ -1,609 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#include <rpc/rpc.h>
#include <loc_api_rpc_glue.h>
#include <loc_eng.h>
#include <loc_eng_ni.h>
#define LOG_TAG "lib_locapi"
#include <utils/Log.h>
// comment this out to enable logging
// #undef LOGD
// #define LOGD(...) {}
/*=============================================================================
*
* DATA DECLARATION
*
*============================================================================*/
const GpsNiInterface sLocEngNiInterface =
{
sizeof(GpsNiInterface),
loc_eng_ni_init,
loc_eng_ni_respond,
};
boolean loc_eng_ni_data_init = FALSE;
loc_eng_ni_data_s_type loc_eng_ni_data;
extern loc_eng_data_s_type loc_eng_data;
/*=============================================================================
*
* FUNCTION DECLARATIONS
*
*============================================================================*/
/*===========================================================================
FUNCTION respond_from_enum
DESCRIPTION
Returns the name of the response
RETURN VALUE
response name string
===========================================================================*/
static const char* respond_from_enum(rpc_loc_ni_user_resp_e_type resp)
{
switch (resp)
{
case RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT:
return "accept";
case RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY:
return "deny";
case RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP:
return "no response";
default:
return NULL;
}
}
/*===========================================================================
FUNCTION loc_ni_respond
DESCRIPTION
Displays the NI request and awaits user input. If a previous request is
in session, the new one is handled using sys.ni_default_response (if exists);
otherwise, it is denied.
DEPENDENCY
Do not lock the data by mutex loc_ni_lock
RETURN VALUE
none
===========================================================================*/
static void loc_ni_respond(rpc_loc_ni_user_resp_e_type resp,
const rpc_loc_ni_event_s_type *request_pass_back
)
{
LOGD("Sending NI response: %s\n", respond_from_enum(resp));
rpc_loc_ioctl_data_u_type data;
rpc_loc_ioctl_callback_s_type callback_payload;
memcpy(&data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.ni_event_pass_back,
request_pass_back, sizeof (rpc_loc_ni_event_s_type));
data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = resp;
loc_eng_ioctl(
loc_eng_data.client_handle,
RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE,
&data,
LOC_IOCTL_DEFAULT_TIMEOUT,
&callback_payload
);
}
/*===========================================================================
FUNCTION loc_ni_fill_notif_verify_type
DESCRIPTION
Fills need_notify, need_verify, etc.
RETURN VALUE
none
===========================================================================*/
static boolean loc_ni_fill_notif_verify_type(GpsNiNotification *notif,
rpc_loc_ni_notify_verify_e_type notif_priv)
{
notif->notify_flags = 0;
notif->default_response = GPS_NI_RESPONSE_NORESP;
switch (notif_priv)
{
case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY:
notif->notify_flags = 0;
break;
case RPC_LOC_NI_USER_NOTIFY_ONLY:
notif->notify_flags = GPS_NI_NEED_NOTIFY;
break;
case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP:
notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
notif->default_response = GPS_NI_RESPONSE_ACCEPT;
break;
case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP:
notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
notif->default_response = GPS_NI_RESPONSE_DENY;
break;
case RPC_LOC_NI_USER_PRIVACY_OVERRIDE:
notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE;
break;
default:
return FALSE;
}
return TRUE;
}
/*===========================================================================
FUNCTION hexcode
DESCRIPTION
Converts a binary array into a Hex string. E.g., 1F 00 3F --> "1F003F"
RETURN VALUE
bytes encoded
===========================================================================*/
static int hexcode(char *hexstring, int string_size, const char *data, int data_size)
{
int i;
for (i = 0; i < data_size; i++)
{
char ch = data[i];
if (i*2 + 3 <= string_size)
{
snprintf(&hexstring[i*2], 3, "%02X", ch);
}
else {
break;
}
}
return i;
}
static GpsNiEncodingType convert_encoding_type(int loc_encoding)
{
GpsNiEncodingType enc = GPS_ENC_UNKNOWN;
switch (loc_encoding)
{
case RPC_LOC_NI_SUPL_UTF8:
enc = GPS_ENC_SUPL_UTF8;
break;
case RPC_LOC_NI_SUPL_UCS2:
enc = GPS_ENC_SUPL_UCS2;
break;
case RPC_LOC_NI_SUPL_GSM_DEFAULT:
enc = GPS_ENC_SUPL_GSM_DEFAULT;
break;
default:
break;
}
return enc;
}
/*===========================================================================
FUNCTION loc_ni_request_handler
DESCRIPTION
Displays the NI request and awaits user input. If a previous request is
in session, it is ignored.
RETURN VALUE
none
===========================================================================*/
static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_type *ni_req)
{
GpsNiNotification notif;
notif.size = sizeof(notif);
strlcpy(notif.text, "[text]", sizeof notif.text); // defaults
strlcpy(notif.requestor_id, "[requestor id]", sizeof notif.requestor_id);
/* If busy, use default or deny */
if (loc_eng_ni_data.notif_in_progress)
{
#if 0
/* Cannot be here because the current thread is in RPC client */
/* XXX Consider adding an event queue to process overlapped NI requests */
loc_ni_user_resp_e_type response =
sys.ni_default_resp == 1 /* accept */ ?
LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT :
LOC_NI_LCS_NOTIFY_VERIFY_DENY;
loc_ni_respond(response, ni_req); */
#endif
LOGW("loc_ni_request_handler, notification in progress, new NI request ignored, type: %d",
ni_req->event);
}
else {
/* Print notification */
LOGD("NI Notification: %s, event: %d", msg, ni_req->event);
pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
/* Save request */
memcpy(&loc_eng_ni_data.loc_ni_request, ni_req, sizeof loc_eng_ni_data.loc_ni_request);
/* Set up NI response waiting */
loc_eng_ni_data.notif_in_progress = TRUE;
loc_eng_ni_data.current_notif_id = abs(rand());
/* Fill in notification */
notif.notification_id = loc_eng_ni_data.current_notif_id;
const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req;
const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req;
const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req;
switch (ni_req->event)
{
case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
vx_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req;
notif.ni_type = GPS_NI_TYPE_VOICE;
notif.timeout = LOC_NI_NO_RESPONSE_TIME; // vx_req->user_resp_timer_val;
memset(notif.extras, 0, sizeof notif.extras);
memset(notif.text, 0, sizeof notif.text);
memset(notif.requestor_id, 0, sizeof notif.requestor_id);
// Requestor ID
hexcode(notif.requestor_id, sizeof notif.requestor_id,
vx_req->requester_id.requester_id,
vx_req->requester_id.requester_id_length);
notif.text_encoding = 0; // No text and no encoding
notif.requestor_id_encoding = convert_encoding_type(vx_req->encoding_scheme);
// Set default_response & notify_flags
loc_ni_fill_notif_verify_type(&notif, vx_req->notification_priv_type);
break;
case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
umts_cp_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req;
notif.ni_type = GPS_NI_TYPE_UMTS_CTRL_PLANE;
notif.timeout = LOC_NI_NO_RESPONSE_TIME; // umts_cp_req->user_response_timer;
memset(notif.extras, 0, sizeof notif.extras);
memset(notif.text, 0, sizeof notif.text);
memset(notif.requestor_id, 0, sizeof notif.requestor_id);
// Stores notification text
hexcode(notif.text, sizeof notif.text,
#if (AMSS_VERSION==3200)
umts_cp_req->notification_text.notification_text_val,
#else
umts_cp_req->notification_text,
#endif
umts_cp_req->notification_length);
// Stores requestor ID
hexcode(notif.requestor_id, sizeof notif.requestor_id,
#if (AMSS_VERSION==3200)
umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val,
#else
umts_cp_req->requestor_id.requestor_id_string,
#endif
umts_cp_req->requestor_id.string_len);
notif.text_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
notif.requestor_id_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
// Set default_response & notify_flags
loc_ni_fill_notif_verify_type(&notif, umts_cp_req->notification_priv_type);
break;
case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
notif.ni_type = GPS_NI_TYPE_UMTS_SUPL;
notif.timeout = LOC_NI_NO_RESPONSE_TIME; // supl_req->user_response_timer;
memset(notif.extras, 0, sizeof notif.extras);
memset(notif.text, 0, sizeof notif.text);
memset(notif.requestor_id, 0, sizeof notif.requestor_id);
// Client name
if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT)
{
hexcode(notif.text, sizeof notif.text,
#if (AMSS_VERSION==3200)
supl_req->client_name.client_name_string.client_name_string_val, /* buffer */
#else
supl_req->client_name.client_name_string, /* buffer */
#endif
supl_req->client_name.string_len /* length */
);
LOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
} else {
LOGD("SUPL NI: client_name not present.");
}
// Requestor ID
if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT)
{
hexcode(notif.requestor_id, sizeof notif.requestor_id,
#if (AMSS_VERSION==3200)
supl_req->requestor_id.requestor_id_string.requestor_id_string_val, /* buffer */
#else
supl_req->requestor_id.requestor_id_string, /* buffer */
#endif
supl_req->requestor_id.string_len /* length */
);
LOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
} else {
LOGD("SUPL NI: requestor_id not present.");
}
// Encoding type
if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT)
{
notif.text_encoding = convert_encoding_type(supl_req->datacoding_scheme);
notif.requestor_id_encoding = convert_encoding_type(supl_req->datacoding_scheme);
} else {
notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
}
// Set default_response & notify_flags
loc_ni_fill_notif_verify_type(&notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type);
break;
default:
LOGE("loc_ni_request_handler, unknown request event: %d", ni_req->event);
return;
}
/* Log requestor ID and text for debugging */
LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif.ni_type, notif.timeout, notif.default_response);
LOGI(" requestor_id: %s (encoding: %d)", notif.requestor_id, notif.requestor_id_encoding);
LOGI(" text: %s text (encoding: %d)", notif.text, notif.text_encoding);
/* For robustness, always sets a timeout to clear up the notification status, even though
* the OEM layer in java does not do so.
**/
loc_eng_ni_data.response_time_left = 5 + (notif.timeout != 0 ? notif.timeout : LOC_NI_NO_RESPONSE_TIME);
LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data.response_time_left);
pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
/* Notify callback */
if (loc_eng_data.ni_notify_cb != NULL)
{
loc_eng_data.ni_notify_cb(&notif);
}
}
}
/*===========================================================================
FUNCTION loc_ni_process_user_response
DESCRIPTION
Handles user input from the UI
RETURN VALUE
error code (0 for successful, -1 for error)
===========================================================================*/
int loc_ni_process_user_response(GpsUserResponseType userResponse)
{
LOGD("NI response from UI: %d", userResponse);
rpc_loc_ni_user_resp_e_type resp;
switch (userResponse)
{
case GPS_NI_RESPONSE_ACCEPT:
resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT;
break;
case GPS_NI_RESPONSE_DENY:
resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY;
break;
case GPS_NI_RESPONSE_NORESP:
resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP;
break;
default:
return -1;
}
loc_ni_respond(resp, &loc_eng_ni_data.loc_ni_request);
/* Make the NI respond */
pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
loc_eng_ni_data.notif_in_progress = FALSE;
loc_eng_ni_data.response_time_left = 0;
loc_eng_ni_data.current_notif_id = -1;
pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
return 0;
}
/*===========================================================================
FUNCTION loc_eng_ni_callback
DESCRIPTION
Loc API callback handler
RETURN VALUE
error code (0 for success)
===========================================================================*/
int loc_eng_ni_callback (
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
)
{
int rc = 0;
const rpc_loc_ni_event_s_type *ni_req = &loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request;
if (loc_event == RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST)
{
switch (ni_req->event)
{
case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
LOGI("VX Notification");
loc_ni_request_handler("VX Notify", ni_req);
break;
case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
LOGI("UMTS CP Notification\n");
loc_ni_request_handler("UMTS CP Notify", ni_req);
break;
case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
LOGI("SUPL Notification\n");
loc_ni_request_handler("SUPL Notify", ni_req);
break;
default:
LOGE("Unknown NI event: %x\n", (int) ni_req->event);
break;
}
}
return rc;
}
/*===========================================================================
FUNCTION loc_ni_thread_proc
===========================================================================*/
static void loc_ni_thread_proc(void *unused)
{
LOGI("Starting Loc NI thread...\n");
while (1)
{
/* wakes up every second to check timed out requests */
sleep(1);
pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
if (loc_eng_ni_data.notif_in_progress && loc_eng_ni_data.response_time_left > 0)
{
loc_eng_ni_data.response_time_left--;
if (loc_eng_ni_data.response_time_left <= 0)
{
loc_ni_respond(RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP, &loc_eng_ni_data.loc_ni_request);
loc_eng_ni_data.notif_in_progress = FALSE;
}
}
pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
} /* while (1) */
}
/*===========================================================================
FUNCTION loc_eng_ni_init
DESCRIPTION
This function initializes the NI interface
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_eng_ni_init(GpsNiCallbacks *callbacks)
{
LOGD("loc_eng_ni_init: entered.");
if (!loc_eng_ni_data_init)
{
pthread_mutex_init(&loc_eng_ni_data.loc_ni_lock, NULL);
callbacks->create_thread_cb("loc_api_ni", loc_ni_thread_proc, NULL);
loc_eng_ni_data_init = TRUE;
}
loc_eng_ni_data.notif_in_progress = FALSE;
loc_eng_ni_data.current_notif_id = -1;
loc_eng_ni_data.response_time_left = 0;
srand(time(NULL));
loc_eng_data.ni_notify_cb = callbacks->notify_cb;
}
/*===========================================================================
FUNCTION loc_eng_ni_respond
DESCRIPTION
This function sends an NI respond to the modem processor
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response)
{
if (notif_id == loc_eng_ni_data.current_notif_id && loc_eng_ni_data.notif_in_progress)
{
LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
loc_ni_process_user_response(user_response);
} else {
LOGE("loc_eng_ni_respond: notif_id %d mismatch or notification not in progress, response: %d",
notif_id, user_response);
}
}

56
loc_api/libloc_api/loc_eng_ni.h
View file

@ -1,56 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_NI_H
#define LOC_ENG_NI_H
#include <hardware/gps.h>
#define LOC_NI_NO_RESPONSE_TIME 20 /* secs */
extern const GpsNiInterface sLocEngNiInterface;
typedef struct {
pthread_mutex_t loc_ni_lock;
int response_time_left; /* examine time for NI response */
boolean notif_in_progress; /* NI notification/verification in progress */
rpc_loc_ni_event_s_type loc_ni_request;
int current_notif_id; /* ID to check against response */
} loc_eng_ni_data_s_type;
// Functions for sLocEngNiInterface
extern void loc_eng_ni_init(GpsNiCallbacks *callbacks);
extern void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response);
extern int loc_eng_ni_callback (
rpc_loc_event_mask_type loc_event, /* event mask */
const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
);
#endif /* LOC_ENG_NI_H */

180
loc_api/libloc_api/loc_eng_xtra.cpp
View file

@ -1,180 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <pthread.h>
#include <rpc/rpc.h>
#include <loc_api_rpc_glue.h>
#include <loc_eng.h>
#define LOG_TAG "lib_locapi"
#include <utils/Log.h>
// comment this out to enable logging
// #undef LOGD
// #define LOGD(...) {}
#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
#define XTRA_BLOCK_SIZE (400)
static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks);
static int qct_loc_eng_inject_xtra_data(char* data, int length);
const GpsXtraInterface sLocEngXTRAInterface =
{
sizeof(GpsXtraInterface),
qct_loc_eng_xtra_init,
qct_loc_eng_inject_xtra_data,
};
/*===========================================================================
FUNCTION qct_loc_eng_xtra_init
DESCRIPTION
Initialize XTRA module.
DEPENDENCIES
N/A
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks)
{
rpc_loc_event_mask_type event;
loc_eng_xtra_data_s_type *xtra_module_data_ptr;
xtra_module_data_ptr = &(loc_eng_data.xtra_module_data);
xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb;
return 0;
}
/*===========================================================================
FUNCTION qct_loc_eng_inject_xtra_data
DESCRIPTION
Injects XTRA file into the engine.
DEPENDENCIES
N/A
RETURN VALUE
0: success
>0: failure
SIDE EFFECTS
N/A
===========================================================================*/
static int qct_loc_eng_inject_xtra_data(char* data, int length)
{
int rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
boolean ret_val = 0;
int total_parts;
uint8 part;
uint16 part_len;
uint16 len_injected;
rpc_loc_ioctl_data_u_type ioctl_data;
rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr;
LOGV ("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%x\n", length, (int) data);
ioctl_data.disc = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA;
predicted_orbits_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.predicted_orbits_data);
predicted_orbits_data_ptr->format_type = RPC_LOC_PREDICTED_ORBITS_XTRA;
predicted_orbits_data_ptr->total_size = length;
total_parts = (length / XTRA_BLOCK_SIZE);
if ((total_parts % XTRA_BLOCK_SIZE) != 0)
{
total_parts += 1;
}
predicted_orbits_data_ptr->total_parts = total_parts;
len_injected = 0; // O bytes injected
// XTRA injection starts with part 1
for (part = 1; part <= total_parts; part++)
{
predicted_orbits_data_ptr->part = part;
predicted_orbits_data_ptr->part_len = XTRA_BLOCK_SIZE;
if (XTRA_BLOCK_SIZE > (length - len_injected))
{
predicted_orbits_data_ptr->part_len = length - len_injected;
}
predicted_orbits_data_ptr->data_ptr.data_ptr_len = predicted_orbits_data_ptr->part_len;
predicted_orbits_data_ptr->data_ptr.data_ptr_val = data + len_injected;
LOGV ("qct_loc_eng_inject_xtra_data, inject part = %d, len = %d, len = %d\n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len, predicted_orbits_data_ptr->data_ptr.data_ptr_len);
LOGV ("qct_loc_eng_inject_xtra_data, total part = %d, len = %d \n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len);
if (part < total_parts)
{
// No callback in this case
rpc_ret_val = loc_ioctl (loc_eng_data.client_handle,
RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
&ioctl_data);
if (rpc_ret_val != RPC_LOC_API_SUCCESS)
{
LOGE ("loc_ioctl for xtra returned %d \n", rpc_ret_val);
ret_val = EINVAL; // return error
break;
}
}
else // part == total_parts
{
// Last part injection, will need to wait for callback
ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
&ioctl_data,
LOC_XTRA_INJECT_DEFAULT_TIMEOUT,
NULL /* No output information is expected*/);
break; // done with injection
}
len_injected += predicted_orbits_data_ptr->part_len;
LOGV ("loc_ioctl for xtra len injected %d \n", len_injected);
}
return ret_val;
}

45
loc_api/libloc_api/loc_eng_xtra.h
View file

@ -1,45 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_XTRA_H
#define LOC_ENG_XTRA_H
#include <hardware/gps.h>
extern const GpsXtraInterface sLocEngXTRAInterface;
// Module data
typedef struct
{
// loc_eng_ioctl_cb_data_s_type ioctl_cb_data;
gps_xtra_download_request download_request_cb;
} loc_eng_xtra_data_s_type;
#endif // LOC_ENG_XTRA_H

125
loc_api/libloc_api_50001/Android.mk
View file

@ -1,125 +0,0 @@
ifneq ($(BUILD_TINY_ANDROID),true)
#Compile this library only for builds with the latest modem image
BIT_ENABLED_BOARD_PLATFORM_LIST := msm7630_fusion
BIT_ENABLED_BOARD_PLATFORM_LIST += msm8660
ifeq ($(call is-board-platform-in-list,$(BIT_ENABLED_BOARD_PLATFORM_LIST)),true)
FEATURE_GNSS_BIT_API := true
endif # is-board-platform-in-list
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_adapter
LOCAL_MODULE_TAGS := optional
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
libgps.utils \
libdl
LOCAL_SRC_FILES += \
loc_eng_log.cpp \
LocApiAdapter.cpp
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_
LOCAL_C_INCLUDES:= \
$(TARGET_OUT_HEADERS)/gps.utils
LOCAL_COPY_HEADERS_TO:= libloc_eng/
LOCAL_COPY_HEADERS:= \
LocApiAdapter.h \
loc.h \
loc_eng.h \
loc_eng_xtra.h \
loc_eng_ni.h \
loc_eng_agps.h \
loc_eng_msg.h \
loc_eng_msg_id.h \
loc_eng_log.h
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_eng
LOCAL_MODULE_TAGS := optional
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
libloc_adapter \
libgps.utils \
libdl
LOCAL_SRC_FILES += \
loc_eng.cpp \
loc_eng_agps.cpp \
loc_eng_xtra.cpp \
loc_eng_ni.cpp \
loc_eng_log.cpp
ifeq ($(FEATURE_GNSS_BIT_API), true)
LOCAL_CFLAGS += -DFEATURE_GNSS_BIT_API
endif # FEATURE_GNSS_BIT_API
LOCAL_SRC_FILES += \
loc_eng_dmn_conn.cpp \
loc_eng_dmn_conn_handler.cpp \
loc_eng_dmn_conn_thread_helper.c \
loc_eng_dmn_conn_glue_msg.c \
loc_eng_dmn_conn_glue_pipe.c
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_
LOCAL_C_INCLUDES:= \
$(TARGET_OUT_HEADERS)/gps.utils \
hardware/qcom/gps/loc_api/ulp/inc
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
LOCAL_MODULE_TAGS := optional
## Libs
LOCAL_SHARED_LIBRARIES := \
libutils \
libcutils \
libloc_eng \
libgps.utils
LOCAL_SRC_FILES += \
loc.cpp \
gps.c
LOCAL_CFLAGS += \
-fno-short-enums \
-D_ANDROID_ \
## Includes
LOCAL_C_INCLUDES:= \
$(TARGET_OUT_HEADERS)/gps.utils
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
include $(BUILD_SHARED_LIBRARY)
endif # not BUILD_TINY_ANDROID

226
loc_api/libloc_api_50001/LocApiAdapter.cpp
View file

@ -1,226 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_adapter"
#include <dlfcn.h>
#include <LocApiAdapter.h>
#include "loc_eng_msg.h"
#include "loc_log.h"
#include "loc_eng_ni.h"
static void* noProc(void* data)
{
return NULL;
}
LocEng::LocEng(void* caller,
LOC_API_ADAPTER_EVENT_MASK_T emask,
gps_acquire_wakelock acqwl,
gps_release_wakelock relwl,
loc_msg_sender msgSender,
loc_ext_parser posParser,
loc_ext_parser svParser) :
owner(caller),
eventMask(emask), acquireWakelock(acqwl),
releaseWakeLock(relwl), sendMsge(msgSender),
extPosInfo(NULL == posParser ? noProc : posParser),
extSvInfo(NULL == svParser ? noProc : svParser)
{
LOC_LOGV("LocEng constructor %p, %p", posParser, svParser);
}
LocApiAdapter::LocApiAdapter(LocEng &locEng) :
locEngHandle(locEng)
{
LOC_LOGD("LocApiAdapter created");
}
LocApiAdapter::~LocApiAdapter()
{
LOC_LOGV("LocApiAdapter deleted");
}
LocApiAdapter* LocApiAdapter::getLocApiAdapter(LocEng &locEng)
{
void* handle;
LocApiAdapter* adapter = NULL;
handle = dlopen ("libloc_api_v02.so", RTLD_NOW);
if (!handle) {
LOC_LOGI("%s: dlopen(libloc_api_v02.so) failed, trying to load libloc_api-rpc-qc.so", __FUNCTION__);
handle = dlopen ("libloc_api-rpc-qc.so", RTLD_NOW);
}
else
LOC_LOGE("%s: dlopen(libloc_api_v02.so) succeeded.", __FUNCTION__);
if (!handle) {
LOC_LOGI("%s: dlopen(libloc_api-rpc-qc.so) failed, constructing LocApiAdapter", __FUNCTION__);
adapter = new LocApiAdapter(locEng);
} else {
getLocApiAdapter_t* getHandle = (getLocApiAdapter_t*)dlsym(handle, "getLocApiAdapter");
if (!getHandle) {
LOC_LOGE("%s: dlsym(getLocApiAdapter) failed", __FUNCTION__);
return NULL;
}
adapter = (*getHandle)(locEng);
}
return adapter;
}
int LocApiAdapter::hexcode(char *hexstring, int string_size,
const char *data, int data_size)
{
int i;
for (i = 0; i < data_size; i++)
{
char ch = data[i];
if (i*2 + 3 <= string_size)
{
snprintf(&hexstring[i*2], 3, "%02X", ch);
}
else {
break;
}
}
return i;
}
int LocApiAdapter::decodeAddress(char *addr_string, int string_size,
const char *data, int data_size)
{
const char addr_prefix = 0x91;
int i, idxOutput = 0;
if (!data || !addr_string) { return 0; }
if (data[0] != addr_prefix)
{
LOC_LOGW("decodeAddress: address prefix is not 0x%x but 0x%x", addr_prefix, data[0]);
addr_string[0] = '\0';
return 0; // prefix not correct
}
for (i = 1; i < data_size; i++)
{
unsigned char ch = data[i], low = ch & 0x0F, hi = ch >> 4;
if (low <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = low + '0'; }
if (hi <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = hi + '0'; }
}
addr_string[idxOutput] = '\0'; // Terminates the string
return idxOutput;
}
void LocApiAdapter::reportPosition(GpsLocation &location,
void* locationExt,
enum loc_sess_status status)
{
loc_eng_msg_report_position *msg(new loc_eng_msg_report_position(locEngHandle.owner,
location,
locationExt,
status));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::reportSv(GpsSvStatus &svStatus, void* svExt)
{
loc_eng_msg_report_sv *msg(new loc_eng_msg_report_sv(locEngHandle.owner, svStatus, svExt));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::reportStatus(GpsStatusValue status)
{
loc_eng_msg_report_status *msg(new loc_eng_msg_report_status(locEngHandle.owner, status));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::reportNmea(const char* nmea, int length)
{
loc_eng_msg_report_nmea *msg(new loc_eng_msg_report_nmea(locEngHandle.owner, nmea, length));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::requestATL(int connHandle, AGpsType agps_type)
{
loc_eng_msg_request_atl *msg(new loc_eng_msg_request_atl(locEngHandle.owner, connHandle, agps_type));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::releaseATL(int connHandle)
{
loc_eng_msg_release_atl *msg(new loc_eng_msg_release_atl(locEngHandle.owner, connHandle));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::requestXtraData()
{
LOC_LOGD("XTRA download request");
loc_eng_msg *msg(new loc_eng_msg(locEngHandle.owner, LOC_ENG_MSG_REQUEST_XTRA_DATA));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::requestTime()
{
LOC_LOGD("loc_event_cb: XTRA time download request... not supported");
// loc_eng_msg *msg(new loc_eng_msg(locEngHandle.owner, LOC_ENG_MSG_REQUEST_TIME));
// locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::requestLocation()
{
LOC_LOGD("loc_event_cb: XTRA time download request... not supported");
// loc_eng_msg *msg(new loc_eng_msg(locEngHandle.owner, LOC_ENG_MSG_REQUEST_POSITION));
// locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::requestNiNotify(GpsNiNotification &notif, const void* data)
{
notif.size = sizeof(notif);
notif.timeout = LOC_NI_NO_RESPONSE_TIME;
loc_eng_msg_request_ni *msg(new loc_eng_msg_request_ni(locEngHandle.owner, notif, data));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::handleEngineDownEvent()
{
loc_eng_msg *msg(new loc_eng_msg(locEngHandle.owner, LOC_ENG_MSG_ENGINE_DOWN));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}
void LocApiAdapter::handleEngineUpEvent()
{
loc_eng_msg *msg(new loc_eng_msg(locEngHandle.owner, LOC_ENG_MSG_ENGINE_UP));
locEngHandle.sendMsge(locEngHandle.owner, msg);
}

208
loc_api/libloc_api_50001/LocApiAdapter.h
View file

@ -1,208 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_API_ADAPTER_H
#define LOC_API_ADAPTER_H
#include <ctype.h>
#include <hardware/gps.h>
#include <loc.h>
#include <log_util.h>
#define MIN_POSSIBLE_FIX_INTERVAL 1000 /* msec */
enum loc_api_adapter_err {
LOC_API_ADAPTER_ERR_SUCCESS = 0,
LOC_API_ADAPTER_ERR_GENERAL_FAILURE = 1,
LOC_API_ADAPTER_ERR_UNSUPPORTED = 2,
LOC_API_ADAPTER_ERR_INVALID_HANDLE = 4,
LOC_API_ADAPTER_ERR_INVALID_PARAMETER = 5,
LOC_API_ADAPTER_ERR_ENGINE_BUSY = 6,
LOC_API_ADAPTER_ERR_PHONE_OFFLINE = 7,
LOC_API_ADAPTER_ERR_TIMEOUT = 8,
LOC_API_ADAPTER_ERR_SERVICE_NOT_PRESENT = 9,
LOC_API_ADAPTER_ERR_ENGINE_DOWN = 100,
LOC_API_ADAPTER_ERR_FAILURE,
LOC_API_ADAPTER_ERR_UNKNOWN
};
enum loc_api_adapter_event_index {
LOC_API_ADAPTER_REPORT_POSITION = 0, // Position report comes in loc_parsed_position_s_type
LOC_API_ADAPTER_REPORT_SATELLITE, // Satellite in view report
LOC_API_ADAPTER_REPORT_NMEA_1HZ, // NMEA report at 1HZ rate
LOC_API_ADAPTER_REPORT_NMEA_POSITION, // NMEA report at position report rate
LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY, // NI notification/verification request
LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA, // Assistance data, eg: time, predicted orbits request
LOC_API_ADAPTER_REQUEST_LOCATION_SERVER, // Request for location server
LOC_API_ADAPTER_REPORT_IOCTL, // Callback report for loc_ioctl
LOC_API_ADAPTER_REPORT_STATUS, // Misc status report: eg, engine state
LOC_API_ADAPTER_EVENT_MAX
};
#define LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT (1<<LOC_API_ADAPTER_REPORT_POSITION)
#define LOC_API_ADAPTER_BIT_SATELLITE_REPORT (1<<LOC_API_ADAPTER_REPORT_SATELLITE)
#define LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT (1<<LOC_API_ADAPTER_REPORT_NMEA_1HZ)
#define LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT (1<<LOC_API_ADAPTER_REPORT_NMEA_POSITION)
#define LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST (1<<LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY)
#define LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST (1<<LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA)
#define LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST (1<<LOC_API_ADAPTER_REQUEST_LOCATION_SERVER)
#define LOC_API_ADAPTER_BIT_IOCTL_REPORT (1<<LOC_API_ADAPTER_REPORT_IOCTL)
#define LOC_API_ADAPTER_BIT_STATUS_REPORT (1<<LOC_API_ADAPTER_REPORT_STATUS)
typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp);
struct LocEng {
void* owner;
LOC_API_ADAPTER_EVENT_MASK_T eventMask;
const gps_acquire_wakelock acquireWakelock;
const gps_release_wakelock releaseWakeLock;
const loc_msg_sender sendMsge;
const loc_ext_parser extPosInfo;
const loc_ext_parser extSvInfo;
LocEng(void* caller,
LOC_API_ADAPTER_EVENT_MASK_T emask,
gps_acquire_wakelock acqwl,
gps_release_wakelock relwl,
loc_msg_sender msgSender,
loc_ext_parser posParser,
loc_ext_parser svParser);
};
class LocApiAdapter {
protected:
const LocEng locEngHandle;
LocApiAdapter(LocEng &locEng);
public:
//LocApiAdapter(int q, reportCb_t[LOC_API_ADAPTER_EVENT_MAX] callbackTable);
virtual ~LocApiAdapter();
static LocApiAdapter* getLocApiAdapter(LocEng &locEng);
static int hexcode(char *hexstring, int string_size,
const char *data, int data_size);
static int decodeAddress(char *addr_string, int string_size,
const char *data, int data_size);
void reportPosition(GpsLocation &location,
void* locationExt,
enum loc_sess_status status);
void reportSv(GpsSvStatus &svStatus, void* svExt);
void reportStatus(GpsStatusValue status);
void reportNmea(const char* nmea, int length);
void reportAgpsStatus(AGpsStatus &agpsStatus);
void requestXtraData();
void requestTime();
void requestLocation();
void requestATL(int connHandle, AGpsType agps_type);
void releaseATL(int connHandle);
void requestNiNotify(GpsNiNotification &notify, const void* data);
void handleEngineDownEvent();
void handleEngineUpEvent();
// All below functions are to be defined by adapter specific modules:
// RPC, QMI, etc. The default implementation is empty.
inline virtual enum loc_api_adapter_err
reinit()
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
startFix()
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
stopFix()
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
deleteAidingData(GpsAidingData f)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
enableData(int enable)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setAPN(char* apn, int len)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
injectPosition(double latitude, double longitude, float accuracy)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setXtraData(char* data, int length)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
#ifdef QCOM_FEATURE_IPV6
inline virtual enum loc_api_adapter_err
atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
#else
inline virtual enum loc_api_adapter_err
atlOpenStatus(int handle, int is_succ, char* apn, AGpsType agpsType)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
#endif
inline virtual enum loc_api_adapter_err
atlCloseStatus(int handle, int is_succ)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setPositionMode(LocPositionMode mode, GpsPositionRecurrence recurrence,
uint32_t min_interval, uint32_t preferred_accuracy,
uint32_t preferred_time)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setServer(const char* url, int len)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setServer(unsigned int ip, int port,
LocServerType type)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
informNiResponse(GpsUserResponseType userResponse, const void* passThroughData)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setSUPLVersion(uint32_t version)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setSensorControlConfig(int sensorUsage)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setSensorProperties(float gyroBiasVarianceRandomWalk)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
inline virtual enum loc_api_adapter_err
setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec,
int gyroSamplesPerBatch, int gyroBatchesPerSec)
{LOC_LOGW("%s: default implementation invoked", __func__); return LOC_API_ADAPTER_ERR_SUCCESS;}
};
extern "C" LocApiAdapter* getLocApiAdapter(LocEng &locEng);
typedef LocApiAdapter* (getLocApiAdapter_t)(LocEng&);
#endif //LOC_API_RPC_ADAPTER_H

68
loc_api/libloc_api_50001/gps.c
View file

@ -1,68 +0,0 @@
/* Copyright (c) 2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <hardware/gps.h>
#include <stdlib.h>
extern const GpsInterface* get_gps_interface();
const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)
{
return get_gps_interface();
}
static int open_gps(const struct hw_module_t* module, char const* name,
struct hw_device_t** device)
{
struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t));
memset(dev, 0, sizeof(*dev));
dev->common.tag = HARDWARE_DEVICE_TAG;
dev->common.version = 0;
dev->common.module = (struct hw_module_t*)module;
dev->get_gps_interface = gps__get_gps_interface;
*device = (struct hw_device_t*)dev;
return 0;
}
static struct hw_module_methods_t gps_module_methods = {
.open = open_gps
};
struct hw_module_t HAL_MODULE_INFO_SYM = {
.tag = HARDWARE_MODULE_TAG,
.module_api_version = 1,
.hal_api_version = 0,
.id = GPS_HARDWARE_MODULE_ID,
.name = "loc_api GPS Module",
.author = "Qualcomm USA, Inc.",
.methods = &gps_module_methods,
};

870
loc_api/libloc_api_50001/loc.cpp
View file

@ -1,870 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_afw"
#include <hardware/gps.h>
#include <loc_eng.h>
#include <loc_log.h>
static gps_location_callback gps_loc_cb = NULL;
static gps_sv_status_callback gps_sv_cb = NULL;
static void loc_cb(GpsLocation* location, void* locExt);
static void sv_cb(GpsSvStatus* sv_status, void* svExt);
// Function declarations for sLocEngInterface
static int loc_init(GpsCallbacks* callbacks);
static int loc_start();
static int loc_stop();
static void loc_cleanup();
static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
static int loc_inject_location(double latitude, double longitude, float accuracy);
static void loc_delete_aiding_data(GpsAidingData f);
static int loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
uint32_t min_interval, uint32_t preferred_accuracy,
uint32_t preferred_time);
static const void* loc_get_extension(const char* name);
#ifdef QCOM_FEATURE_ULP
static int loc_update_criteria(UlpLocationCriteria criteria);
#endif
// Defines the GpsInterface in gps.h
static const GpsInterface sLocEngInterface =
{
sizeof(GpsInterface),
loc_init,
loc_start,
loc_stop,
loc_cleanup,
loc_inject_time,
loc_inject_location,
loc_delete_aiding_data,
loc_set_position_mode,
loc_get_extension
#ifdef QCOM_FEATURE_ULP
,loc_update_criteria
#endif
};
// Function declarations for sLocEngAGpsInterface
static void loc_agps_init(AGpsCallbacks* callbacks);
#ifdef QCOM_FEATURE_IPV6
static int loc_agps_open(AGpsType agpsType,
const char* apn, AGpsBearerType bearerType);
static int loc_agps_closed(AGpsType agpsType);
static int loc_agps_open_failed(AGpsType agpsType);
#else
static int loc_agps_open(const char* apn);
static int loc_agps_closed();
static int loc_agps_open_failed();
#endif
static int loc_agps_set_server(AGpsType type, const char *hostname, int port);
static const AGpsInterface sLocEngAGpsInterface =
{
sizeof(AGpsInterface),
loc_agps_init,
loc_agps_open,
loc_agps_closed,
loc_agps_open_failed,
loc_agps_set_server
};
static int loc_xtra_init(GpsXtraCallbacks* callbacks);
static int loc_xtra_inject_data(char* data, int length);
static const GpsXtraInterface sLocEngXTRAInterface =
{
sizeof(GpsXtraInterface),
loc_xtra_init,
loc_xtra_inject_data
};
static void loc_ni_init(GpsNiCallbacks *callbacks);
static void loc_ni_respond(int notif_id, GpsUserResponseType user_response);
const GpsNiInterface sLocEngNiInterface =
{
sizeof(GpsNiInterface),
loc_ni_init,
loc_ni_respond,
};
static void loc_agps_ril_init( AGpsRilCallbacks* callbacks );
static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid);
static void loc_agps_ril_ni_message(uint8_t *msg, size_t len);
static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info);
static void loc_agps_ril_update_network_availability(int avaiable, const char* apn);
static const AGpsRilInterface sLocEngAGpsRilInterface =
{
sizeof(AGpsRilInterface),
loc_agps_ril_init,
loc_agps_ril_set_ref_location,
loc_agps_ril_set_set_id,
loc_agps_ril_ni_message,
loc_agps_ril_update_network_state,
loc_agps_ril_update_network_availability
};
#ifdef QCOM_FEATURE_ULP
static bool loc_inject_raw_command(char* command, int length);
static const InjectRawCmdInterface sLocEngInjectRawCmdInterface =
{
sizeof(InjectRawCmdInterface),
loc_inject_raw_command
};
#endif
static loc_eng_data_s_type loc_afw_data;
/*===========================================================================
FUNCTION gps_get_hardware_interface
DESCRIPTION
Returns the GPS hardware interaface based on LOC API
if GPS is enabled.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
const GpsInterface* gps_get_hardware_interface ()
{
ENTRY_LOG_CALLFLOW();
const GpsInterface* ret_val;
char propBuf[PROPERTY_VALUE_MAX];
// check to see if GPS should be disabled
property_get("gps.disable", propBuf, "");
if (propBuf[0] == '1')
{
LOC_LOGD("gps_get_interface returning NULL because gps.disable=1\n");
ret_val = NULL;
} else {
ret_val = &sLocEngInterface;
}
EXIT_LOG(%p, ret_val);
return ret_val;
}
// for gps.c
extern "C" const GpsInterface* get_gps_interface()
{
return &sLocEngInterface;
}
/*===========================================================================
FUNCTION loc_init
DESCRIPTION
Initialize the location engine, this include setting up global datas
and registers location engien with loc api service.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/Ax
===========================================================================*/
static int loc_init(GpsCallbacks* callbacks)
{
ENTRY_LOG();
LOC_API_ADAPTER_EVENT_MASK_T event =
LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
LOC_API_ADAPTER_BIT_IOCTL_REPORT |
LOC_API_ADAPTER_BIT_STATUS_REPORT |
LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
LocCallbacks clientCallbacks = {loc_cb, /* location_cb */
callbacks->status_cb, /* status_cb */
sv_cb, /* sv_status_cb */
callbacks->nmea_cb, /* nmea_cb */
callbacks->set_capabilities_cb, /* set_capabilities_cb */
callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */
callbacks->release_wakelock_cb, /* release_wakelock_cb */
callbacks->create_thread_cb, /* create_thread_cb */
NULL, /* location_ext_parser */
NULL /* sv_ext_parser */};
gps_loc_cb = callbacks->location_cb;
gps_sv_cb = callbacks->sv_status_cb;
int ret_val = loc_eng_init(loc_afw_data, &clientCallbacks, event);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_cleanup
DESCRIPTION
Cleans location engine. The location client handle will be released.
DEPENDENCIES
None
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_cleanup()
{
ENTRY_LOG();
loc_eng_cleanup(loc_afw_data);
gps_loc_cb = NULL;
gps_sv_cb = NULL;
EXIT_LOG(%s, VOID_RET);
}
/*===========================================================================
FUNCTION loc_start
DESCRIPTION
Starts the tracking session
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_start()
{
ENTRY_LOG();
int ret_val = loc_eng_start(loc_afw_data);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_stop
DESCRIPTION
Stops the tracking session
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_stop()
{
ENTRY_LOG();
int ret_val = loc_eng_stop(loc_afw_data);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_set_position_mode
DESCRIPTION
Sets the mode and fix frequency for the tracking session.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_set_position_mode(GpsPositionMode mode,
GpsPositionRecurrence recurrence,
uint32_t min_interval,
uint32_t preferred_accuracy,
uint32_t preferred_time)
{
ENTRY_LOG();
LocPositionMode locMode;
switch (mode) {
case GPS_POSITION_MODE_MS_BASED:
locMode = LOC_POSITION_MODE_MS_BASED;
break;
case GPS_POSITION_MODE_MS_ASSISTED:
locMode = LOC_POSITION_MODE_MS_ASSISTED;
break;
default:
locMode = LOC_POSITION_MODE_STANDALONE;
break;
}
int ret_val = loc_eng_set_position_mode(loc_afw_data, locMode,
recurrence, min_interval,
preferred_accuracy, preferred_time);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_inject_time
DESCRIPTION
This is used by Java native function to do time injection.
DEPENDENCIES
None
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty)
{
ENTRY_LOG();
int ret_val = loc_eng_inject_time(loc_afw_data, time, timeReference, uncertainty);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_inject_location
DESCRIPTION
This is used by Java native function to do location injection.
DEPENDENCIES
None
RETURN VALUE
0 : Successful
error code : Failure
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_inject_location(double latitude, double longitude, float accuracy)
{
ENTRY_LOG();
int ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_delete_aiding_data
DESCRIPTION
This is used by Java native function to delete the aiding data. The function
updates the global variable for the aiding data to be deleted. If the GPS
engine is off, the aiding data will be deleted. Otherwise, the actual action
will happen when gps engine is turned off.
DEPENDENCIES
Assumes the aiding data type specified in GpsAidingData matches with
LOC API specification.
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_delete_aiding_data(GpsAidingData f)
{
ENTRY_LOG();
loc_eng_delete_aiding_data(loc_afw_data, f);
EXIT_LOG(%s, VOID_RET);
}
#ifdef QCOM_FEATURE_ULP
/*===========================================================================
FUNCTION loc_update_criteria
DESCRIPTION
This is used to inform the ULP module of new unique criteria that are passed
in by the applications
DEPENDENCIES
N/A
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_update_criteria(UlpLocationCriteria criteria)
{
ENTRY_LOG();
int ret_val = loc_eng_update_criteria(loc_afw_data, criteria);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#endif
/*===========================================================================
FUNCTION loc_get_extension
DESCRIPTION
Get the gps extension to support XTRA.
DEPENDENCIES
N/A
RETURN VALUE
The GPS extension interface.
SIDE EFFECTS
N/A
===========================================================================*/
static const void* loc_get_extension(const char* name)
{
ENTRY_LOG();
const void* ret_val = NULL;
if (strcmp(name, GPS_XTRA_INTERFACE) == 0)
{
ret_val = &sLocEngXTRAInterface;
}
else if (strcmp(name, AGPS_INTERFACE) == 0)
{
ret_val = &sLocEngAGpsInterface;
}
else if (strcmp(name, GPS_NI_INTERFACE) == 0)
{
ret_val = &sLocEngNiInterface;
}
else if (strcmp(name, AGPS_RIL_INTERFACE) == 0)
{
ret_val = &sLocEngAGpsRilInterface;
}
#ifdef QCOM_FEATURE_ULP
else if (strcmp(name, ULP_RAW_CMD_INTERFACE) == 0)
{
ret_val = &sLocEngInjectRawCmdInterface;
}
#endif
else
{
LOC_LOGE ("get_extension: Invalid interface passed in\n");
}
EXIT_LOG(%p, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_agps_init
DESCRIPTION
Initialize the AGps interface.
DEPENDENCIES
NONE
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_agps_init(AGpsCallbacks* callbacks)
{
ENTRY_LOG();
loc_eng_agps_init(loc_afw_data, callbacks);
EXIT_LOG(%s, VOID_RET);
}
/*===========================================================================
FUNCTION loc_agps_open
DESCRIPTION
This function is called when on-demand data connection opening is successful.
It should inform ARM 9 about the data open result.
DEPENDENCIES
NONE
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
#ifdef QCOM_FEATURE_IPV6
static int loc_agps_open(AGpsType agpsType,
const char* apn, AGpsBearerType bearerType)
{
ENTRY_LOG();
int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#else
static int loc_agps_open(const char* apn)
{
ENTRY_LOG();
int ret_val = loc_eng_agps_open(loc_afw_data, apn);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#endif
/*===========================================================================
FUNCTION loc_agps_closed
DESCRIPTION
This function is called when on-demand data connection closing is done.
It should inform ARM 9 about the data close result.
DEPENDENCIES
NONE
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
#ifdef QCOM_FEATURE_IPV6
static int loc_agps_closed(AGpsType agpsType)
{
ENTRY_LOG();
int ret_val = loc_eng_agps_closed(loc_afw_data, agpsType);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#else
static int loc_agps_closed()
{
ENTRY_LOG();
int ret_val = loc_eng_agps_closed(loc_afw_data);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#endif
/*===========================================================================
FUNCTION loc_agps_open_failed
DESCRIPTION
This function is called when on-demand data connection opening has failed.
It should inform ARM 9 about the data open result.
DEPENDENCIES
NONE
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
#ifdef QCOM_FEATURE_IPV6
int loc_agps_open_failed(AGpsType agpsType)
{
ENTRY_LOG();
int ret_val = loc_eng_agps_open_failed(loc_afw_data, agpsType);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#else
int loc_agps_open_failed()
{
ENTRY_LOG();
int ret_val = loc_eng_agps_open_failed(loc_afw_data);
EXIT_LOG(%d, ret_val);
return ret_val;
}
#endif
/*===========================================================================
FUNCTION loc_agps_set_server
DESCRIPTION
If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
proxy buffers server settings and calls loc_eng_set_server when the client is
open.
DEPENDENCIES
NONE
RETURN VALUE
0
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_agps_set_server(AGpsType type, const char* hostname, int port)
{
ENTRY_LOG();
LocServerType serverType;
switch (type) {
case AGPS_TYPE_SUPL:
serverType = LOC_AGPS_SUPL_SERVER;
break;
case AGPS_TYPE_C2K:
serverType = LOC_AGPS_CDMA_PDE_SERVER;
break;
}
int ret_val = loc_eng_set_server_proxy(loc_afw_data, serverType, hostname, port);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_xtra_init
DESCRIPTION
Initialize XTRA module.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_xtra_init(GpsXtraCallbacks* callbacks)
{
ENTRY_LOG();
int ret_val = loc_eng_xtra_init(loc_afw_data, callbacks);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_xtra_inject_data
DESCRIPTION
Initialize XTRA module.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_xtra_inject_data(char* data, int length)
{
ENTRY_LOG();
int ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_ni_init
DESCRIPTION
This function initializes the NI interface
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_ni_init(GpsNiCallbacks *callbacks)
{
ENTRY_LOG();
loc_eng_ni_init(loc_afw_data, callbacks);
EXIT_LOG(%s, VOID_RET);
}
/*===========================================================================
FUNCTION loc_ni_respond
DESCRIPTION
This function sends an NI respond to the modem processor
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_ni_respond(int notif_id, GpsUserResponseType user_response)
{
ENTRY_LOG();
loc_eng_ni_respond(loc_afw_data, notif_id, user_response);
EXIT_LOG(%s, VOID_RET);
}
// Below stub functions are members of sLocEngAGpsRilInterface
static void loc_agps_ril_init( AGpsRilCallbacks* callbacks ) {}
static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct) {}
static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid) {}
static void loc_agps_ril_ni_message(uint8_t *msg, size_t len) {}
static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info) {}
/*===========================================================================
FUNCTION loc_agps_ril_update_network_availability
DESCRIPTION
Sets data call allow vs disallow flag to modem
This is the only member of sLocEngAGpsRilInterface implemented.
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_agps_ril_update_network_availability(int available, const char* apn)
{
ENTRY_LOG();
loc_eng_agps_ril_update_network_availability(loc_afw_data, available, apn);
EXIT_LOG(%s, VOID_RET);
}
#ifdef QCOM_FEATURE_ULP
/*===========================================================================
FUNCTION loc_inject_raw_command
DESCRIPTION
This is used to send special test modem commands from the applications
down into the HAL
DEPENDENCIES
N/A
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
static bool loc_inject_raw_command(char* command, int length)
{
ENTRY_LOG();
int ret_val = loc_eng_inject_raw_command(loc_afw_data, command, length);
EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
return ret_val;
}
#endif
static void loc_cb(GpsLocation* location, void* locExt)
{
ENTRY_LOG();
if (NULL != gps_loc_cb && NULL != location) {
#ifdef QCOM_FEATURE_ULP
CALLBACK_LOG_CALLFLOW("location_cb - from", %d, location->position_source);
#else
CALLBACK_LOG_CALLFLOW("location_cb - at", %llu, location->timestamp);
#endif
gps_loc_cb(location);
}
EXIT_LOG(%s, VOID_RET);
}
static void sv_cb(GpsSvStatus* sv_status, void* svExt)
{
ENTRY_LOG();
if (NULL != gps_sv_cb) {
CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs);
gps_sv_cb(sv_status);
}
EXIT_LOG(%s, VOID_RET);
}

86
loc_api/libloc_api_50001/loc.h
View file

@ -1,86 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef __LOC_H__
#define __LOC_H__
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <ctype.h>
#include <cutils/properties.h>
#include <hardware/gps.h>
typedef enum loc_server_type {
LOC_AGPS_CDMA_PDE_SERVER,
LOC_AGPS_CUSTOM_PDE_SERVER,
LOC_AGPS_MPC_SERVER,
LOC_AGPS_SUPL_SERVER
} LocServerType;
typedef enum loc_position_mode_type {
LOC_POSITION_MODE_STANDALONE,
LOC_POSITION_MODE_MS_BASED,
LOC_POSITION_MODE_MS_ASSISTED,
LOC_POSITION_MODE_RESERVED_1,
LOC_POSITION_MODE_RESERVED_2,
LOC_POSITION_MODE_RESERVED_3,
LOC_POSITION_MODE_RESERVED_4
} LocPositionMode;
typedef void (*loc_location_cb_ext) (GpsLocation* location, void* locExt);
typedef void (*loc_sv_status_cb_ext) (GpsSvStatus* sv_status, void* svExt);
typedef void* (*loc_ext_parser)(void* data);
typedef struct {
loc_location_cb_ext location_cb;
gps_status_callback status_cb;
loc_sv_status_cb_ext sv_status_cb;
gps_nmea_callback nmea_cb;
gps_set_capabilities set_capabilities_cb;
gps_acquire_wakelock acquire_wakelock_cb;
gps_release_wakelock release_wakelock_cb;
gps_create_thread create_thread_cb;
loc_ext_parser location_ext_parser;
loc_ext_parser sv_ext_parser;
} LocCallbacks;
enum loc_sess_status {
LOC_SESS_SUCCESS,
LOC_SESS_INTERMEDIATE,
LOC_SESS_FAILURE
};
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif //__LOC_H__

1831
loc_api/libloc_api_50001/loc_eng.cpp
View file

File diff suppressed because it is too large Load diff

204
loc_api/libloc_api_50001/loc_eng.h
View file

@ -1,204 +0,0 @@
/* Copyright (c) 2009,2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_H
#define LOC_ENG_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
// Uncomment to keep all LOG messages (LOGD, LOGI, LOGV, etc.)
#define MAX_NUM_ATL_CONNECTIONS 2
// Define boolean type to be used by libgps on loc api module
typedef unsigned char boolean;
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#include <loc.h>
#include <loc_eng_xtra.h>
#include <loc_eng_ni.h>
#include <loc_eng_agps.h>
#include <loc_cfg.h>
#include <loc_log.h>
#include <log_util.h>
#include <loc_eng_msg.h>
#include <loc_eng_agps.h>
#include <LocApiAdapter.h>
// The data connection minimal open time
#define DATA_OPEN_MIN_TIME 1 /* sec */
// The system sees GPS engine turns off after inactive for this period of time
#define GPS_AUTO_OFF_TIME 2 /* secs */
#define SUCCESS TRUE
#define FAILURE FALSE
#define INVALID_ATL_CONNECTION_HANDLE -1
#define MAX_APN_LEN 100
#define MAX_URL_LEN 256
#define smaller_of(a, b) (((a) > (b)) ? (b) : (a))
enum loc_mute_session_e_type {
LOC_MUTE_SESS_NONE = 0,
LOC_MUTE_SESS_WAIT,
LOC_MUTE_SESS_IN_SESSION
};
// Module data
typedef struct
{
LocApiAdapter *client_handle;
loc_location_cb_ext location_cb;
gps_status_callback status_cb;
loc_sv_status_cb_ext sv_status_cb;
agps_status_callback agps_status_cb;
gps_nmea_callback nmea_cb;
gps_ni_notify_callback ni_notify_cb;
gps_acquire_wakelock acquire_wakelock_cb;
gps_release_wakelock release_wakelock_cb;
boolean intermediateFix;
AGpsStatusValue agps_status;
// used to defer stopping the GPS engine until AGPS data calls are done
boolean agps_request_pending;
boolean stop_request_pending;
loc_eng_xtra_data_s_type xtra_module_data;
loc_eng_ni_data_s_type loc_eng_ni_data;
boolean navigating;
// AGPS state machines
AgpsStateMachine* agnss_nif;
AgpsStateMachine* internet_nif;
// GPS engine status
GpsStatusValue engine_status;
GpsStatusValue fix_session_status;
// Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
GpsAidingData aiding_data_for_deletion;
void* context;
loc_eng_msg_position_mode position_mode;
// For muting session broadcast
loc_mute_session_e_type mute_session_state;
// Address buffers, for addressing setting before init
int supl_host_set;
char supl_host_buf[101];
int supl_port_buf;
int c2k_host_set;
char c2k_host_buf[101];
int c2k_port_buf;
int mpc_host_set;
char mpc_host_buf[101];
int mpc_port_buf;
} loc_eng_data_s_type;
int loc_eng_init(loc_eng_data_s_type &loc_eng_data,
LocCallbacks* callbacks,
LOC_API_ADAPTER_EVENT_MASK_T event);
int loc_eng_start(loc_eng_data_s_type &loc_eng_data);
int loc_eng_stop(loc_eng_data_s_type &loc_eng_data);
void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data);
int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data,
GpsUtcTime time, int64_t timeReference,
int uncertainty);
int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data,
double latitude, double longitude,
float accuracy);
void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data,
GpsAidingData f);
int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
LocPositionMode mode, GpsPositionRecurrence recurrence,
uint32_t min_interval, uint32_t preferred_accuracy,
uint32_t preferred_time);
const void* loc_eng_get_extension(loc_eng_data_s_type &loc_eng_data,
const char* name);
#ifdef QCOM_FEATURE_ULP
int loc_eng_update_criteria(loc_eng_data_s_type &loc_eng_data,
UlpLocationCriteria criteria);
#endif
void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data,
AGpsCallbacks* callbacks);
#ifdef QCOM_FEATURE_IPV6
int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType,
const char* apn, AGpsBearerType bearerType);
int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType);
int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType);
#else
int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, const char* apn);
int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data);
int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data);
#endif
int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
LocServerType type, const char *hostname, int port);
void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
int avaiable, const char* apn);
bool loc_eng_inject_raw_command(loc_eng_data_s_type &loc_eng_data,
char* command, int length);
void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data);
int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
GpsXtraCallbacks* callbacks);
int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
char* data, int length);
extern void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data,
GpsNiCallbacks *callbacks);
extern void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
int notif_id, GpsUserResponseType user_response);
extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
const GpsNiNotification *notif,
const void* passThrough);
extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif // LOC_ENG_H

702
loc_api/libloc_api_50001/loc_eng_agps.cpp
View file

@ -1,702 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_eng"
#include <loc_eng_agps.h>
#include <loc_eng_log.h>
#include <log_util.h>
#include <loc_eng_dmn_conn_handler.h>
#include <loc_eng_dmn_conn.h>
//======================================================================
// C callbacks
//======================================================================
// This is given to linked_list_add as the dealloc callback
// data -- an instance of Subscriber
static void deleteObj(void* data)
{
delete (Subscriber*)data;
}
// This is given to linked_list_search() as the comparison callback
// when the state manchine needs to process for particular subscriber
// fromCaller -- caller provides this obj
// fromList -- linked_list_search() function take this one from list
static bool hasSubscriber(void* fromCaller, void* fromList)
{
Notification* notification = (Notification*)fromCaller;
Subscriber* s1 = (Subscriber*)fromList;
return s1->forMe(*notification);
}
// This is gvien to linked_list_search() to notify subscriber objs
// when the state machine needs to inform all subscribers of resource
// status changes, e.g. when resource is GRANTED.
// fromCaller -- caller provides this ptr to a Notification obj.
// fromList -- linked_list_search() function take this one from list
static bool notifySubscriber(void* fromCaller, void* fromList)
{
Notification* notification = (Notification*)fromCaller;
Subscriber* s1 = (Subscriber*)fromList;
// we notify every subscriber indiscriminatively
// each subscriber decides if this notification is interesting.
return s1->notifyRsrcStatus(*notification) &&
// if we do not want to delete the subscriber from the
// the list, we must set this to false so this function
// returns false
notification->postNotifyDelete;
}
//======================================================================
// Notification
//======================================================================
const int Notification::BROADCAST_ALL = 0x80000000;
const int Notification::BROADCAST_ACTIVE = 0x80000001;
const int Notification::BROADCAST_INACTIVE = 0x80000002;
//======================================================================
// Subscriber: BITSubscriber / ATLSubscriber
//======================================================================
bool Subscriber::forMe(Notification &notification)
{
if (NULL != notification.rcver) {
return equals(notification.rcver);
} else {
return Notification::BROADCAST_ALL == notification.groupID ||
(Notification::BROADCAST_ACTIVE == notification.groupID &&
!isInactive()) ||
(Notification::BROADCAST_INACTIVE == notification.groupID &&
isInactive());
}
}
bool BITSubscriber::equals(const Subscriber *s) const
{
BITSubscriber* bitS = (BITSubscriber*)s;
return (ID == bitS->ID &&
(INADDR_NONE != (unsigned int)ID ||
0 == strncmp(ipv6Addr, bitS->ipv6Addr, sizeof(ipv6Addr))));
}
bool BITSubscriber::notifyRsrcStatus(Notification &notification)
{
bool notify = forMe(notification);
if (notify) {
switch(notification.rsrcStatus)
{
case RSRC_UNSUBSCRIBE:
case RSRC_RELEASED:
loc_eng_dmn_conn_loc_api_server_data_conn(
GPSONE_LOC_API_IF_RELEASE_SUCCESS);
break;
case RSRC_DENIED:
loc_eng_dmn_conn_loc_api_server_data_conn(
GPSONE_LOC_API_IF_FAILURE);
break;
case RSRC_GRANTED:
loc_eng_dmn_conn_loc_api_server_data_conn(
GPSONE_LOC_API_IF_REQUEST_SUCCESS);
break;
default:
notify = false;
}
}
return notify;
}
bool ATLSubscriber::notifyRsrcStatus(Notification &notification)
{
bool notify = forMe(notification);
if (notify) {
switch(notification.rsrcStatus)
{
case RSRC_UNSUBSCRIBE:
case RSRC_RELEASED:
((LocApiAdapter*)mLocAdapter)->atlCloseStatus(ID, 1);
break;
case RSRC_DENIED:
((LocApiAdapter*)mLocAdapter)->atlOpenStatus(ID, 0,
(char*)mStateMachine->getAPN(),
#ifdef QCOM_FEATURE_IPV6
mStateMachine->getBearer(),
#endif
mStateMachine->getType());
break;
case RSRC_GRANTED:
((LocApiAdapter*)mLocAdapter)->atlOpenStatus(ID, 1,
(char*)mStateMachine->getAPN(),
#ifdef QCOM_FEATURE_IPV6
mStateMachine->getBearer(),
#endif
mStateMachine->getType());
break;
default:
notify = false;
}
}
return notify;
}
//======================================================================
// AgpsState: AgpsReleasedState / AgpsPendingState / AgpsAcquiredState
//======================================================================
// AgpsReleasedState
class AgpsReleasedState : public AgpsState
{
friend class AgpsStateMachine;
inline AgpsReleasedState(AgpsStateMachine* stateMachine) :
AgpsState(stateMachine)
{ mReleasedState = this; }
inline ~AgpsReleasedState() {}
public:
virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
inline virtual char* whoami() {return (char*)"AgpsReleasedState";}
};
AgpsState* AgpsReleasedState::onRsrcEvent(AgpsRsrcStatus event, void* data)
{
if (mStateMachine->hasSubscribers()) {
LOC_LOGE("Error: %s subscriber list not empty!!!", whoami());
// I don't know how to recover from it. I am adding this rather
// for debugging purpose.
}
AgpsState* nextState = this;;
switch (event)
{
case RSRC_SUBSCRIBE:
{
// no notification until we get RSRC_GRANTED
// but we need to add subscriber to the list
mStateMachine->addSubscriber((Subscriber*)data);
// move the state to PENDING
nextState = mPendingState;
// request from connecivity service for NIF
mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN);
}
break;
case RSRC_UNSUBSCRIBE:
{
// the list should really be empty, nothing to remove.
// but we might as well just tell the client it is
// unsubscribed. False tolerance, right?
Subscriber* subscriber = (Subscriber*) data;
Notification notification(subscriber, event, false);
subscriber->notifyRsrcStatus(notification);
}
// break;
case RSRC_GRANTED:
case RSRC_RELEASED:
case RSRC_DENIED:
default:
LOC_LOGW("%s: unrecognized event %d", whoami(), event);
// no state change.
break;
}
LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
whoami(), nextState->whoami(), event);
return nextState;
}
// AgpsPendingState
class AgpsPendingState : public AgpsState
{
friend class AgpsStateMachine;
inline AgpsPendingState(AgpsStateMachine* stateMachine) :
AgpsState(stateMachine)
{ mPendingState = this; }
inline ~AgpsPendingState() {}
public:
virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
inline virtual char* whoami() {return (char*)"AgpsPendingState";}
};
AgpsState* AgpsPendingState::onRsrcEvent(AgpsRsrcStatus event, void* data)
{
AgpsState* nextState = this;;
switch (event)
{
case RSRC_SUBSCRIBE:
{
// already requested for NIF resource,
// do nothing until we get RSRC_GRANTED indication
// but we need to add subscriber to the list
mStateMachine->addSubscriber((Subscriber*)data);
// no state change.
}
break;
case RSRC_UNSUBSCRIBE:
{
Subscriber* subscriber = (Subscriber*) data;
if (subscriber->waitForCloseComplete()) {
subscriber->setInactive();
if (!mStateMachine->hasActiveSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasingState;
}
} else {
// auto notify this subscriber of the unsubscribe
Notification notification(subscriber, event, true);
mStateMachine->notifySubscribers(notification);
// now check if there is any subscribers left
if (!mStateMachine->hasSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasedState;
// tell connecivity service we can release NIF
mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN);
}
}
}
break;
case RSRC_GRANTED:
{
nextState = mAcquiredState;
Notification notification(Notification::BROADCAST_ACTIVE, event, false);
// notify all subscribers NIF resource GRANTED
// by setting false, we keep subscribers on the linked list
mStateMachine->notifySubscribers(notification);
}
break;
case RSRC_RELEASED:
// no state change.
// we are expecting either GRANTED or DENIED. Handling RELEASED
// may like break our state machine in race conditions.
break;
case RSRC_DENIED:
{
nextState = mReleasedState;
Notification notification(Notification::BROADCAST_ALL, event, true);
// notify all subscribers NIF resource RELEASED or DENIED
// by setting true, we remove subscribers from the linked list
mStateMachine->notifySubscribers(notification);
}
break;
default:
LOC_LOGE("%s: unrecognized event %d", whoami(), event);
// no state change.
}
LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
whoami(), nextState->whoami(), event);
return nextState;
}
class AgpsAcquiredState : public AgpsState
{
friend class AgpsStateMachine;
inline AgpsAcquiredState(AgpsStateMachine* stateMachine) :
AgpsState(stateMachine)
{ mAcquiredState = this; }
inline ~AgpsAcquiredState() {}
public:
virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
inline virtual char* whoami() { return (char*)"AgpsAcquiredState"; }
};
AgpsState* AgpsAcquiredState::onRsrcEvent(AgpsRsrcStatus event, void* data)
{
AgpsState* nextState = this;
switch (event)
{
case RSRC_SUBSCRIBE:
{
// we already have the NIF resource, simply notify subscriber
Subscriber* subscriber = (Subscriber*) data;
// we have rsrc in hand, so grant it right away
Notification notification(subscriber, RSRC_GRANTED, false);
subscriber->notifyRsrcStatus(notification);
// add subscriber to the list
mStateMachine->addSubscriber(subscriber);
// no state change.
}
break;
case RSRC_UNSUBSCRIBE:
{
Subscriber* subscriber = (Subscriber*) data;
if (subscriber->waitForCloseComplete()) {
subscriber->setInactive();
} else {
// auto notify this subscriber of the unsubscribe
Notification notification(subscriber, event, true);
mStateMachine->notifySubscribers(notification);
}
// now check if there is any subscribers left
if (!mStateMachine->hasSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasingState;
// tell connecivity service we can release NIF
mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN);
} else if (!mStateMachine->hasActiveSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasedState;
// tell connecivity service we can release NIF
mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN);
}
}
break;
case RSRC_GRANTED:
LOC_LOGW("%s: %d, RSRC_GRANTED already received", whoami(), event);
// no state change.
break;
case RSRC_RELEASED:
{
LOC_LOGW("%s: %d, a force rsrc release", whoami(), event);
nextState = mReleasedState;
Notification notification(Notification::BROADCAST_ALL, event, true);
// by setting true, we remove subscribers from the linked list
mStateMachine->notifySubscribers(notification);
}
break;
case RSRC_DENIED:
// no state change.
// we are expecting RELEASED. Handling DENIED
// may like break our state machine in race conditions.
break;
default:
LOC_LOGE("%s: unrecognized event %d", whoami(), event);
// no state change.
}
LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
whoami(), nextState->whoami(), event);
return nextState;
}
// AgpsPendingState
class AgpsReleasingState : public AgpsState
{
friend class AgpsStateMachine;
inline AgpsReleasingState(AgpsStateMachine* stateMachine) :
AgpsState(stateMachine)
{ mReleasingState = this; }
inline ~AgpsReleasingState() {}
public:
virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
inline virtual char* whoami() {return (char*)"AgpsReleasingState";}
};
AgpsState* AgpsReleasingState::onRsrcEvent(AgpsRsrcStatus event, void* data)
{
AgpsState* nextState = this;;
switch (event)
{
case RSRC_SUBSCRIBE:
{
// already requested for NIF resource,
// do nothing until we get RSRC_GRANTED indication
// but we need to add subscriber to the list
mStateMachine->addSubscriber((Subscriber*)data);
// no state change.
}
break;
case RSRC_UNSUBSCRIBE:
{
Subscriber* subscriber = (Subscriber*) data;
if (subscriber->waitForCloseComplete()) {
subscriber->setInactive();
} else {
// auto notify this subscriber of the unsubscribe
Notification notification(subscriber, event, true);
mStateMachine->notifySubscribers(notification);
}
// now check if there is any subscribers left
if (!mStateMachine->hasSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasingState;
// tell connecivity service we can release NIF
mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN);
} else if (!mStateMachine->hasActiveSubscribers()) {
// no more subscribers, move to RELEASED state
nextState = mReleasedState;
// tell connecivity service we can release NIF
mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN);
}
}
break;
case RSRC_RELEASED:
{
nextState = mAcquiredState;
Notification notification(Notification::BROADCAST_INACTIVE, event, true);
// notify all subscribers that are active NIF resource RELEASE
// by setting false, we keep subscribers on the linked list
mStateMachine->notifySubscribers(notification);
if (mStateMachine->hasSubscribers()) {
nextState = mPendingState;
// request from connecivity service for NIF
mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN);
} else {
nextState = mReleasedState;
}
}
break;
case RSRC_GRANTED:
case RSRC_DENIED:
default:
LOC_LOGE("%s: unrecognized event %d", whoami(), event);
// no state change.
}
LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
whoami(), nextState->whoami(), event);
return nextState;
}
//======================================================================
// AgpsStateMachine
//======================================================================
AgpsStateMachine::AgpsStateMachine(void (*servicer)(AGpsStatus* status),
AGpsType type) :
mServicer(servicer), mType(type),
mStatePtr(new AgpsReleasedState(this)),
mAPN(NULL),
mAPNLen(0)
{
linked_list_init(&mSubscribers);
// setting up mReleasedState
mStatePtr->mPendingState = new AgpsPendingState(this);
mStatePtr->mAcquiredState = new AgpsAcquiredState(this);
mStatePtr->mReleasingState = new AgpsReleasingState(this);
// setting up mAcquiredState
mStatePtr->mAcquiredState->mReleasedState = mStatePtr;
mStatePtr->mAcquiredState->mPendingState = mStatePtr->mPendingState;
mStatePtr->mAcquiredState->mReleasingState = mStatePtr->mReleasingState;
// setting up mPendingState
mStatePtr->mPendingState->mAcquiredState = mStatePtr->mAcquiredState;
mStatePtr->mPendingState->mReleasedState = mStatePtr;
mStatePtr->mPendingState->mReleasingState = mStatePtr->mReleasingState;
// setting up mReleasingState
mStatePtr->mReleasingState->mReleasedState = mStatePtr;
mStatePtr->mReleasingState->mPendingState = mStatePtr->mPendingState;
mStatePtr->mReleasingState->mAcquiredState = mStatePtr->mAcquiredState;
}
AgpsStateMachine::~AgpsStateMachine()
{
dropAllSubscribers();
// free the 3 states. We must read out all 3 pointers first.
// Otherwise we run the risk of getting pointers from already
// freed memory.
AgpsState* acquiredState = mStatePtr->mAcquiredState;
AgpsState* releasedState = mStatePtr->mReleasedState;
AgpsState* pendindState = mStatePtr->mPendingState;
AgpsState* releasingState = mStatePtr->mReleasingState;
delete acquiredState;
delete releasedState;
delete pendindState;
delete releasingState;
linked_list_destroy(&mSubscribers);
if (NULL != mAPN) {
delete[] mAPN;
mAPN = NULL;
}
}
void AgpsStateMachine::setAPN(const char* apn, unsigned int len)
{
if (NULL != mAPN) {
delete mAPN;
}
if (NULL != apn) {
mAPN = new char[len+1];
memcpy(mAPN, apn, len);
mAPN[len] = NULL;
mAPNLen = len;
} else {
mAPN = NULL;
mAPNLen = 0;
}
}
void AgpsStateMachine::onRsrcEvent(AgpsRsrcStatus event)
{
switch (event)
{
case RSRC_GRANTED:
case RSRC_RELEASED:
case RSRC_DENIED:
mStatePtr = mStatePtr->onRsrcEvent(event, NULL);
break;
default:
LOC_LOGW("AgpsStateMachine: unrecognized event %d", event);
break;
}
}
void AgpsStateMachine::notifySubscribers(Notification& notification) const
{
if (notification.postNotifyDelete) {
// just any non NULL value to get started
Subscriber* s = (Subscriber*)~0;
while (NULL != s) {
s = NULL;
// if the last param sets to true, _search will delete
// the node from the list for us. But the problem is
// once that is done, _search returns, leaving the
// rest of the list unprocessed. So we need a loop.
linked_list_search(mSubscribers, (void**)&s, notifySubscriber,
(void*)&notification, true);
}
} else {
// no loop needed if it the last param sets to false, which
// mean nothing gets deleted from the list.
linked_list_search(mSubscribers, NULL, notifySubscriber,
(void*)&notification, false);
}
}
void AgpsStateMachine::addSubscriber(Subscriber* subscriber) const
{
Subscriber* s = NULL;
Notification notification((const Subscriber*)subscriber);
linked_list_search(mSubscribers, (void**)&s,
hasSubscriber, (void*)&notification, false);
if (NULL == s) {
linked_list_add(mSubscribers, subscriber->clone(), deleteObj);
}
}
void AgpsStateMachine::sendRsrcRequest(AGpsStatusValue action) const
{
Subscriber* s = NULL;
Notification notification(Notification::BROADCAST_ALL);
linked_list_search(mSubscribers, (void**)&s, hasSubscriber,
(void*)&notification, false);
if ((NULL == s) == (GPS_RELEASE_AGPS_DATA_CONN == action)) {
AGpsStatus nifRequest;
nifRequest.size = sizeof(nifRequest);
nifRequest.type = mType;
nifRequest.status = action;
#ifdef QCOM_FEATURE_IPV6
if (s == NULL) {
nifRequest.ipv4_addr = INADDR_NONE;
nifRequest.ipv6_addr[0] = 0;
} else {
s->setIPAddresses(nifRequest.ipv4_addr, (char*)nifRequest.ipv6_addr);
}
#else
if (s == NULL) {
nifRequest.ipaddr = INADDR_NONE;
} else {
nifRequest.ipaddr = s->ID;
}
#endif
CALLBACK_LOG_CALLFLOW("agps_cb", %s, loc_get_agps_status_name(action));
(*mServicer)(&nifRequest);
}
}
void AgpsStateMachine::subscribeRsrc(Subscriber *subscriber)
{
mStatePtr = mStatePtr->onRsrcEvent(RSRC_SUBSCRIBE, (void*)subscriber);
}
bool AgpsStateMachine::unsubscribeRsrc(Subscriber *subscriber)
{
Subscriber* s = NULL;
Notification notification((const Subscriber*)subscriber);
linked_list_search(mSubscribers, (void**)&s,
hasSubscriber, (void*)&notification, false);
if (NULL != s) {
mStatePtr = mStatePtr->onRsrcEvent(RSRC_UNSUBSCRIBE, (void*)s);
return true;
}
return false;
}
bool AgpsStateMachine::hasActiveSubscribers() const
{
Subscriber* s = NULL;
Notification notification(Notification::BROADCAST_ACTIVE);
linked_list_search(mSubscribers, (void**)&s,
hasSubscriber, (void*)&notification, false);
return NULL != s;
}

274
loc_api/libloc_api_50001/loc_eng_agps.h
View file

@ -1,274 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef __LOC_ENG_AGPS_H__
#define __LOC_ENG_AGPS_H__
#include <stdbool.h>
#include <ctype.h>
#include <string.h>
#include <arpa/inet.h>
#include <hardware/gps.h>
#include <linked_list.h>
#include <LocApiAdapter.h>
// forward declaration
class AgpsStateMachine;
class Subscriber;
// NIF resource events
typedef enum {
RSRC_SUBSCRIBE,
RSRC_UNSUBSCRIBE,
RSRC_GRANTED,
RSRC_RELEASED,
RSRC_DENIED,
RSRC_STATUS_MAX
} AgpsRsrcStatus;
// information bundle for subscribers
struct Notification {
// goes to every subscriber
static const int BROADCAST_ALL;
// goes to every ACTIVE subscriber
static const int BROADCAST_ACTIVE;
// goes to every INACTIVE subscriber
static const int BROADCAST_INACTIVE;
// go to a specific subscriber
const Subscriber* rcver;
// broadcast
const int groupID;
// the new resource status event
const AgpsRsrcStatus rsrcStatus;
// should the subscriber be deleted after the notification
const bool postNotifyDelete;
// convenient constructor
inline Notification(const int broadcast,
const AgpsRsrcStatus status,
const bool deleteAfterwards) :
rcver(NULL), groupID(broadcast), rsrcStatus(status),
postNotifyDelete(deleteAfterwards) {}
// convenient constructor
inline Notification(const Subscriber* subscriber,
const AgpsRsrcStatus status,
const bool deleteAfterwards) :
rcver(subscriber), groupID(-1), rsrcStatus(status),
postNotifyDelete(deleteAfterwards) {}
// convenient constructor
inline Notification(const int broadcast) :
rcver(NULL), groupID(broadcast), rsrcStatus(RSRC_STATUS_MAX),
postNotifyDelete(false) {}
// convenient constructor
inline Notification(const Subscriber* subscriber) :
rcver(subscriber), groupID(-1), rsrcStatus(RSRC_STATUS_MAX),
postNotifyDelete(false) {}
};
class AgpsState {
// allows AgpsStateMachine to access private data
// no class members are public. We don't want
// anyone but state machine to use state.
friend class AgpsStateMachine;
// state transitions are done here.
// Each state implements its own transitions (of course).
inline virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data) = 0;
protected:
// handle back to state machine
const AgpsStateMachine* mStateMachine;
// each state has pointers to all 3 states
// one of which is to itself.
AgpsState* mReleasedState;
AgpsState* mAcquiredState;
AgpsState* mPendingState;
AgpsState* mReleasingState;
inline AgpsState(const AgpsStateMachine *stateMachine) :
mStateMachine(stateMachine),
mReleasedState(NULL),
mAcquiredState(NULL),
mPendingState(NULL),
mReleasingState(NULL) {}
virtual ~AgpsState() {}
public:
// for logging purpose
inline virtual char* whoami() = 0;
};
class AgpsStateMachine {
// allows AgpsState to access private data
// each state is really internal data to the
// state machine, so it should be able to
// access anything within the state machine.
friend class AgpsState;
// handle to whoever provides the service
void (* const mServicer)(AGpsStatus* status);
// NIF type: AGNSS or INTERNET.
const AGpsType mType;
// pointer to the current state.
AgpsState* mStatePtr;
// a linked list of subscribers.
void* mSubscribers;
// apn to the NIF. Each state machine tracks
// resource state of a particular NIF. For each
// NIF, there is also an active APN.
char* mAPN;
// for convenience, we don't do strlen each time.
unsigned int mAPNLen;
#ifdef QCOM_FEATURE_IPV6
// bear
AGpsBearerType mBearer;
#endif
// ipv4 address for routing
public:
AgpsStateMachine(void (*servicer)(AGpsStatus* status), AGpsType type);
virtual ~AgpsStateMachine();
// self explanatory methods below
void setAPN(const char* apn, unsigned int len);
inline const char* getAPN() const { return (const char*)mAPN; }
#ifdef QCOM_FEATURE_IPV6
inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; }
inline AGpsBearerType getBearer() const { return mBearer; }
#endif
inline AGpsType getType() const { return (AGpsType)mType; }
// someone, a ATL client or BIT, is asking for NIF
void subscribeRsrc(Subscriber *subscriber);
// someone, a ATL client or BIT, is done with NIF
bool unsubscribeRsrc(Subscriber *subscriber);
// add a subscriber in the linked list, if not already there.
void addSubscriber(Subscriber* subscriber) const;
void onRsrcEvent(AgpsRsrcStatus event);
// put the data together and send the FW
void sendRsrcRequest(AGpsStatusValue action) const;
inline bool hasSubscribers() const
{ return !linked_list_empty(mSubscribers); }
bool hasActiveSubscribers() const;
inline void dropAllSubscribers() const
{ linked_list_flush(mSubscribers); }
// private. Only a state gets to call this.
void notifySubscribers(Notification& notification) const;
};
// each subscriber is a AGPS client. In the case of ATL, there could be
// multiple clients from modem. In the case of BIT, there is only one
// cilent from BIT daemon.
struct Subscriber {
const int ID;
const AgpsStateMachine* mStateMachine;
inline Subscriber(const int id,
const AgpsStateMachine* stateMachine) :
ID(id), mStateMachine(stateMachine) {}
inline virtual ~Subscriber() {}
virtual void setIPAddresses(int &v4, char* v6) = 0;
inline virtual bool equals(const Subscriber *s) const
{ return ID == s->ID; }
// notifies a subscriber a new NIF resource status, usually
// either GRANTE, DENIED, or RELEASED
virtual bool notifyRsrcStatus(Notification &notification) = 0;
virtual bool waitForCloseComplete() { return false; }
virtual void setInactive() {}
virtual bool isInactive() { return false; }
virtual Subscriber* clone() = 0;
// checks if this notification is for me, i.e.
// either has my id, or has a broadcast id.
bool forMe(Notification &notification);
};
// BITSubscriber, created with requests from BIT daemon
struct BITSubscriber : public Subscriber {
inline BITSubscriber(const AgpsStateMachine* stateMachine,
unsigned int ipv4, char* ipv6) :
Subscriber(ipv4, stateMachine)
{
if (NULL == ipv6) {
ipv6Addr[0] = NULL;
} else {
memcpy(ipv6Addr, ipv6, sizeof(ipv6Addr));
}
}
virtual bool notifyRsrcStatus(Notification &notification);
inline virtual void setIPAddresses(int &v4, char* v6)
{ v4 = ID; memcpy(v6, ipv6Addr, sizeof(ipv6Addr)); }
virtual Subscriber* clone()
{
return new BITSubscriber(mStateMachine, ID, ipv6Addr);
}
virtual bool equals(const Subscriber *s) const;
private:
char ipv6Addr[16];
};
// ATLSubscriber, created with requests from ATL
struct ATLSubscriber : public Subscriber {
const LocApiAdapter* mLocAdapter;
inline ATLSubscriber(const int id,
const AgpsStateMachine* stateMachine,
const LocApiAdapter* adapter) :
Subscriber(id, stateMachine), mLocAdapter(adapter) {}
virtual bool notifyRsrcStatus(Notification &notification);
inline virtual void setIPAddresses(int &v4, char* v6)
{ v4 = INADDR_NONE; v6[0] = 0; }
inline virtual Subscriber* clone()
{
return new ATLSubscriber(ID, mStateMachine, mLocAdapter);
}
};
#endif //__LOC_ENG_AGPS_H__

180
loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp
View file

@ -1,180 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <linux/stat.h>
#include <fcntl.h>
#include <linux/types.h>
#include <unistd.h>
#include "log_util.h"
#include "loc_eng_dmn_conn_glue_msg.h"
#include "loc_eng_dmn_conn_handler.h"
#include "loc_eng_dmn_conn.h"
static int loc_api_server_msgqid;
static int loc_api_resp_msgqid;
static const char * global_loc_api_q_path = GPSONE_LOC_API_Q_PATH;
static const char * global_loc_api_resp_q_path = GPSONE_LOC_API_RESP_Q_PATH;
static int loc_api_server_proc_init(void *context)
{
loc_api_server_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_q_path, O_RDWR);
loc_api_resp_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_resp_q_path, O_RDWR);
LOC_LOGD("%s:%d] loc_api_server_msgqid = %d\n", __func__, __LINE__, loc_api_server_msgqid);
return 0;
}
static int loc_api_server_proc_pre(void *context)
{
return 0;
}
static int loc_api_server_proc(void *context)
{
int length, sz;
int result = 0;
static int cnt = 0;
struct ctrl_msgbuf * p_cmsgbuf;
struct ctrl_msgbuf cmsg_resp;
sz = sizeof(struct ctrl_msgbuf) + 256;
p_cmsgbuf = (struct ctrl_msgbuf *) malloc(sz);
if (!p_cmsgbuf) {
LOC_LOGE("%s:%d] Out of memory\n", __func__, __LINE__);
return -1;
}
cnt ++;
LOC_LOGD("%s:%d] %d listening on %s...\n", __func__, __LINE__, cnt, (char *) context);
length = loc_eng_dmn_conn_glue_msgrcv(loc_api_server_msgqid, p_cmsgbuf, sz);
if (length <= 0) {
LOC_LOGE("%s:%d] fail receiving msg from gpsone_daemon, retry later\n", __func__, __LINE__);
usleep(1000);
return 0;
}
LOC_LOGD("%s:%d] received ctrl_type = %d\n", __func__, __LINE__, p_cmsgbuf->ctrl_type);
switch(p_cmsgbuf->ctrl_type) {
case GPSONE_LOC_API_IF_REQUEST:
result = loc_eng_dmn_conn_loc_api_server_if_request_handler(p_cmsgbuf, length);
break;
case GPSONE_LOC_API_IF_RELEASE:
result = loc_eng_dmn_conn_loc_api_server_if_release_handler(p_cmsgbuf, length);
break;
case GPSONE_UNBLOCK:
LOC_LOGD("%s:%d] GPSONE_UNBLOCK\n", __func__, __LINE__);
break;
default:
LOC_LOGE("%s:%d] unsupported ctrl_type = %d\n",
__func__, __LINE__, p_cmsgbuf->ctrl_type);
break;
}
free(p_cmsgbuf);
return 0;
}
static int loc_api_server_proc_post(void *context)
{
LOC_LOGD("%s:%d]\n", __func__, __LINE__);
loc_eng_dmn_conn_glue_msgremove( global_loc_api_q_path, loc_api_server_msgqid);
loc_eng_dmn_conn_glue_msgremove( global_loc_api_resp_q_path, loc_api_resp_msgqid);
return 0;
}
static int loc_eng_dmn_conn_unblock_proc(void)
{
struct ctrl_msgbuf cmsgbuf;
cmsgbuf.ctrl_type = GPSONE_UNBLOCK;
LOC_LOGD("%s:%d]\n", __func__, __LINE__);
loc_eng_dmn_conn_glue_msgsnd(loc_api_server_msgqid, & cmsgbuf, sizeof(cmsgbuf));
return 0;
}
static struct loc_eng_dmn_conn_thelper thelper;
int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb,
const char * loc_api_q_path, const char * resp_q_path, void *agps_handle)
{
int result;
loc_api_handle = agps_handle;
if (loc_api_q_path) global_loc_api_q_path = loc_api_q_path;
if (resp_q_path) global_loc_api_resp_q_path = resp_q_path;
result = loc_eng_dmn_conn_launch_thelper( &thelper,
loc_api_server_proc_init,
loc_api_server_proc_pre,
loc_api_server_proc,
loc_api_server_proc_post,
create_thread_cb,
(char *) global_loc_api_q_path);
if (result != 0) {
LOC_LOGE("%s:%d]\n", __func__, __LINE__);
return -1;
}
return 0;
}
int loc_eng_dmn_conn_loc_api_server_unblock(void)
{
loc_eng_dmn_conn_unblock_thelper(&thelper);
loc_eng_dmn_conn_unblock_proc();
return 0;
}
int loc_eng_dmn_conn_loc_api_server_join(void)
{
loc_eng_dmn_conn_join_thelper(&thelper);
return 0;
}
int loc_eng_dmn_conn_loc_api_server_data_conn(int status) {
struct ctrl_msgbuf cmsgbuf;
cmsgbuf.ctrl_type = GPSONE_LOC_API_RESPONSE;
cmsgbuf.cmsg.cmsg_response.result = status;
LOC_LOGD("%s:%d] status = %d",__func__, __LINE__, status);
if (loc_eng_dmn_conn_glue_msgsnd(loc_api_resp_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) {
LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__);
return -1;
}
return 0;
}

53
loc_api/libloc_api_50001/loc_eng_dmn_conn.h
View file

@ -1,53 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_DATA_SERVER_H
#define LOC_ENG_DATA_SERVER_H
#include "loc_eng_dmn_conn_thread_helper.h"
#ifdef _ANDROID_
#define GPSONE_LOC_API_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_q"
#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_resp_q"
#else
#define GPSONE_LOC_API_Q_PATH "/tmp/gpsone_loc_api_q"
#define GPSONE_LOC_API_RESP_Q_PATH "/tmp/gpsone_loc_api_resp_q"
#endif
int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb,
const char * loc_api_q_path, const char * ctrl_q_path, void *agps_handle);
int loc_eng_dmn_conn_loc_api_server_unblock(void);
int loc_eng_dmn_conn_loc_api_server_join(void);
int loc_eng_dmn_conn_loc_api_server_data_conn(int);
#endif /* LOC_ENG_DATA_SERVER_H */

223
loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c
View file

@ -1,223 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <linux/stat.h>
#include <fcntl.h>
#include <linux/types.h>
#include "log_util.h"
#include "loc_eng_dmn_conn_glue_msg.h"
#include "loc_eng_dmn_conn_handler.h"
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgget
DESCRIPTION
This function get a message queue
q_path - name path of the message queue
mode -
DEPENDENCIES
None
RETURN VALUE
message queue id
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode)
{
int msgqid;
msgqid = loc_eng_dmn_conn_glue_pipeget(q_path, mode);
return msgqid;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgremove
DESCRIPTION
remove a message queue
q_path - name path of the message queue
msgqid - message queue id
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid)
{
int result;
result = loc_eng_dmn_conn_glue_piperemove(q_path, msgqid);
return result;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgsnd
DESCRIPTION
Send a message
msgqid - message queue id
msgp - pointer to the message to be sent
msgsz - size of the message
DEPENDENCIES
None
RETURN VALUE
number of bytes sent out or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz)
{
int result;
struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp;
pmsg->msgsz = msgsz;
result = loc_eng_dmn_conn_glue_pipewrite(msgqid, msgp, msgsz);
if (result != (int) msgsz) {
LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) msgsz);
return -1;
}
return result;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgrcv
DESCRIPTION
receive a message
msgqid - message queue id
msgp - pointer to the buffer to hold the message
msgsz - size of the buffer
DEPENDENCIES
None
RETURN VALUE
number of bytes received or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgbufsz)
{
int result;
struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp;
result = loc_eng_dmn_conn_glue_piperead(msgqid, &(pmsg->msgsz), sizeof(pmsg->msgsz));
if (result != sizeof(pmsg->msgsz)) {
LOC_LOGE("%s:%d] pipe broken %d\n", __func__, __LINE__, result);
return -1;
}
if (msgbufsz < pmsg->msgsz) {
LOC_LOGE("%s:%d] msgbuf is too small %d < %d\n", __func__, __LINE__, (int) msgbufsz, (int) pmsg->msgsz);
return -1;
}
result = loc_eng_dmn_conn_glue_piperead(msgqid, (uint8_t *) msgp + sizeof(pmsg->msgsz), pmsg->msgsz - sizeof(pmsg->msgsz));
if (result != (int) (pmsg->msgsz - sizeof(pmsg->msgsz))) {
LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) pmsg->msgsz);
return -1;
}
return pmsg->msgsz;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgunblock
DESCRIPTION
unblock a message queue
msgqid - message queue id
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgunblock(int msgqid)
{
return loc_eng_dmn_conn_glue_pipeunblock(msgqid);
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_msgflush
DESCRIPTION
flush out the message in a queue
msgqid - message queue id
DEPENDENCIES
None
RETURN VALUE
number of bytes that are flushed out.
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_msgflush(int msgqid)
{
int length;
char buf[128];
do {
length = loc_eng_dmn_conn_glue_piperead(msgqid, buf, 128);
LOC_LOGD("%s:%d] %s\n", __func__, __LINE__, buf);
} while(length);
return length;
}

51
loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h
View file

@ -1,51 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_DMN_CONN_GLUE_MSG_H
#define LOC_ENG_DMN_CONN_GLUE_MSG_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <linux/types.h>
#include "loc_eng_dmn_conn_glue_pipe.h"
int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode);
int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid);
int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz);
int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgsz);
int loc_eng_dmn_conn_glue_msgflush(int msgqid);
int loc_eng_dmn_conn_glue_msgunblock(int msgqid);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LOC_ENG_DMN_CONN_GLUE_MSG_H */

206
loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c
View file

@ -1,206 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <string.h>
#include <unistd.h>
#include <errno.h>
// #include <linux/stat.h>
#include <fcntl.h>
// #include <linux/types.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "loc_eng_dmn_conn_glue_pipe.h"
#include "log_util.h"
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_pipeget
DESCRIPTION
create a named pipe.
pipe_name - pipe name path
mode - mode
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode)
{
int fd;
int result;
LOC_LOGD("%s, mode = %d\n", pipe_name, mode);
result = mkfifo(pipe_name, 0666);
if ((result == -1) && (errno != EEXIST)) {
LOC_LOGE("failed: %s\n", strerror(errno));
return result;
}
fd = open(pipe_name, mode);
if (fd <= 0)
{
LOC_LOGE("failed: %s\n", strerror(errno));
}
LOC_LOGD("fd = %d, %s\n", fd, pipe_name);
return fd;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_piperemove
DESCRIPTION
remove a pipe
pipe_name - pipe name path
fd - fd for the pipe
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd)
{
close(fd);
if (pipe_name) unlink(pipe_name);
LOC_LOGD("fd = %d, %s\n", fd, pipe_name);
return 0;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_pipewrite
DESCRIPTION
write to a pipe
fd - fd of a pipe
buf - buffer for the data to write
sz - size of the data in buffer
DEPENDENCIES
None
RETURN VALUE
number of bytes written or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz)
{
int result;
result = write(fd, buf, sz);
/* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */
/* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, result = %d\n", fd, (long) buf, (int) sz, (int) result); */
return result;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_piperead
DESCRIPTION
read from a pipe
fd - fd for the pipe
buf - buffer to hold the data read from pipe
sz - size of the buffer
DEPENDENCIES
None
RETURN VALUE
number of bytes read from pipe or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz)
{
int len;
len = read(fd, buf, sz);
/* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */
/* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, len = %d\n", fd, (long) buf, (int) sz, len); */
return len;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_glue_pipeunblock
DESCRIPTION
unblock a pipe
fd - fd for the pipe
DEPENDENCIES
None
RETURN VALUE
0 for success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_glue_pipeunblock(int fd)
{
int result;
struct flock flock_v;
LOC_LOGD("\n");
// result = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NDELAY);
flock_v.l_type = F_UNLCK;
flock_v.l_len = 32;
result = fcntl(fd, F_SETLK, &flock_v);
if (result < 0) {
LOC_LOGE("fcntl failure, %s\n", strerror(errno));
}
return result;
}

50
loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h
View file

@ -1,50 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_DMN_CONN_GLUE_PIPE_H
#define LOC_ENG_DMN_CONN_GLUE_PIPE_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <linux/types.h>
int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode);
int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd);
int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz);
int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz);
int loc_eng_dmn_conn_glue_pipeflush(int fd);
int loc_eng_dmn_conn_glue_pipeunblock(int fd);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LOC_ENG_DMN_CONN_GLUE_PIPE_H */

78
loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp
View file

@ -1,78 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "log_util.h"
#include "loc_eng_msg.h"
#include "loc_eng_dmn_conn.h"
#include "loc_eng_dmn_conn_handler.h"
void* loc_api_handle = NULL;
int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len)
{
LOC_LOGD("%s:%d]\n", __func__, __LINE__);
#ifndef DEBUG_DMN_LOC_API
if (NULL == loc_api_handle) {
LOC_LOGE("%s:%d] NO agps data handle\n", __func__, __LINE__);
return 1;
}
loc_eng_msg_request_bit *msg(
new loc_eng_msg_request_bit(loc_api_handle,
pmsg->cmsg.cmsg_if_request.is_supl,
pmsg->cmsg.cmsg_if_request.ipv4_addr,
(char*)pmsg->cmsg.cmsg_if_request.ipv6_addr));
loc_eng_msg_sender(loc_api_handle, msg);
#else
loc_eng_dmn_conn_loc_api_server_data_conn(GPSONE_LOC_API_IF_REQUEST_SUCCESS);
#endif
return 0;
}
int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len)
{
LOC_LOGD("%s:%d]\n", __func__, __LINE__);
#ifndef DEBUG_DMN_LOC_API
loc_eng_msg_release_bit *msg(
new loc_eng_msg_release_bit(loc_api_handle,
pmsg->cmsg.cmsg_if_request.is_supl,
pmsg->cmsg.cmsg_if_request.ipv4_addr,
(char*)pmsg->cmsg.cmsg_if_request.ipv6_addr));
loc_eng_msg_sender(loc_api_handle, msg);
#else
loc_eng_dmn_conn_loc_api_server_data_conn(GPSONE_LOC_API_IF_RELEASE_SUCCESS);
#endif
return 0;
}

82
loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h
View file

@ -1,82 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_DATA_SERVER_HANDLER
#define LOC_ENG_DATA_SERVER_HANDLER
#include <linux/types.h>
#include <arpa/inet.h>
enum {
/* 0x0 - 0xEF is reserved for daemon internal */
GPSONE_LOC_API_IF_REQUEST = 0xF0,
GPSONE_LOC_API_IF_RELEASE,
GPSONE_LOC_API_RESPONSE,
GPSONE_UNBLOCK,
};
enum {
GPSONE_LOC_API_IF_REQUEST_SUCCESS = 0xF0,
GPSONE_LOC_API_IF_RELEASE_SUCCESS,
GPSONE_LOC_API_IF_FAILURE,
};
struct ctrl_msg_response {
int result;
};
struct ctrl_msg_unblock {
int reserved;
};
struct ctrl_msg_if_request {
unsigned is_supl; /* 1: use Android SUPL connection; 0: use Android default internet connection */
unsigned long ipv4_addr;
unsigned char ipv6_addr[16];
};
/* do not change this structure */
struct ctrl_msgbuf {
size_t msgsz;
uint16_t reserved1;
uint32_t reserved2;
uint8_t ctrl_type;
union {
struct ctrl_msg_response cmsg_response;
struct ctrl_msg_unblock cmsg_unblock;
struct ctrl_msg_if_request cmsg_if_request;
} cmsg;
};
extern void* loc_api_handle;
int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len);
int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len);
#endif /* LOC_ENG_DATA_SERVER_HANDLER */

398
loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c
View file

@ -1,398 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdio.h>
#include "log_util.h"
#include "loc_eng_dmn_conn_thread_helper.h"
/*===========================================================================
FUNCTION thelper_signal_init
DESCRIPTION
This function will initialize the conditional variable resources.
thelper - thelper instance
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper)
{
int result;
thelper->thread_exit = 0;
thelper->thread_ready = 0;
result = pthread_cond_init( &thelper->thread_cond, NULL);
if (result) {
return result;
}
result = pthread_mutex_init(&thelper->thread_mutex, NULL);
if (result) {
pthread_cond_destroy(&thelper->thread_cond);
}
return result;
}
/*===========================================================================
FUNCTION
DESCRIPTION
This function will destroy the conditional variable resources
thelper - pointer to thelper instance
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper)
{
int result, ret_result = 0;
result = pthread_cond_destroy( &thelper->thread_cond);
if (result) {
ret_result = result;
}
result = pthread_mutex_destroy(&thelper->thread_mutex);
if (result) {
ret_result = result;
}
return ret_result;
}
/*===========================================================================
FUNCTION thelper_signal_wait
DESCRIPTION
This function will be blocked on the conditional variable until thelper_signal_ready
is called
thelper - pointer to thelper instance
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper)
{
int result = 0;
pthread_mutex_lock(&thelper->thread_mutex);
if (!thelper->thread_ready && !thelper->thread_exit) {
result = pthread_cond_wait(&thelper->thread_cond, &thelper->thread_mutex);
}
if (thelper->thread_exit) {
result = -1;
}
pthread_mutex_unlock(&thelper->thread_mutex);
return result;
}
/*===========================================================================
FUNCTION thelper_signal_ready
DESCRIPTION
This function will wake up the conditional variable
thelper - pointer to thelper instance
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper)
{
int result;
LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
pthread_mutex_lock(&thelper->thread_mutex);
thelper->thread_ready = 1;
result = pthread_cond_signal(&thelper->thread_cond);
pthread_mutex_unlock(&thelper->thread_mutex);
return result;
}
/*===========================================================================
FUNCTION thelper_signal_block
DESCRIPTION
This function will set the thread ready to 0 to block the thelper_signal_wait
thelper - pointer to thelper instance
DEPENDENCIES
None
RETURN VALUE
if thread_ready is set
SIDE EFFECTS
N/A
===========================================================================*/
int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper)
{
int result = thelper->thread_ready;
LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
pthread_mutex_lock(&thelper->thread_mutex);
thelper->thread_ready = 0;
pthread_mutex_unlock(&thelper->thread_mutex);
return result;
}
/*===========================================================================
FUNCTION thelper_main
DESCRIPTION
This function is the main thread. It will be launched as a child thread
data - pointer to the instance
DEPENDENCIES
None
RETURN VALUE
NULL
SIDE EFFECTS
N/A
===========================================================================*/
static void * thelper_main(void *data)
{
int result = 0;
struct loc_eng_dmn_conn_thelper * thelper = (struct loc_eng_dmn_conn_thelper *) data;
if (thelper->thread_proc_init) {
result = thelper->thread_proc_init(thelper->thread_context);
if (result < 0) {
thelper->thread_exit = 1;
thelper_signal_ready(thelper);
LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
return NULL;
}
}
thelper_signal_ready(thelper);
if (thelper->thread_proc_pre) {
result = thelper->thread_proc_pre(thelper->thread_context);
if (result < 0) {
thelper->thread_exit = 1;
LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
return NULL;
}
}
do {
if (thelper->thread_proc) {
result = thelper->thread_proc(thelper->thread_context);
if (result < 0) {
thelper->thread_exit = 1;
LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
}
}
} while (thelper->thread_exit == 0);
if (thelper->thread_proc_post) {
result = thelper->thread_proc_post(thelper->thread_context);
}
if (result != 0) {
LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
}
return NULL;
}
static void thelper_main_2(void *data)
{
thelper_main(data);
return;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_launch_thelper
DESCRIPTION
This function will initialize the thread context and launch the thelper_main
thelper - pointer to thelper instance
thread_proc_init - The initialization function pointer
thread_proc_pre - The function to call before task loop and after initialization
thread_proc - The task loop
thread_proc_post - The function to call after the task loop
context - the context for the above four functions
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper,
int (*thread_proc_init) (void * context),
int (*thread_proc_pre) (void * context),
int (*thread_proc) (void * context),
int (*thread_proc_post) (void * context),
thelper_create_thread create_thread_cb,
void * context)
{
int result;
thelper_signal_init(thelper);
if (context) {
thelper->thread_context = context;
}
thelper->thread_proc_init = thread_proc_init;
thelper->thread_proc_pre = thread_proc_pre;
thelper->thread_proc = thread_proc;
thelper->thread_proc_post = thread_proc_post;
LOC_LOGD("%s:%d] 0x%lx call pthread_create\n", __func__, __LINE__, (long) thelper);
if (create_thread_cb) {
result = 0;
thelper->thread_id = create_thread_cb("loc_eng_dmn_conn",
thelper_main_2, (void *)thelper);
} else {
result = pthread_create(&thelper->thread_id, NULL,
thelper_main, (void *)thelper);
}
if (result != 0) {
LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
return -1;
}
LOC_LOGD("%s:%d] 0x%lx pthread_create done\n", __func__, __LINE__, (long) thelper);
thelper_signal_wait(thelper);
LOC_LOGD("%s:%d] 0x%lx pthread ready\n", __func__, __LINE__, (long) thelper);
return thelper->thread_exit;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_unblock_thelper
DESCRIPTION
This function unblocks thelper_main to release the thread
thelper - pointer to thelper instance
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper)
{
LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
thelper->thread_exit = 1;
return 0;
}
/*===========================================================================
FUNCTION loc_eng_dmn_conn_join_thelper
thelper - pointer to thelper instance
DESCRIPTION
This function will wait for the thread of thelper_main to finish
DEPENDENCIES
None
RETURN VALUE
0: success or negative value for failure
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper)
{
int result;
LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
result = pthread_join(thelper->thread_id, NULL);
if (result != 0) {
LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
}
LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
thelper_signal_destroy(thelper);
return result;
}

74
loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h
View file

@ -1,74 +0,0 @@
/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef __LOC_ENG_DMN_CONN_THREAD_HELPER_H__
#define __LOC_ENG_DMN_CONN_THREAD_HELPER_H__
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <pthread.h>
struct loc_eng_dmn_conn_thelper {
unsigned char thread_exit;
unsigned char thread_ready;
pthread_cond_t thread_cond;
pthread_mutex_t thread_mutex;
pthread_t thread_id;
void * thread_context;
int (*thread_proc_init) (void * context);
int (*thread_proc_pre) (void * context);
int (*thread_proc) (void * context);
int (*thread_proc_post) (void * context);
};
typedef pthread_t (* thelper_create_thread)(const char* name, void (*start)(void *), void* arg);
int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper,
int (*thread_proc_init) (void * context),
int (*thread_proc_pre) (void * context),
int (*thread_proc) (void * context),
int (*thread_proc_post) (void * context),
thelper_create_thread create_thread_cb,
void * context);
int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper);
int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper);
/* if only need to use signal */
int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper);
int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper);
int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper);
int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper);
int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ */

292
loc_api/libloc_api_50001/loc_eng_log.cpp
View file

@ -1,292 +0,0 @@
/* Copyright (c) 2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_NDDEBUG 0
#define LOG_TAG "LocSvc_eng"
#include "hardware/gps.h"
#include "loc.h"
#include "loc_log.h"
#include "loc_eng_log.h"
#include "loc_eng_msg_id.h"
/* GPS status names */
static loc_name_val_s_type gps_status_name[] =
{
NAME_VAL( GPS_STATUS_NONE ),
NAME_VAL( GPS_STATUS_SESSION_BEGIN ),
NAME_VAL( GPS_STATUS_SESSION_END ),
NAME_VAL( GPS_STATUS_ENGINE_ON ),
NAME_VAL( GPS_STATUS_ENGINE_OFF ),
};
static int gps_status_num = sizeof(gps_status_name) / sizeof(loc_name_val_s_type);
/* Find Android GPS status name */
const char* loc_get_gps_status_name(GpsStatusValue gps_status)
{
return loc_get_name_from_val(gps_status_name, gps_status_num,
(long) gps_status);
}
static loc_name_val_s_type loc_eng_msgs[] =
{
NAME_VAL( LOC_ENG_MSG_QUIT ),
NAME_VAL( LOC_ENG_MSG_ENGINE_DOWN ),
NAME_VAL( LOC_ENG_MSG_ENGINE_UP ),
NAME_VAL( LOC_ENG_MSG_START_FIX ),
NAME_VAL( LOC_ENG_MSG_STOP_FIX ),
NAME_VAL( LOC_ENG_MSG_SET_POSITION_MODE ),
NAME_VAL( LOC_ENG_MSG_SET_TIME ),
NAME_VAL( LOC_ENG_MSG_INJECT_XTRA_DATA ),
NAME_VAL( LOC_ENG_MSG_INJECT_LOCATION ),
NAME_VAL( LOC_ENG_MSG_DELETE_AIDING_DATA ),
NAME_VAL( LOC_ENG_MSG_SET_APN ),
NAME_VAL( LOC_ENG_MSG_SET_SERVER_URL ),
NAME_VAL( LOC_ENG_MSG_SET_SERVER_IPV4 ),
NAME_VAL( LOC_ENG_MSG_ENABLE_DATA ),
NAME_VAL( LOC_ENG_MSG_SUPL_VERSION ),
NAME_VAL( LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG ),
NAME_VAL( LOC_ENG_MSG_SET_SENSOR_PROPERTIES ),
NAME_VAL( LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG ),
NAME_VAL( LOC_ENG_MSG_MUTE_SESSION ),
NAME_VAL( LOC_ENG_MSG_ATL_OPEN_SUCCESS ),
NAME_VAL( LOC_ENG_MSG_ATL_CLOSED ),
NAME_VAL( LOC_ENG_MSG_ATL_OPEN_FAILED ),
NAME_VAL( LOC_ENG_MSG_REPORT_POSITION ),
NAME_VAL( LOC_ENG_MSG_REPORT_SV ),
NAME_VAL( LOC_ENG_MSG_REPORT_STATUS ),
NAME_VAL( LOC_ENG_MSG_REPORT_NMEA ),
NAME_VAL( LOC_ENG_MSG_REQUEST_ATL ),
NAME_VAL( LOC_ENG_MSG_RELEASE_ATL ),
NAME_VAL( LOC_ENG_MSG_REQUEST_BIT ),
NAME_VAL( LOC_ENG_MSG_RELEASE_BIT ),
NAME_VAL( LOC_ENG_MSG_REQUEST_NI ),
NAME_VAL( LOC_ENG_MSG_INFORM_NI_RESPONSE ),
NAME_VAL( LOC_ENG_MSG_REQUEST_XTRA_DATA ),
NAME_VAL( LOC_ENG_MSG_REQUEST_TIME )
};
static int loc_eng_msgs_num = sizeof(loc_eng_msgs) / sizeof(loc_name_val_s_type);
/* Find Android GPS status name */
const char* loc_get_msg_name(int id)
{
return loc_get_name_from_val(loc_eng_msgs, loc_eng_msgs_num, (long) id);
}
static loc_name_val_s_type loc_eng_position_modes[] =
{
NAME_VAL( LOC_POSITION_MODE_STANDALONE ),
NAME_VAL( LOC_POSITION_MODE_MS_BASED ),
NAME_VAL( LOC_POSITION_MODE_MS_ASSISTED ),
NAME_VAL( LOC_POSITION_MODE_RESERVED_1 ),
NAME_VAL( LOC_POSITION_MODE_RESERVED_2 ),
NAME_VAL( LOC_POSITION_MODE_RESERVED_3 ),
NAME_VAL( LOC_POSITION_MODE_RESERVED_4 )
};
static int loc_eng_position_mode_num = sizeof(loc_eng_position_modes) / sizeof(loc_name_val_s_type);
const char* loc_get_position_mode_name(GpsPositionMode mode)
{
return loc_get_name_from_val(loc_eng_position_modes, loc_eng_position_mode_num, (long) mode);
}
static loc_name_val_s_type loc_eng_position_recurrences[] =
{
NAME_VAL( GPS_POSITION_RECURRENCE_PERIODIC ),
NAME_VAL( GPS_POSITION_RECURRENCE_SINGLE )
};
static int loc_eng_position_recurrence_num = sizeof(loc_eng_position_recurrences) / sizeof(loc_name_val_s_type);
const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur)
{
return loc_get_name_from_val(loc_eng_position_recurrences, loc_eng_position_recurrence_num, (long) recur);
}
static loc_name_val_s_type loc_eng_aiding_data_bits[] =
{
NAME_VAL( GPS_DELETE_EPHEMERIS ),
NAME_VAL( GPS_DELETE_ALMANAC ),
NAME_VAL( GPS_DELETE_POSITION ),
NAME_VAL( GPS_DELETE_TIME ),
NAME_VAL( GPS_DELETE_IONO ),
NAME_VAL( GPS_DELETE_UTC ),
NAME_VAL( GPS_DELETE_HEALTH ),
NAME_VAL( GPS_DELETE_SVDIR ),
NAME_VAL( GPS_DELETE_SVSTEER ),
NAME_VAL( GPS_DELETE_SADATA ),
NAME_VAL( GPS_DELETE_RTI ),
NAME_VAL( GPS_DELETE_CELLDB_INFO )
#ifdef QCOM_FEATURE_DELEXT
,NAME_VAL( GPS_DELETE_ALMANAC_CORR ),
NAME_VAL( GPS_DELETE_FREQ_BIAS_EST ),
NAME_VAL( GPS_DELETE_EPHEMERIS_GLO ),
NAME_VAL( GPS_DELETE_ALMANAC_GLO ),
NAME_VAL( GPS_DELETE_SVDIR_GLO ),
NAME_VAL( GPS_DELETE_SVSTEER_GLO ),
NAME_VAL( GPS_DELETE_ALMANAC_CORR_GLO ),
NAME_VAL( GPS_DELETE_TIME_GPS ),
NAME_VAL( GPS_DELETE_TIME_GLO )
#endif
};
static int loc_eng_aiding_data_bit_num = sizeof(loc_eng_aiding_data_bits) / sizeof(loc_name_val_s_type);
const char* loc_get_aiding_data_mask_names(GpsAidingData data)
{
return NULL;
}
static loc_name_val_s_type loc_eng_agps_types[] =
{
#ifdef QCOM_FEATURE_IPV6
NAME_VAL( AGPS_TYPE_INVALID ),
NAME_VAL( AGPS_TYPE_ANY ),
#endif
NAME_VAL( AGPS_TYPE_SUPL ),
NAME_VAL( AGPS_TYPE_C2K )
#ifdef QCOM_FEATURE_IPV6
,NAME_VAL( AGPS_TYPE_WWAN_ANY )
#endif
};
static int loc_eng_agps_type_num = sizeof(loc_eng_agps_types) / sizeof(loc_name_val_s_type);
const char* loc_get_agps_type_name(AGpsType type)
{
return loc_get_name_from_val(loc_eng_agps_types, loc_eng_agps_type_num, (long) type);
}
static loc_name_val_s_type loc_eng_ni_types[] =
{
NAME_VAL( GPS_NI_TYPE_VOICE ),
NAME_VAL( GPS_NI_TYPE_UMTS_SUPL ),
NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE )
};
static int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type);
const char* loc_get_ni_type_name(GpsNiType type)
{
return loc_get_name_from_val(loc_eng_ni_types, loc_eng_ni_type_num, (long) type);
}
static loc_name_val_s_type loc_eng_ni_responses[] =
{
NAME_VAL( GPS_NI_RESPONSE_ACCEPT ),
NAME_VAL( GPS_NI_RESPONSE_DENY ),
NAME_VAL( GPS_NI_RESPONSE_DENY )
};
static int loc_eng_ni_reponse_num = sizeof(loc_eng_ni_responses) / sizeof(loc_name_val_s_type);
const char* loc_get_ni_response_name(GpsUserResponseType response)
{
return loc_get_name_from_val(loc_eng_ni_responses, loc_eng_ni_reponse_num, (long) response);
}
static loc_name_val_s_type loc_eng_ni_encodings[] =
{
NAME_VAL( GPS_ENC_NONE ),
NAME_VAL( GPS_ENC_SUPL_GSM_DEFAULT ),
NAME_VAL( GPS_ENC_SUPL_UTF8 ),
NAME_VAL( GPS_ENC_SUPL_UCS2 ),
NAME_VAL( GPS_ENC_UNKNOWN )
};
static int loc_eng_ni_encoding_num = sizeof(loc_eng_ni_encodings) / sizeof(loc_name_val_s_type);
const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding)
{
return loc_get_name_from_val(loc_eng_ni_encodings, loc_eng_ni_encoding_num, (long) encoding);
}
#ifdef QCOM_FEATURE_IPV6
static loc_name_val_s_type loc_eng_agps_bears[] =
{
NAME_VAL( AGPS_APN_BEARER_INVALID ),
NAME_VAL( AGPS_APN_BEARER_IPV4 ),
NAME_VAL( AGPS_APN_BEARER_IPV4 ),
NAME_VAL( AGPS_APN_BEARER_IPV4V6 )
};
static int loc_eng_agps_bears_num = sizeof(loc_eng_agps_bears) / sizeof(loc_name_val_s_type);
const char* loc_get_agps_bear_name(AGpsBearerType bearer)
{
return loc_get_name_from_val(loc_eng_agps_bears, loc_eng_agps_bears_num, (long) bearer);
}
#endif
static loc_name_val_s_type loc_eng_server_types[] =
{
NAME_VAL( LOC_AGPS_CDMA_PDE_SERVER ),
NAME_VAL( LOC_AGPS_CUSTOM_PDE_SERVER ),
NAME_VAL( LOC_AGPS_MPC_SERVER ),
NAME_VAL( LOC_AGPS_SUPL_SERVER )
};
static int loc_eng_server_types_num = sizeof(loc_eng_server_types) / sizeof(loc_name_val_s_type);
const char* loc_get_server_type_name(LocServerType type)
{
return loc_get_name_from_val(loc_eng_server_types, loc_eng_server_types_num, (long) type);
}
static loc_name_val_s_type loc_eng_position_sess_status_types[] =
{
NAME_VAL( LOC_SESS_SUCCESS ),
NAME_VAL( LOC_SESS_INTERMEDIATE ),
NAME_VAL( LOC_SESS_FAILURE )
};
static int loc_eng_position_sess_status_num = sizeof(loc_eng_position_sess_status_types) / sizeof(loc_name_val_s_type);
const char* loc_get_position_sess_status_name(enum loc_sess_status status)
{
return loc_get_name_from_val(loc_eng_position_sess_status_types, loc_eng_position_sess_status_num, (long) status);
}
static loc_name_val_s_type loc_eng_agps_status_names[] =
{
NAME_VAL( GPS_REQUEST_AGPS_DATA_CONN ),
NAME_VAL( GPS_RELEASE_AGPS_DATA_CONN ),
NAME_VAL( GPS_AGPS_DATA_CONNECTED ),
NAME_VAL( GPS_AGPS_DATA_CONN_DONE ),
NAME_VAL( GPS_AGPS_DATA_CONN_FAILED )
};
static int loc_eng_agps_status_num = sizeof(loc_eng_agps_status_names) / sizeof(loc_name_val_s_type);
const char* loc_get_agps_status_name(AGpsStatusValue status)
{
return loc_get_name_from_val(loc_eng_agps_status_names, loc_eng_agps_status_num, (long) status);
}

62
loc_api/libloc_api_50001/loc_eng_log.h
View file

@ -1,62 +0,0 @@
/* Copyright (c) 2011 Code Aurora Forum. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Code Aurora Forum, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef LOC_ENG_LOG_H
#define LOC_ENG_LOG_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <ctype.h>
#include <hardware/gps.h>
#include "loc_eng_msg_id.h"
const char* loc_get_gps_status_name(GpsStatusValue gps_status);
const char* loc_get_msg_name(int id);
const char* loc_get_position_mode_name(GpsPositionMode mode);
const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur);
const char* loc_get_aiding_data_mask_names(GpsAidingData data);
const char* loc_get_agps_type_name(AGpsType type);
const char* loc_get_ni_type_name(GpsNiType type);
const char* loc_get_ni_response_name(GpsUserResponseType response);
const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding);
#ifdef QCOM_FEATURE_IPV6
const char* loc_get_agps_bear_name(AGpsBearerType bear);
#endif
const char* loc_get_server_type_name(LocServerType type);
const char* loc_get_position_sess_status_name(enum loc_sess_status status);
const char* loc_get_agps_status_name(AGpsStatusValue status);
#ifdef __cplusplus
}
#endif
#endif /* LOC_ENG_LOG_H */

Some files were not shown because too many files have changed in this diff Show more