diff --git a/Android.mk b/Android.mk new file mode 100644 index 00000000..e2c5a56f --- /dev/null +++ b/Android.mk @@ -0,0 +1,5 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) +LOCAL_PATH := $(call my-dir) + +include $(call all-makefiles-under,$(LOCAL_PATH)) +endif diff --git a/android/Android.mk b/android/Android.mk new file mode 100644 index 00000000..d36b4712 --- /dev/null +++ b/android/Android.mk @@ -0,0 +1,56 @@ +ifneq ($(BUILD_TINY_ANDROID),true) + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE) +LOCAL_MODULE_OWNER := qti + +LOCAL_MODULE_TAGS := optional + +## Libs + +LOCAL_SHARED_LIBRARIES := \ + libutils \ + libcutils \ + liblog \ + libloc_core \ + libgps.utils \ + libdl \ + libloc_pla \ + liblocation_api \ + +LOCAL_SRC_FILES += \ + gps.c \ + loc.cpp \ + loc_geofence.cpp \ + GnssAPIClient.cpp \ + GeofenceAPIClient.cpp \ + +LOCAL_CFLAGS += \ + -Wunused-parameter \ + -fno-short-enums \ + -D_ANDROID_ \ + +ifeq ($(TARGET_BUILD_VARIANT),user) + LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER +endif + +ifeq ($(TARGET_USES_QCOM_BSP), true) +LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP +endif + +## Includes +LOCAL_C_INCLUDES:= \ + $(TARGET_OUT_HEADERS)/gps.utils \ + $(TARGET_OUT_HEADERS)/libloc_core \ + $(TARGET_OUT_HEADERS)/libloc_pla \ + $(TARGET_OUT_HEADERS)/liblocation_api \ + +LOCAL_PRELINK_MODULE := false +LOCAL_MODULE_RELATIVE_PATH := hw + +include $(BUILD_SHARED_LIBRARY) + +endif # not BUILD_TINY_ANDROID diff --git a/android/GeofenceAPIClient.cpp b/android/GeofenceAPIClient.cpp new file mode 100644 index 00000000..aeb4fd5e --- /dev/null +++ b/android/GeofenceAPIClient.cpp @@ -0,0 +1,242 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#define LOG_NDDEBUG 0 +#define LOG_TAG "LocSvc_GeofenceApiClient" + +#include +#include + +#include "GeofenceAPIClient.h" + +static void convertGpsLocation(Location& in, GpsLocation& out) +{ + memset(&out, 0, sizeof(GpsLocation)); + out.size = sizeof(GpsLocation); + if (in.flags & LOCATION_HAS_LAT_LONG_BIT) + out.flags |= GPS_LOCATION_HAS_LAT_LONG; + if (in.flags & LOCATION_HAS_ALTITUDE_BIT) + out.flags |= GPS_LOCATION_HAS_ALTITUDE; + if (in.flags & LOCATION_HAS_SPEED_BIT) + out.flags |= GPS_LOCATION_HAS_SPEED; + if (in.flags & LOCATION_HAS_BEARING_BIT) + out.flags |= GPS_LOCATION_HAS_BEARING; + if (in.flags & LOCATION_HAS_ACCURACY_BIT) + out.flags |= GPS_LOCATION_HAS_ACCURACY; + out.latitude = in.latitude; + out.longitude = in.longitude; + out.altitude = in.altitude; + out.speed = in.speed; + out.bearing = in.bearing; + out.accuracy = in.accuracy; + out.timestamp = (GpsUtcTime)in.timestamp; +} + +GeofenceAPIClient::GeofenceAPIClient(GpsGeofenceCallbacks* cbs) : + LocationAPIClientBase(), + mGpsGeofenceCallbacks(cbs) +{ + LOC_LOGD("%s]: (%p)", __func__, cbs); + + LocationCallbacks locationCallbacks; + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + locationCallbacks.batchingCb = nullptr; + + locationCallbacks.geofenceBreachCb = nullptr; + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_transition_callback) { + locationCallbacks.geofenceBreachCb = + [this](GeofenceBreachNotification geofenceBreachNotification) { + onGeofenceBreachCb(geofenceBreachNotification); + }; + } + + locationCallbacks.geofenceStatusCb = nullptr; + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_status_callback) { + locationCallbacks.geofenceStatusCb = + [this](GeofenceStatusNotification geofenceStatusNotification) { + onGeofenceStatusCb(geofenceStatusNotification); + }; + } + + locationCallbacks.gnssLocationInfoCb = nullptr; + locationCallbacks.gnssNiCb = nullptr; + locationCallbacks.gnssSvCb = nullptr; + locationCallbacks.gnssNmeaCb = nullptr; + locationCallbacks.gnssMeasurementsCb = nullptr; + + locAPISetCallbacks(locationCallbacks); +} + +void GeofenceAPIClient::geofenceAdd(uint32_t geofence_id, double latitude, double longitude, + double radius_meters, int last_transition, int monitor_transitions, + int notification_responsiveness_ms, int unknown_timer_ms) +{ + LOC_LOGD("%s]: (%d %f %f %f %d %d %d %d)", __func__, + geofence_id, latitude, longitude, radius_meters, + last_transition, monitor_transitions, notification_responsiveness_ms, unknown_timer_ms); + + GeofenceOption options; + memset(&options, 0, sizeof(GeofenceOption)); + options.size = sizeof(GeofenceOption); + if (monitor_transitions & GPS_GEOFENCE_ENTERED) + options.breachTypeMask |= GEOFENCE_BREACH_ENTER_BIT; + if (monitor_transitions & GPS_GEOFENCE_EXITED) + options.breachTypeMask |= GEOFENCE_BREACH_EXIT_BIT; + options.responsiveness = notification_responsiveness_ms; + + GeofenceInfo data; + data.size = sizeof(GeofenceInfo); + data.latitude = latitude; + data.longitude = longitude; + data.radius = radius_meters; + + locAPIAddGeofences(1, &geofence_id, &options, &data); +} + +void GeofenceAPIClient::geofencePause(uint32_t geofence_id) +{ + LOC_LOGD("%s]: (%d)", __func__, geofence_id); + locAPIPauseGeofences(1, &geofence_id); +} + +void GeofenceAPIClient::geofenceResume(uint32_t geofence_id, int monitor_transitions) +{ + LOC_LOGD("%s]: (%d %d)", __func__, geofence_id, monitor_transitions); + GeofenceBreachTypeMask mask = 0; + if (monitor_transitions & GPS_GEOFENCE_ENTERED) + mask |= GEOFENCE_BREACH_ENTER_BIT; + if (monitor_transitions & GPS_GEOFENCE_EXITED) + mask |= GEOFENCE_BREACH_EXIT_BIT; + locAPIResumeGeofences(1, &geofence_id, &mask); +} + +void GeofenceAPIClient::geofenceRemove(uint32_t geofence_id) +{ + LOC_LOGD("%s]: (%d)", __func__, geofence_id); + locAPIRemoveGeofences(1, &geofence_id); +} + +// callbacks +void GeofenceAPIClient::onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification) +{ + LOC_LOGD("%s]: (%zu)", __func__, geofenceBreachNotification.count); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_transition_callback) { + for (size_t i = 0; i < geofenceBreachNotification.count; i++) { + GpsLocation location; + convertGpsLocation(geofenceBreachNotification.location, location); + + uint32_t transition; + if (geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER) + transition = GPS_GEOFENCE_ENTERED; + else if (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT) + transition = GPS_GEOFENCE_EXITED; + else { + // continue with other breach if transition is + // nether GPS_GEOFENCE_ENTERED nor GPS_GEOFENCE_EXITED + continue; + } + GpsUtcTime time = geofenceBreachNotification.timestamp; + + mGpsGeofenceCallbacks->geofence_transition_callback(geofenceBreachNotification.ids[i], + &location, transition, time); + } + } +} + +void GeofenceAPIClient::onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification) +{ + LOC_LOGD("%s]: (%d)", __func__, geofenceStatusNotification.available); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_status_callback) { + int32_t status = GPS_GEOFENCE_UNAVAILABLE; + if (geofenceStatusNotification.available == GEOFENCE_STATUS_AVAILABILE_YES) { + status = GPS_GEOFENCE_AVAILABLE; + } + mGpsGeofenceCallbacks->geofence_status_callback(status, nullptr); + } +} + +void GeofenceAPIClient::onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __func__, count); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_add_callback) { + for (size_t i = 0; i < count; i++) { + int32_t status = GPS_GEOFENCE_ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = GPS_GEOFENCE_OPERATION_SUCCESS; + mGpsGeofenceCallbacks->geofence_add_callback(ids[i], status); + } + } +} + +void GeofenceAPIClient::onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __func__, count); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_remove_callback) { + for (size_t i = 0; i < count; i++) { + int32_t status = GPS_GEOFENCE_ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = GPS_GEOFENCE_OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = GPS_GEOFENCE_ERROR_ID_UNKNOWN; + mGpsGeofenceCallbacks->geofence_remove_callback(ids[i], status); + } + } +} + +void GeofenceAPIClient::onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __func__, count); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_pause_callback) { + for (size_t i = 0; i < count; i++) { + int32_t status = GPS_GEOFENCE_ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = GPS_GEOFENCE_OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = GPS_GEOFENCE_ERROR_ID_UNKNOWN; + mGpsGeofenceCallbacks->geofence_pause_callback(ids[i], status); + } + } +} + +void GeofenceAPIClient::onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __func__, count); + if (mGpsGeofenceCallbacks && mGpsGeofenceCallbacks->geofence_resume_callback) { + for (size_t i = 0; i < count; i++) { + int32_t status = GPS_GEOFENCE_ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = GPS_GEOFENCE_OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = GPS_GEOFENCE_ERROR_ID_UNKNOWN; + mGpsGeofenceCallbacks->geofence_resume_callback(ids[i], status); + } + } +} diff --git a/loc_api/libloc_api_50001/loc_eng_log.h b/android/GeofenceAPIClient.h similarity index 52% rename from loc_api/libloc_api_50001/loc_eng_log.h rename to android/GeofenceAPIClient.h index a68bd847..e99d6ba2 100644 --- a/loc_api/libloc_api_50001/loc_eng_log.h +++ b/android/GeofenceAPIClient.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -27,18 +27,34 @@ * */ -#ifndef LOC_ENG_LOG_H -#define LOC_ENG_LOG_H +#ifndef GEOFENCE_API_CLINET_H +#define GEOFENCE_API_CLINET_H -#ifdef __cplusplus -extern "C" +#include +#include + +class GeofenceAPIClient : public LocationAPIClientBase { -#endif +public: + GeofenceAPIClient(GpsGeofenceCallbacks* cbs); + virtual ~GeofenceAPIClient() = default; -#include + void geofenceAdd(uint32_t geofence_id, double latitude, double longitude, + double radius_meters, int last_transition, int monitor_transitions, + int notification_responsiveness_ms, int unknown_timer_ms); + void geofencePause(uint32_t geofence_id); + void geofenceResume(uint32_t geofence_id, int monitor_transitions); + void geofenceRemove(uint32_t geofence_id); -#ifdef __cplusplus -} -#endif + // callbacks + void onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification) final; + void onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification) final; + void onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; -#endif /* LOC_ENG_LOG_H */ +private: + GpsGeofenceCallbacks* mGpsGeofenceCallbacks; +}; +#endif // GEOFENCE_API_CLINET_H diff --git a/android/GnssAPIClient.cpp b/android/GnssAPIClient.cpp new file mode 100644 index 00000000..915a82e7 --- /dev/null +++ b/android/GnssAPIClient.cpp @@ -0,0 +1,765 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#define LOG_NDDEBUG 0 +#define LOG_TAG "LocSvc_GnssAPIClient" + +#include +#include + +#include "GnssAPIClient.h" + +static void convertGpsLocation(Location& in, GpsLocation& out); +static void convertGpsSvStatus(GnssSvNotification& in, GpsSvStatus& out); +static void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out); +static void convertGnssSvStatus(GnssSvNotification& in, GnssSvStatus& out); +static void convertGpsMeasurement(GnssMeasurementsData& in, GpsMeasurement& out); +static void convertGpsClock(GnssMeasurementsClock& in, GpsClock& out); +static void convertGpsData(GnssMeasurementsNotification& in, GpsData& out); +static void convertGnssClock(GnssMeasurementsClock& in, GnssClock& out); +static void convertGnssData(GnssMeasurementsNotification& in, GnssData& out); + +GnssAPIClient::GnssAPIClient(GpsCallbacks* gpsCb, + GpsNiCallbacks* niCb, + GpsMeasurementCallbacks* measurementCb) : + LocationAPIClientBase(), + mGpsCallbacks(nullptr), + mGpsNiCallbacks(nullptr), + mLocationCapabilitiesMask(0), + mGpsMeasurementCallbacks(nullptr) +{ + LOC_LOGD("%s]: (%p %p %p)", __func__, gpsCb, niCb, measurementCb); + pthread_mutex_init(&mLock, nullptr); + + // set default LocationOptions. + memset(&mLocationOptions, 0, sizeof(LocationOptions)); + mLocationOptions.size = sizeof(LocationOptions); + mLocationOptions.minInterval = 1000; + mLocationOptions.minDistance = 0; + mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE; + + gnssUpdateCallbacks(gpsCb, niCb, measurementCb); +} + +GnssAPIClient::~GnssAPIClient() +{ + LOC_LOGD("%s]: ()", __func__); + pthread_mutex_destroy(&mLock); +} + +// for GpsInterface +void GnssAPIClient::gnssUpdateCallbacks(GpsCallbacks* gpsCb, + GpsNiCallbacks* niCb, + GpsMeasurementCallbacks* measurementCb) +{ + LOC_LOGD("%s]: (%p %p %p)", __func__, gpsCb, niCb, measurementCb); + + mGpsCallbacks = gpsCb; + mGpsNiCallbacks = niCb; + mGpsMeasurementCallbacks = measurementCb; + + LocationCallbacks locationCallbacks; + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + if (mGpsCallbacks && mGpsCallbacks->location_cb) { + locationCallbacks.trackingCb = [this](Location location) { + onTrackingCb(location); + }; + } + + locationCallbacks.batchingCb = nullptr; + locationCallbacks.geofenceBreachCb = nullptr; + locationCallbacks.geofenceStatusCb = nullptr; + locationCallbacks.gnssLocationInfoCb = nullptr; + + locationCallbacks.gnssNiCb = nullptr; + if (mGpsNiCallbacks && mGpsNiCallbacks->notify_cb) { + locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotification) { + onGnssNiCb(id, gnssNiNotification); + }; + } + + locationCallbacks.gnssSvCb = nullptr; + if (mGpsCallbacks && mGpsCallbacks->sv_status_cb) { + locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) { + onGnssSvCb(gnssSvNotification); + }; + } + + locationCallbacks.gnssNmeaCb = nullptr; + if (mGpsCallbacks && mGpsCallbacks->nmea_cb) { + locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) { + onGnssNmeaCb(gnssNmeaNotification); + }; + } + + locationCallbacks.gnssMeasurementsCb = nullptr; + if (mGpsMeasurementCallbacks && + (mGpsMeasurementCallbacks->measurement_callback || + mGpsMeasurementCallbacks->gnss_measurement_callback)) { + locationCallbacks.gnssMeasurementsCb = + [this](GnssMeasurementsNotification gnssMeasurementsNotification) { + onGnssMeasurementsCb(gnssMeasurementsNotification); + }; + } + + locAPISetCallbacks(locationCallbacks); +} + +int GnssAPIClient::gnssStart() +{ + LOC_LOGD("%s]: ()", __func__); + int retVal = 0; + locAPIStartTracking(mLocationOptions); + return retVal; +} + +int GnssAPIClient::gnssStop() +{ + LOC_LOGD("%s]: ()", __func__); + int retVal = 0; + locAPIStopTracking(); + return retVal; +} + +void GnssAPIClient::gnssDeleteAidingData(GpsAidingData f) +{ + LOC_LOGD("%s]: (%02x)", __func__, f); + GnssAidingData data; + memset(&data, 0, sizeof (GnssAidingData)); + data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS | + GNSS_AIDING_DATA_SV_TYPE_GLONASS | + GNSS_AIDING_DATA_SV_TYPE_QZSS | + GNSS_AIDING_DATA_SV_TYPE_BEIDOU | + GNSS_AIDING_DATA_SV_TYPE_GALILEO; + + if (f == GPS_DELETE_ALL) + data.deleteAll = true; + else { + if (f & GPS_DELETE_EPHEMERIS) data.sv.svMask |= GNSS_AIDING_DATA_SV_EPHEMERIS; + if (f & GPS_DELETE_ALMANAC) data.sv.svMask |= GNSS_AIDING_DATA_SV_ALMANAC; + if (f & GPS_DELETE_POSITION) data.common.mask |= GNSS_AIDING_DATA_COMMON_POSITION; + if (f & GPS_DELETE_TIME) data.common.mask |= GNSS_AIDING_DATA_COMMON_TIME; + if (f & GPS_DELETE_IONO) data.sv.svMask |= GNSS_AIDING_DATA_SV_IONOSPHERE; + if (f & GPS_DELETE_UTC) data.common.mask |= GNSS_AIDING_DATA_COMMON_UTC; + if (f & GPS_DELETE_HEALTH) data.sv.svMask |= GNSS_AIDING_DATA_SV_HEALTH; + if (f & GPS_DELETE_SVDIR) data.sv.svMask |= GNSS_AIDING_DATA_SV_DIRECTION; + if (f & GPS_DELETE_SVSTEER) data.sv.svMask |= GNSS_AIDING_DATA_SV_STEER; + if (f & GPS_DELETE_SADATA) data.sv.svMask |= GNSS_AIDING_DATA_SV_SA_DATA; + if (f & GPS_DELETE_RTI) data.common.mask |= GNSS_AIDING_DATA_COMMON_RTI; + if (f & GPS_DELETE_CELLDB_INFO) data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB; + } + locAPIGnssDeleteAidingData(data); +} + +int GnssAPIClient::gnssSetPositionMode(GpsPositionMode mode, GpsPositionRecurrence recurrence, + uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time) +{ + LOC_LOGD("%s]: (%d %d %d %d %d)", __func__, + mode, recurrence, min_interval, preferred_accuracy, preferred_time); + int retVal = 0; + memset(&mLocationOptions, 0, sizeof(LocationOptions)); + mLocationOptions.size = sizeof(LocationOptions); + mLocationOptions.minInterval = min_interval; + mLocationOptions.minDistance = preferred_accuracy; + if (mode == GPS_POSITION_MODE_STANDALONE) + mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE; + else if (mode == GPS_POSITION_MODE_MS_BASED) + mLocationOptions.mode = GNSS_SUPL_MODE_MSB; + else if (mode == GPS_POSITION_MODE_MS_ASSISTED) + mLocationOptions.mode = GNSS_SUPL_MODE_MSA; + return retVal; +} + +// for AGpsInterface +void GnssAPIClient::gnssAgnssSetServer(AGpsType type, const char *hostname, int port) +{ + LOC_LOGD("%s]: (%d %s %d)", __func__, type, hostname, port); + GnssConfig data; + memset(&data, 0, sizeof(GnssConfig)); + data.size = sizeof(GnssConfig); + data.flags |= GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT; + + memset(&data.assistanceServer, 0, sizeof(GnssConfigSetAssistanceServer)); + data.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer); + if (type == AGPS_TYPE_SUPL) + data.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL; + else if (type == AGPS_TYPE_C2K) + data.assistanceServer.type = GNSS_ASSISTANCE_TYPE_C2K; + data.assistanceServer.hostName = hostname; + data.assistanceServer.port = port; + + locAPIGnssUpdateConfig(data); +} + +// for GpsNiInterface +void GnssAPIClient::gnssNiRespond(int notif_id, GpsUserResponseType user_response) +{ + LOC_LOGD("%s]: (%d %d)", __func__, notif_id, user_response); + GnssNiResponse data = GNSS_NI_RESPONSE_IGNORE; + if (user_response == GPS_NI_RESPONSE_ACCEPT) data = GNSS_NI_RESPONSE_ACCEPT; + else if (user_response == GPS_NI_RESPONSE_DENY) data = GNSS_NI_RESPONSE_DENY; + else if (user_response == GPS_NI_RESPONSE_NORESP) data = GNSS_NI_RESPONSE_NO_RESPONSE; + locAPIGnssNiResponse(notif_id, data); +} + +// for GpsMeasurementInterface +void GnssAPIClient::gnssMeasurementClose() { + LOC_LOGD("%s]: ()", __func__); + pthread_mutex_lock(&mLock); + mGpsMeasurementCallbacks = nullptr; + pthread_mutex_unlock(&mLock); +} + +// for GnssConfigurationInterface +void GnssAPIClient::gnssConfigurationUpdate(const char* config_data, int32_t length) +{ + LOC_LOGD("%s]: (%s %d)", __func__, config_data, length); + int n = 10; + uint8_t flags[n]; + memset(&flags, 0, sizeof(uint8_t) * n); + + GnssConfig data; + memset(&data, 0, sizeof(GnssConfig)); + data.size = sizeof(GnssConfig); + + const loc_param_s_type gnssConfTable[] = + { + {"GPS_LOCK", &data.gpsLock, flags+0, 'n'}, + {"SUPL_VER", &data.suplVersion, flags+1, 'n'}, + //{"ASSISTANCE_SERVER", &data.assistanceServer, nullptr, 's'}, + {"LPP_PROFILE", &data.lppProfile, flags+3, 'n'}, + {"LPPE_CP_TECHNOLOGY", &data.lppeControlPlaneMask, flags+4, 'n'}, + {"LPPE_UP_TECHNOLOGY", &data.lppeUserPlaneMask, flags+5, 'n'}, + {"A_GLONASS_POS_PROTOCOL_SELECT", &data.aGlonassPositionProtocolMask, flags+6, 'n'}, + {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL",&data.emergencyPdnForEmergencySupl, flags+7, 'n'}, + {"SUPL_ES", &data.suplEmergencyServices, flags+8, 'n'}, + {"SUPL_MODE", &data.suplModeMask, flags+9, 'n'}, + }; + UTIL_UPDATE_CONF(config_data, length, gnssConfTable); + + for (int i = 0; i < n; i++) { + if (flags[i] != 0) + data.flags |= (0x1 << i); + } + locAPIGnssUpdateConfig(data); +} + +// callbacks +void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) +{ + LOC_LOGD("%s]: (%02x)", __func__, capabilitiesMask); + mLocationCapabilitiesMask = capabilitiesMask; + if (mGpsCallbacks && mGpsCallbacks->set_capabilities_cb) { + uint32_t data = 0; + if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT)) + data |= GPS_CAPABILITY_SCHEDULING; + if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT) + data |= GPS_CAPABILITY_GEOFENCING; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) + data |= GPS_CAPABILITY_MEASUREMENTS; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) + data |= GPS_CAPABILITY_MSB; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT) + data |= GPS_CAPABILITY_MSA; + mGpsCallbacks->set_capabilities_cb(data); + } + if (mGpsCallbacks && mGpsCallbacks->set_system_info_cb) { + GnssSystemInfo info; + info.size = sizeof(GnssSystemInfo); + info.year_of_hw = 2015; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { + info.year_of_hw = 2017; + } + LOC_LOGV("%s:%d] set_system_info_cb (%d)", __func__, __LINE__, info.year_of_hw); + mGpsCallbacks->set_system_info_cb(&info); + } +} + +void GnssAPIClient::onTrackingCb(Location location) +{ + LOC_LOGD("%s]: (flags: %02x)", __func__, location.flags); + if (mGpsCallbacks && mGpsCallbacks->location_cb) { + GpsLocation data; + convertGpsLocation(location, data); + mGpsCallbacks->location_cb(&data); + } +} + +void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) +{ + LOC_LOGD("%s]: (id: %d)", __func__, id); + if (mGpsNiCallbacks && mGpsNiCallbacks->notify_cb) { + GpsNiNotification data; + memset(&data, 0, sizeof(GpsNiNotification)); + data.size = sizeof(GpsNiNotification); + data.notification_id = id; + + if (gnssNiNotification.type == GNSS_NI_TYPE_VOICE) + data.ni_type = GPS_NI_TYPE_VOICE; + else if (gnssNiNotification.type == GNSS_NI_TYPE_SUPL) + data.ni_type = GPS_NI_TYPE_UMTS_SUPL; + else if (gnssNiNotification.type == GNSS_NI_TYPE_CONTROL_PLANE) + data.ni_type = GPS_NI_TYPE_UMTS_CTRL_PLANE; + // GNSS_NI_TYPE_EMERGENCY_SUPL not supported + + if (gnssNiNotification.options == GNSS_NI_OPTIONS_NOTIFICATION) + data.notify_flags = GPS_NI_NEED_NOTIFY; + else if (gnssNiNotification.options == GNSS_NI_OPTIONS_VERIFICATION) + data.notify_flags = GPS_NI_NEED_VERIFY; + else if (gnssNiNotification.options == GNSS_NI_OPTIONS_PRIVACY_OVERRIDE) + data.notify_flags = GPS_NI_PRIVACY_OVERRIDE; + + data.timeout = gnssNiNotification.timeout; + if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_ACCEPT) + data.default_response = GPS_NI_RESPONSE_ACCEPT; + else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_DENY) + data.default_response = GPS_NI_RESPONSE_DENY; + else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_NO_RESPONSE || + gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_IGNORE) + data.default_response = GPS_NI_RESPONSE_NORESP; + + int len = GPS_NI_SHORT_STRING_MAXLEN < GNSS_NI_REQUESTOR_MAX + ? GPS_NI_SHORT_STRING_MAXLEN : GNSS_NI_REQUESTOR_MAX; + memcpy(data.requestor_id, gnssNiNotification.requestor, len); + + len = GPS_NI_LONG_STRING_MAXLEN < GNSS_NI_MESSAGE_ID_MAX + ? GPS_NI_LONG_STRING_MAXLEN : GNSS_NI_MESSAGE_ID_MAX; + memcpy(data.text, gnssNiNotification.message, len); + + if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_NONE) + data.requestor_id_encoding = GPS_ENC_NONE; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT) + data.requestor_id_encoding = GPS_ENC_SUPL_GSM_DEFAULT; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UTF8) + data.requestor_id_encoding = GPS_ENC_SUPL_UTF8; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UCS2) + data.requestor_id_encoding = GPS_ENC_SUPL_UCS2; + + if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_NONE) + data.text_encoding = GPS_ENC_NONE; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT) + data.text_encoding = GPS_ENC_SUPL_GSM_DEFAULT; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UTF8) + data.text_encoding = GPS_ENC_SUPL_UTF8; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UCS2) + data.text_encoding = GPS_ENC_SUPL_UCS2; + data.text_encoding = gnssNiNotification.messageEncoding; + + memcpy(data.extras, gnssNiNotification.extras, len); + + mGpsNiCallbacks->notify_cb(&data); + } +} + +void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification) +{ + LOC_LOGD("%s]: (count: %zu)", __func__, gnssSvNotification.count); + if (mGpsCallbacks && mGpsCallbacks->sv_status_cb) { + GpsSvStatus data; + convertGpsSvStatus(gnssSvNotification, data); + mGpsCallbacks->sv_status_cb(&data); + } + if (mGpsCallbacks && mGpsCallbacks->gnss_sv_status_cb) { + GnssSvStatus data; + convertGnssSvStatus(gnssSvNotification, data); + mGpsCallbacks->gnss_sv_status_cb(&data); + } +} + +void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) +{ + if (mGpsCallbacks && mGpsCallbacks->nmea_cb) { + mGpsCallbacks->nmea_cb((GpsUtcTime)gnssNmeaNotification.timestamp, + gnssNmeaNotification.nmea, gnssNmeaNotification.length); + } +} + +void GnssAPIClient::onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) +{ + LOC_LOGD("%s]: (count: %zu)", __func__, gnssMeasurementsNotification.count); + // we don't need to lock the mutext + // if mGpsMeasurementCallbacks is set to nullptr + if (mGpsMeasurementCallbacks) { + pthread_mutex_lock(&mLock); + if (mGpsMeasurementCallbacks) { + if (mGpsMeasurementCallbacks->measurement_callback) { + GpsData data; + convertGpsData(gnssMeasurementsNotification, data); + mGpsMeasurementCallbacks->measurement_callback(&data); + } + if (mGpsMeasurementCallbacks->gnss_measurement_callback) { + GnssData data; + convertGnssData(gnssMeasurementsNotification, data); + mGpsMeasurementCallbacks->gnss_measurement_callback(&data); + } + } + pthread_mutex_unlock(&mLock); + } +} + +void GnssAPIClient::onStartTrackingCb(LocationError error) +{ + LOC_LOGD("%s]: (%d)", __func__, error); + if (error == LOCATION_ERROR_SUCCESS && mGpsCallbacks && mGpsCallbacks->status_cb) { + GpsStatus data; + data.size = sizeof(GpsStatus); + data.status = GPS_STATUS_ENGINE_ON; + mGpsCallbacks->status_cb(&data); + data.status = GPS_STATUS_SESSION_BEGIN; + mGpsCallbacks->status_cb(&data); + } +} + +void GnssAPIClient::onStopTrackingCb(LocationError error) +{ + LOC_LOGD("%s]: (%d)", __func__, error); + if (error == LOCATION_ERROR_SUCCESS && mGpsCallbacks && mGpsCallbacks->status_cb) { + GpsStatus data; + data.size = sizeof(GpsStatus); + data.status = GPS_STATUS_SESSION_END; + mGpsCallbacks->status_cb(&data); + data.status = GPS_STATUS_ENGINE_OFF; + mGpsCallbacks->status_cb(&data); + } +} + +static void convertGpsLocation(Location& in, GpsLocation& out) +{ + memset(&out, 0, sizeof(GpsLocation)); + out.size = sizeof(GpsLocation); + if (in.flags & LOCATION_HAS_LAT_LONG_BIT) + out.flags |= GPS_LOCATION_HAS_LAT_LONG; + if (in.flags & LOCATION_HAS_ALTITUDE_BIT) + out.flags |= GPS_LOCATION_HAS_ALTITUDE; + if (in.flags & LOCATION_HAS_SPEED_BIT) + out.flags |= GPS_LOCATION_HAS_SPEED; + if (in.flags & LOCATION_HAS_BEARING_BIT) + out.flags |= GPS_LOCATION_HAS_BEARING; + if (in.flags & LOCATION_HAS_ACCURACY_BIT) + out.flags |= GPS_LOCATION_HAS_ACCURACY; + out.latitude = in.latitude; + out.longitude = in.longitude; + out.altitude = in.altitude; + out.speed = in.speed; + out.bearing = in.bearing; + out.accuracy = in.accuracy; + out.timestamp = (GpsUtcTime)in.timestamp; +} + +static void convertGpsSvStatus(GnssSvNotification& in, GpsSvStatus& out) +{ + memset(&out, 0, sizeof(GpsSvStatus)); + out.size = sizeof(GpsSvStatus); + out.num_svs = in.count; + int len = GPS_MAX_SVS < GNSS_SV_MAX ? GPS_MAX_SVS : GNSS_SV_MAX; + for (int i = 0; i < len; i++) { + GpsSvInfo& info = out.sv_list[i]; + info.size = sizeof(GpsSvInfo); + info.prn = in.gnssSvs[i].svId; + info.snr = in.gnssSvs[i].cN0Dbhz; + info.elevation = in.gnssSvs[i].elevation; + info.azimuth = in.gnssSvs[i].azimuth; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT) + out.ephemeris_mask |= 0x1 < i; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT) + out.almanac_mask |= 0x1 < i; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT) + out.used_in_fix_mask |= 0x1 < i; + } +} + +static void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out) +{ + switch(in) { + case GNSS_SV_TYPE_GPS: + out = GNSS_CONSTELLATION_GPS; + break; + case GNSS_SV_TYPE_SBAS: + out = GNSS_CONSTELLATION_SBAS; + break; + case GNSS_SV_TYPE_GLONASS: + out = GNSS_CONSTELLATION_GLONASS; + break; + case GNSS_SV_TYPE_QZSS: + out = GNSS_CONSTELLATION_QZSS; + break; + case GNSS_SV_TYPE_BEIDOU: + out = GNSS_CONSTELLATION_BEIDOU; + break; + case GNSS_SV_TYPE_GALILEO: + out = GNSS_CONSTELLATION_GALILEO; + break; + default: + out = GNSS_CONSTELLATION_UNKNOWN; + break; + } +} + +static void convertGnssSvStatus(GnssSvNotification& in, GnssSvStatus& out) +{ + memset(&out, 0, sizeof(GnssSvStatus)); + out.size = sizeof(GnssSvStatus); + out.num_svs = in.count; + int len = GNSS_MAX_SVS < GNSS_SV_MAX ? GNSS_MAX_SVS : GNSS_SV_MAX; + for (int i = 0; i < len; i++) { + GnssSvInfo& info = out.gnss_sv_list[i]; + info.size = sizeof(GnssSvInfo); + info.svid = in.gnssSvs[i].svId; + convertGnssConstellationType(in.gnssSvs[i].type, info.constellation); + info.c_n0_dbhz = in.gnssSvs[i].cN0Dbhz; + info.elevation = in.gnssSvs[i].elevation; + info.azimuth = in.gnssSvs[i].azimuth; + info.flags = GNSS_SV_FLAGS_NONE; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT) + info.flags |= GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT) + info.flags |= GNSS_SV_FLAGS_HAS_ALMANAC_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT) + info.flags |= GNSS_SV_FLAGS_USED_IN_FIX; + } +} + +static void convertGpsMeasurement(GnssMeasurementsData& in, GpsMeasurement& out) +{ + memset(&out, 0, sizeof(GpsMeasurement)); + out.size = sizeof(GpsMeasurement); + if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT) + out.flags |= GPS_MEASUREMENT_HAS_SNR; + if (in.flags & GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT) + out.flags |= GPS_MEASUREMENT_HAS_PSEUDORANGE; + if (in.flags & GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT) + out.flags |= GPS_MEASUREMENT_HAS_PSEUDORANGE_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT) + out.flags |= GPS_MEASUREMENT_HAS_CARRIER_FREQUENCY; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT) + out.flags |= GPS_MEASUREMENT_HAS_CARRIER_CYCLES; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT) + out.flags |= GPS_MEASUREMENT_HAS_CARRIER_PHASE; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT) + out.flags |= GPS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY; + out.prn = in.svId; + out.time_offset_ns = in.timeOffsetNs; + out.state = GNSS_MEASUREMENT_STATE_UNKNOWN; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT) + out.state |= GPS_MEASUREMENT_STATE_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT) + out.state |= GPS_MEASUREMENT_STATE_BIT_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT) + out.state |= GPS_MEASUREMENT_STATE_SUBFRAME_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT) + out.state |= GPS_MEASUREMENT_STATE_TOW_DECODED; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT) + out.state |= GPS_MEASUREMENT_STATE_MSEC_AMBIGUOUS; + out.received_gps_tow_ns = in.receivedSvTimeNs; + out.received_gps_tow_uncertainty_ns = in.receivedSvTimeUncertaintyNs; + out.c_n0_dbhz = in.carrierToNoiseDbHz; + out.pseudorange_rate_mps = in.pseudorangeRateMps; + out.pseudorange_rate_uncertainty_mps = in.pseudorangeRateUncertaintyMps; + out.accumulated_delta_range_state = GNSS_ADR_STATE_UNKNOWN; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT) + out.accumulated_delta_range_state |= GPS_ADR_STATE_VALID; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT) + out.accumulated_delta_range_state |= GPS_ADR_STATE_RESET; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT) + out.accumulated_delta_range_state |= GPS_ADR_STATE_CYCLE_SLIP; + out.accumulated_delta_range_m = in.adrMeters; + out.accumulated_delta_range_uncertainty_m = in.adrUncertaintyMeters; + out.carrier_frequency_hz = in.carrierFrequencyHz; + out.carrier_cycles = in.carrierCycles; + out.carrier_phase = in.carrierPhase; + out.carrier_phase_uncertainty = in.carrierPhaseUncertainty; + out.loss_of_lock = GPS_LOSS_OF_LOCK_UNKNOWN; + out.multipath_indicator = GPS_MULTIPATH_INDICATOR_UNKNOWN; + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT) + out.multipath_indicator |= GPS_MULTIPATH_INDICATOR_DETECTED; + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT) + out.multipath_indicator |= GPS_MULTIPATH_INDICATOR_NOT_USED; + out.snr_db = in.signalToNoiseRatioDb; +} + +static void convertGpsClock(GnssMeasurementsClock& in, GpsClock& out) +{ + memset(&out, 0, sizeof(GpsClock)); + out.size = sizeof(GpsClock); + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT) + out.flags |= GPS_CLOCK_HAS_LEAP_SECOND; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT) + out.flags |= GPS_CLOCK_HAS_TIME_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT) + out.flags |= GPS_CLOCK_HAS_FULL_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT) + out.flags |= GPS_CLOCK_HAS_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT) + out.flags |= GPS_CLOCK_HAS_BIAS_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT) + out.flags |= GPS_CLOCK_HAS_DRIFT; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT) + out.flags |= GPS_CLOCK_HAS_DRIFT_UNCERTAINTY; + out.leap_second = in.leapSecond; + out.type = GPS_CLOCK_TYPE_UNKNOWN; + out.time_ns = in.timeNs; + out.time_uncertainty_ns = in.timeUncertaintyNs; + out.full_bias_ns = in.fullBiasNs; + out.bias_ns = in.biasNs; + out.bias_uncertainty_ns = in.biasUncertaintyNs; + out.drift_nsps = in.driftNsps; + out.drift_uncertainty_nsps = in.driftUncertaintyNsps; +} + +static void convertGpsData(GnssMeasurementsNotification& in, GpsData& out) +{ + memset(&out, 0, sizeof(GpsData)); + out.size = sizeof(GpsData); + out.measurement_count = in.count; + int len = GPS_MAX_MEASUREMENT < GNSS_MEASUREMENTS_MAX + ? GPS_MAX_MEASUREMENT : GNSS_MEASUREMENTS_MAX; + for (int i = 0; i < len; i++) { + convertGpsMeasurement(in.measurements[i], out.measurements[i]); + } + convertGpsClock(in.clock, out.clock); +} + +static void convertGnssMeasurement(GnssMeasurementsData& in, GnssMeasurement& out) +{ + memset(&out, 0, sizeof(GnssMeasurement)); + out.size = sizeof(GnssMeasurement); + if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT) + out.flags |= GNSS_MEASUREMENT_HAS_SNR; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT) + out.flags |= GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT) + out.flags |= GNSS_MEASUREMENT_HAS_CARRIER_CYCLES; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT) + out.flags |= GNSS_MEASUREMENT_HAS_CARRIER_PHASE; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT) + out.flags |= GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY; + out.svid = in.svId; + convertGnssConstellationType(in.svType, out.constellation); + out.time_offset_ns = in.timeOffsetNs; + out.state = GNSS_MEASUREMENT_STATE_UNKNOWN; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT) + out.state |= GNSS_MEASUREMENT_STATE_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_BIT_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT) + out.state |= GNSS_MEASUREMENT_STATE_TOW_DECODED; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT) + out.state |= GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_SYMBOL_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT) + out.state |= GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT) + out.state |= GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT) + out.state |= GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT) + out.state |= GNSS_MEASUREMENT_STATE_SBAS_SYNC; + out.received_sv_time_in_ns = in.receivedSvTimeNs; + out.received_sv_time_uncertainty_in_ns = in.receivedSvTimeUncertaintyNs; + out.c_n0_dbhz = in.carrierToNoiseDbHz; + out.pseudorange_rate_mps = in.pseudorangeRateMps; + out.pseudorange_rate_uncertainty_mps = in.pseudorangeRateUncertaintyMps; + out.accumulated_delta_range_state = GNSS_ADR_STATE_UNKNOWN; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT) + out.accumulated_delta_range_state |= GNSS_ADR_STATE_VALID; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT) + out.accumulated_delta_range_state |= GNSS_ADR_STATE_RESET; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT) + out.accumulated_delta_range_state |= GNSS_ADR_STATE_CYCLE_SLIP; + out.accumulated_delta_range_m = in.adrMeters; + out.accumulated_delta_range_uncertainty_m = in.adrUncertaintyMeters; + out.carrier_frequency_hz = in.carrierFrequencyHz; + out.carrier_cycles = in.carrierCycles; + out.carrier_phase = in.carrierPhase; + out.carrier_phase_uncertainty = in.carrierPhaseUncertainty; + out.multipath_indicator = GNSS_MULTIPATH_INDICATOR_UNKNOWN; + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT) + out.multipath_indicator |= GNSS_MULTIPATH_INDICATOR_PRESENT; + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT) + out.multipath_indicator |= GNSS_MULTIPATH_INDICATOR_NOT_PRESENT; + out.snr_db = in.signalToNoiseRatioDb; +} + +static void convertGnssClock(GnssMeasurementsClock& in, GnssClock& out) +{ + memset(&out, 0, sizeof(GnssClock)); + out.size = sizeof(GnssClock); + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT) + out.flags |= GNSS_CLOCK_HAS_LEAP_SECOND; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT) + out.flags |= GNSS_CLOCK_HAS_TIME_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT) + out.flags |= GNSS_CLOCK_HAS_FULL_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT) + out.flags |= GNSS_CLOCK_HAS_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT) + out.flags |= GNSS_CLOCK_HAS_BIAS_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT) + out.flags |= GNSS_CLOCK_HAS_DRIFT; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT) + out.flags |= GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY; + out.leap_second = in.leapSecond; + out.time_ns = in.timeNs; + out.time_uncertainty_ns = in.timeUncertaintyNs; + out.full_bias_ns = in.fullBiasNs; + out.bias_ns = in.biasNs; + out.bias_uncertainty_ns = in.biasUncertaintyNs; + out.drift_nsps = in.driftNsps; + out.drift_uncertainty_nsps = in.driftUncertaintyNsps; + out.hw_clock_discontinuity_count = in.hwClockDiscontinuityCount; +} + +static void convertGnssData(GnssMeasurementsNotification& in, GnssData& out) +{ + memset(&out, 0, sizeof(GnssData)); + out.size = sizeof(GnssData); + out.measurement_count = in.count; + int len = GNSS_MAX_MEASUREMENT < GNSS_MEASUREMENTS_MAX + ? GNSS_MAX_MEASUREMENT : GNSS_MEASUREMENTS_MAX; + for (int i = 0; i < len; i++) { + convertGnssMeasurement(in.measurements[i], out.measurements[i]); + } + convertGnssClock(in.clock, out.clock); +} diff --git a/android/GnssAPIClient.h b/android/GnssAPIClient.h new file mode 100644 index 00000000..77bfa527 --- /dev/null +++ b/android/GnssAPIClient.h @@ -0,0 +1,97 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef GNSS_API_CLINET_H +#define GNSS_API_CLINET_H + +#include + +#include + +class GnssAPIClient : public LocationAPIClientBase +{ +public: + GnssAPIClient(GpsCallbacks* gpsCb, + GpsNiCallbacks* niCb, + GpsMeasurementCallbacks* measurementCb); + virtual ~GnssAPIClient(); + GnssAPIClient(const GnssAPIClient&) = delete; + GnssAPIClient& operator=(const GnssAPIClient&) = delete; + + // for GpsInterface + void gnssUpdateCallbacks(GpsCallbacks* gpsCb, + GpsNiCallbacks* niCb, + GpsMeasurementCallbacks* measurementCb); + int gnssStart(); + int gnssStop(); + void gnssDeleteAidingData(GpsAidingData f); + int gnssSetPositionMode(GpsPositionMode mode, GpsPositionRecurrence recurrence, + uint32_t min_interval, uint32_t preferred_accuracy, + uint32_t preferred_time); + + // for AGpsInterface + void gnssAgnssSetServer(AGpsType type, const char *hostname, int port); + + // for GpsNiInterface + void gnssNiRespond(int notif_id, GpsUserResponseType user_response); + + // for GpsMeasurementInterface + void gnssMeasurementClose(); + + // for GnssConfigurationInterface + void gnssConfigurationUpdate(const char* config_data, int32_t length); + + inline LocationCapabilitiesMask gnssGetCapabilities() const { + return mLocationCapabilitiesMask; + } + + // callbacks we are interested in + void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final; + void onTrackingCb(Location location) final; + void onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) final; + void onGnssSvCb(GnssSvNotification gnssSvNotification) final; + void onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) final; + void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final; + + void onStartTrackingCb(LocationError error) final; + void onStopTrackingCb(LocationError error) final; + +private: + pthread_mutex_t mLock; + + GpsCallbacks* mGpsCallbacks; + GpsNiCallbacks* mGpsNiCallbacks; + + LocationCapabilitiesMask mLocationCapabilitiesMask; + + GpsMeasurementCallbacks* mGpsMeasurementCallbacks; + + LocationOptions mLocationOptions; +}; +#endif // GNSS_API_CLINET_H diff --git a/loc_api/libloc_api_50001/gps.c b/android/gps.c similarity index 94% rename from loc_api/libloc_api_50001/gps.c rename to android/gps.c index 29f20f42..a7248551 100644 --- a/loc_api/libloc_api_50001/gps.c +++ b/android/gps.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011,2015 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011, 2015-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -32,16 +32,20 @@ #include #include +#define UNUSED(...) (void)(__VA_ARGS__) + extern const GpsInterface* get_gps_interface(); const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev) { + UNUSED(dev); return get_gps_interface(); } static int open_gps(const struct hw_module_t* module, char const* name, struct hw_device_t** device) { + UNUSED(name); struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t)); if(dev == NULL) diff --git a/android/loc.cpp b/android/loc.cpp new file mode 100644 index 00000000..14d81263 --- /dev/null +++ b/android/loc.cpp @@ -0,0 +1,380 @@ +/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#define LOG_NDDEBUG 0 +#define LOG_TAG "LocSvc_afw" + +#include +#include +#include + +#include "GnssAPIClient.h" + +extern "C" const GpsGeofencingInterface* get_gps_geofence_interface(); + +static GnssAPIClient* sClient = nullptr; +static GpsCallbacks sGpsCallbacks; +static GpsCallbacks* pGpsCallbacks = nullptr; + +static GpsNiCallbacks sGpsNiCallbacks; +static GpsNiCallbacks* pGpsNiCallbacks = nullptr; + +static GpsMeasurementCallbacks sGpsMeasurementCallbacks; +static GpsMeasurementCallbacks* pGpsMeasurementCallbacks = nullptr; + +typedef struct { + bool pending; + AGpsType type; + char *hostname; + int port; +} AgnssServerPack; +static AgnssServerPack pendingAgnssServer = { + false, + AGPS_TYPE_SUPL, + nullptr, + 0 +}; + +typedef struct { + bool pending; + char* config_data; + int32_t length; +} ConfigurationPack; +static ConfigurationPack pendingConfiguration = { + false, + nullptr, + 0 +}; + +static GnssAPIClient* getClient() { + if (!sClient && + // in order to create a GnssClient to call gnssUpdateConfig, + // one of pGpsCallbacks and pGpsNiCallbacks should not be nullptr. + (pGpsCallbacks != nullptr || pGpsNiCallbacks != nullptr)) { + sClient = new GnssAPIClient(pGpsCallbacks, pGpsNiCallbacks, pGpsMeasurementCallbacks); + if (sClient) { + sClient->locAPIEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); + if (pendingAgnssServer.pending && pendingAgnssServer.hostname) { + sClient->gnssAgnssSetServer(pendingAgnssServer.type, + pendingAgnssServer.hostname, + pendingAgnssServer.port); + pendingAgnssServer.pending = false; + free(pendingAgnssServer.hostname); + pendingAgnssServer.hostname = nullptr; + } + if (pendingConfiguration.pending && pendingConfiguration.config_data) { + sClient->gnssConfigurationUpdate(pendingConfiguration.config_data, + pendingConfiguration.length); + pendingConfiguration.pending = false; + free(pendingConfiguration.config_data); + pendingConfiguration.config_data = nullptr; + } + } + } + if (!sClient) { + LOC_LOGE("%s:%d] get GnssAPIClient failed", __func__, __LINE__); + } + return sClient; +} + +/*=========================================================================== + Functions and variables for sGpsInterface +===========================================================================*/ +static int loc_init(GpsCallbacks* callbacks) { + ENTRY_LOG_CALLFLOW(); + int retVal = -1; + if (callbacks) { + GnssAPIClient* client = getClient(); + // backup callbacks in case *callbacks is a stack variable + pGpsCallbacks = &sGpsCallbacks; + pGpsCallbacks->size = callbacks->size; + pGpsCallbacks->location_cb = callbacks->location_cb; + pGpsCallbacks->status_cb = callbacks->status_cb; + pGpsCallbacks->sv_status_cb = callbacks->sv_status_cb; + pGpsCallbacks->nmea_cb = callbacks->nmea_cb; + pGpsCallbacks->set_capabilities_cb = callbacks->set_capabilities_cb; + pGpsCallbacks->set_system_info_cb = callbacks->set_system_info_cb; + pGpsCallbacks->gnss_sv_status_cb = callbacks->gnss_sv_status_cb; + + // create MsgTask + pGpsCallbacks->create_thread_cb = callbacks->create_thread_cb; + loc_core::LocDualContext::getLocFgContext( + (LocThread::tCreate)pGpsCallbacks->create_thread_cb, + nullptr, loc_core::LocDualContext::mLocationHalName, false); + + // will never call these cbs + pGpsCallbacks->acquire_wakelock_cb = nullptr; + pGpsCallbacks->release_wakelock_cb = nullptr; + pGpsCallbacks->request_utc_time_cb = nullptr; + + // we can't create GnssAPIClient before GpsCallbacks or GpsNiCallbacks is set + if (client) { + client->gnssUpdateCallbacks(pGpsCallbacks, pGpsNiCallbacks, pGpsMeasurementCallbacks); + } + + retVal = 0; + } + return retVal; +} +static int loc_start() { + ENTRY_LOG_CALLFLOW(); + int retVal = -1; + GnssAPIClient* client = getClient(); + if (client) + retVal = client->gnssStart(); + return retVal; +} +static int loc_stop() { + ENTRY_LOG_CALLFLOW(); + int retVal = -1; + GnssAPIClient* client = getClient(); + if (client) + retVal = client->gnssStop(); + return retVal; +} +static void loc_cleanup() { + ENTRY_LOG_CALLFLOW(); + if (sClient) { + sClient->locAPIDisable(); + } + pGpsCallbacks = nullptr; + pGpsNiCallbacks = nullptr; + pGpsMeasurementCallbacks = nullptr; + + pendingAgnssServer.pending = false; + if (pendingAgnssServer.hostname) { + free(pendingAgnssServer.hostname); + pendingAgnssServer.hostname = nullptr; + } + pendingConfiguration.pending = false; + if (pendingConfiguration.config_data) { + free(pendingConfiguration.config_data); + pendingConfiguration.config_data = nullptr; + } +} +static int loc_inject_time(GpsUtcTime /*time*/, int64_t /*timeReference*/, int /*uncertainty*/) { + return -1; +} +static int loc_inject_location(double /*latitude*/, double /*longitude*/, float /*accuracy*/) { + return -1; +} +static void loc_delete_aiding_data(GpsAidingData f) { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* client = getClient(); + if (client) + client->gnssDeleteAidingData(f); +} +static int loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence, + uint32_t min_interval, uint32_t preferred_accuracy, + uint32_t preferred_time) { + ENTRY_LOG_CALLFLOW(); + int retVal = -1; + GnssAPIClient* client = getClient(); + if (client) + retVal = client->gnssSetPositionMode(mode, recurrence, + min_interval, preferred_accuracy, preferred_time); + return retVal; +} +static const void* loc_get_extension(const char* name); + +static const GpsInterface sGpsInterface = { + 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 +}; + +/*=========================================================================== + Functions and variables for sAGpsInterface +===========================================================================*/ +static void loc_agps_init(AGpsCallbacks* /*callbacks*/) { +} +static int loc_agps_open(const char* /*apn*/) { + return -1; +} +static int loc_agps_closed() { return -1; } +static int loc_agps_open_failed() { return -1; } +static int loc_agps_set_server(AGpsType type, const char *hostname, int port) { + GnssAPIClient* client = getClient(); + if (client) + client->gnssAgnssSetServer(type, hostname, port); + else { + // client is not ready yet + if (pendingAgnssServer.hostname) + free(pendingAgnssServer.hostname); + pendingAgnssServer.type = type; + pendingAgnssServer.hostname = strdup(hostname); + pendingAgnssServer.port = port; + pendingAgnssServer.pending = true; + } + return 0; +} +static int loc_agps_open_with_apniptype(const char* /*apn*/, ApnIpType /*apnIpType*/) { + return -1; +} + +static const AGpsInterface sAGpsInterface = { + sizeof(AGpsInterface), + loc_agps_init, + loc_agps_open, + loc_agps_closed, + loc_agps_open_failed, + loc_agps_set_server, + loc_agps_open_with_apniptype +}; + +/*=========================================================================== + Functions and variables for sGpsNiInterface +===========================================================================*/ +static void loc_ni_init(GpsNiCallbacks *callbacks) { + ENTRY_LOG_CALLFLOW(); + if (callbacks) { + GnssAPIClient* client = getClient(); + pGpsNiCallbacks = &sGpsNiCallbacks; + pGpsNiCallbacks->notify_cb = callbacks->notify_cb; + pGpsNiCallbacks->create_thread_cb = callbacks->create_thread_cb; + + if (client) { + client->gnssUpdateCallbacks(pGpsCallbacks, pGpsNiCallbacks, pGpsMeasurementCallbacks); + } + } +} +static void loc_ni_respond(int notif_id, GpsUserResponseType user_response) { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* client = getClient(); + if (client) + client->gnssNiRespond(notif_id, user_response); +} + +static const GpsNiInterface sGpsNiInterface = +{ + sizeof(GpsNiInterface), + loc_ni_init, + loc_ni_respond, +}; + +/*=========================================================================== + Functions and variables for sGpsMeasurementInterface +===========================================================================*/ +static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks) { + ENTRY_LOG_CALLFLOW(); + int retVal = -1; + if (callbacks) { + GnssAPIClient* client = getClient(); + pGpsMeasurementCallbacks = &sGpsMeasurementCallbacks; + pGpsMeasurementCallbacks->size = sizeof(GpsMeasurementCallbacks); + pGpsMeasurementCallbacks->measurement_callback = callbacks->measurement_callback; + pGpsMeasurementCallbacks->gnss_measurement_callback = callbacks->gnss_measurement_callback; + + if (client) { + client->gnssUpdateCallbacks(pGpsCallbacks, pGpsNiCallbacks, pGpsMeasurementCallbacks); + } + + retVal = 0; + } + return retVal; +} +static void loc_gps_measurement_close() { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* client = getClient(); + if (client) + client->gnssMeasurementClose(); +} + +static const GpsMeasurementInterface sGpsMeasurementInterface = +{ + sizeof(GpsMeasurementInterface), + loc_gps_measurement_init, + loc_gps_measurement_close +}; + +/*=========================================================================== + Functions and variables for sGnssConfigurationInterface +===========================================================================*/ +static void loc_configuration_update(const char* config_data, int32_t length) { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* client = getClient(); + if (client) + client->gnssConfigurationUpdate(config_data, length); + else { + // client is not ready yet + if (pendingConfiguration.config_data) + free(pendingConfiguration.config_data); + pendingConfiguration.config_data = strdup(config_data); + pendingConfiguration.length = length; + pendingConfiguration.pending = true; + } +} + +static const GnssConfigurationInterface sGnssConfigurationInterface = +{ + sizeof(GnssConfigurationInterface), + loc_configuration_update +}; + +// Function exposed to gps hal +extern "C" const GpsInterface* get_gps_interface() +{ + unsigned int target = loc_get_target(); + int gnssType = getTargetGnssType(target); + if (gnssType == GNSS_NONE){ + LOC_LOGE("%s:%d] No GNSS HW on this target. Returning nullptr", __func__, __LINE__); + return nullptr; + } + return &sGpsInterface; +} + +const void* loc_get_extension(const char* name) +{ + const void* retVal = nullptr; + + LOC_LOGD("%s:%d] For Interface = %s\n", __func__, __LINE__, name); + if (strcmp(name, AGPS_INTERFACE) == 0) { + retVal = &sAGpsInterface; + } else if (strcmp(name, GPS_NI_INTERFACE) == 0) { + retVal = &sGpsNiInterface; + } else if (strcmp(name, GPS_GEOFENCING_INTERFACE) == 0) { + retVal = get_gps_geofence_interface(); + } else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0) { + retVal = &sGpsMeasurementInterface; + } else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0) { + retVal = &sGnssConfigurationInterface; + } + + if (!retVal) { + LOC_LOGE ("%s:%d] %s is not supported", __func__, __LINE__, name); + } + return retVal; +} diff --git a/android/loc_geofence.cpp b/android/loc_geofence.cpp new file mode 100644 index 00000000..91a4be82 --- /dev/null +++ b/android/loc_geofence.cpp @@ -0,0 +1,91 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#define LOG_NDDEBUG 0 +#define LOG_TAG "LocSvc_geofence" + +#include +#include + +static GeofenceAPIClient* sClient = nullptr; + +/*=========================================================================== + Functions and variables for sGpsGeofencingInterface +===========================================================================*/ +static GpsGeofenceCallbacks sGpsGeofenceCbs; + +static void loc_geofence_init(GpsGeofenceCallbacks* callbacks) { + if (callbacks && !sClient) { + sGpsGeofenceCbs.geofence_transition_callback = callbacks->geofence_transition_callback; + sGpsGeofenceCbs.geofence_status_callback = callbacks->geofence_status_callback; + sGpsGeofenceCbs.geofence_add_callback = callbacks->geofence_add_callback; + sGpsGeofenceCbs.geofence_remove_callback = callbacks->geofence_remove_callback; + sGpsGeofenceCbs.geofence_pause_callback = callbacks->geofence_pause_callback; + sGpsGeofenceCbs.geofence_resume_callback = callbacks->geofence_resume_callback; + sGpsGeofenceCbs.create_thread_cb = callbacks->create_thread_cb; + + sClient = new GeofenceAPIClient(&sGpsGeofenceCbs); + } +} +static void loc_add_geofence_area(int32_t geofence_id, double latitude, double longitude, + double radius_meters, int last_transition, int monitor_transitions, + int notification_responsiveness_ms, int unknown_timer_ms) { + if (sClient) + sClient->geofenceAdd(geofence_id, latitude, longitude, + radius_meters, last_transition, monitor_transitions, + notification_responsiveness_ms, unknown_timer_ms); +} +static void loc_pause_geofence(int32_t geofence_id) { + if (sClient) + sClient->geofencePause(geofence_id); +} +static void loc_resume_geofence(int32_t geofence_id, int monitor_transitions) { + if (sClient) + sClient->geofenceResume(geofence_id, monitor_transitions); +} +static void loc_remove_geofence_area(int32_t geofence_id) { + if (sClient) + sClient->geofenceRemove(geofence_id); +} + +static const GpsGeofencingInterface sGpsGeofencingInterface = +{ + sizeof(GpsGeofencingInterface), + loc_geofence_init, + loc_add_geofence_area, + loc_pause_geofence, + loc_resume_geofence, + loc_remove_geofence_area +}; + +// Function exposed to gps hal +extern "C" const GpsGeofencingInterface* get_gps_geofence_interface() +{ + return &sGpsGeofencingInterface; +} diff --git a/core/Android.mk b/core/Android.mk index 319a02a8..53dcb6bd 100644 --- a/core/Android.mk +++ b/core/Android.mk @@ -6,7 +6,7 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := libloc_core -LOCAL_MODULE_OWNER := qcom +LOCAL_MODULE_OWNER := qti LOCAL_MODULE_TAGS := optional @@ -37,8 +37,8 @@ LOCAL_CFLAGS += \ LOCAL_C_INCLUDES:= \ $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla + $(TARGET_OUT_HEADERS)/libloc_pla \ + $(TARGET_OUT_HEADERS)/liblocation_api LOCAL_COPY_HEADERS_TO:= libloc_core/ LOCAL_COPY_HEADERS:= \ diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp index 1ae84823..a9858e22 100644 --- a/core/ContextBase.cpp +++ b/core/ContextBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014,2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -40,8 +40,116 @@ namespace loc_core { -loc_gps_cfg_s_type ContextBase::mGps_conf {0}; -loc_sap_cfg_s_type ContextBase::mSap_conf {0}; +loc_gps_cfg_s_type ContextBase::mGps_conf {}; +loc_sap_cfg_s_type ContextBase::mSap_conf {}; + +const loc_param_s_type ContextBase::mGps_conf_table[] = +{ + {"GPS_LOCK", &mGps_conf.GPS_LOCK, NULL, 'n'}, + {"SUPL_VER", &mGps_conf.SUPL_VER, NULL, 'n'}, + {"LPP_PROFILE", &mGps_conf.LPP_PROFILE, NULL, 'n'}, + {"A_GLONASS_POS_PROTOCOL_SELECT", &mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'}, + {"LPPE_CP_TECHNOLOGY", &mGps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'}, + {"LPPE_UP_TECHNOLOGY", &mGps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'}, + {"AGPS_CERT_WRITABLE_MASK", &mGps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}, + {"SUPL_MODE", &mGps_conf.SUPL_MODE, NULL, 'n'}, + {"SUPL_ES", &mGps_conf.SUPL_ES, NULL, 'n'}, + {"INTERMEDIATE_POS", &mGps_conf.INTERMEDIATE_POS, NULL, 'n'}, + {"ACCURACY_THRES", &mGps_conf.ACCURACY_THRES, NULL, 'n'}, + {"NMEA_PROVIDER", &mGps_conf.NMEA_PROVIDER, NULL, 'n'}, + {"CAPABILITIES", &mGps_conf.CAPABILITIES, NULL, 'n'}, + {"XTRA_VERSION_CHECK", &mGps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, + {"XTRA_SERVER_1", &mGps_conf.XTRA_SERVER_1, NULL, 's'}, + {"XTRA_SERVER_2", &mGps_conf.XTRA_SERVER_2, NULL, 's'}, + {"XTRA_SERVER_3", &mGps_conf.XTRA_SERVER_3, NULL, 's'}, + {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'}, + {"AGPS_CONFIG_INJECT", &mGps_conf.AGPS_CONFIG_INJECT, NULL, 'n'}, + {"EXTERNAL_DR_ENABLED", &mGps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'}, +}; + +const loc_param_s_type ContextBase::mSap_conf_table[] = +{ + {"GYRO_BIAS_RANDOM_WALK", &mSap_conf.GYRO_BIAS_RANDOM_WALK, &mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'}, + {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"SENSOR_ACCEL_BATCHES_PER_SEC", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'}, + {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'}, + {"SENSOR_GYRO_BATCHES_PER_SEC", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'}, + {"SENSOR_GYRO_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'}, + {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'}, + {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, + {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'}, + {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, + {"SENSOR_CONTROL_MODE", &mSap_conf.SENSOR_CONTROL_MODE, NULL, 'n'}, + {"SENSOR_USAGE", &mSap_conf.SENSOR_USAGE, NULL, 'n'}, + {"SENSOR_ALGORITHM_CONFIG_MASK", &mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'}, + {"SENSOR_PROVIDER", &mSap_conf.SENSOR_PROVIDER, NULL, 'n'} +}; + +void ContextBase::readConfig() +{ + /*Defaults for gps.conf*/ + mGps_conf.INTERMEDIATE_POS = 0; + mGps_conf.ACCURACY_THRES = 0; + mGps_conf.NMEA_PROVIDER = 0; + mGps_conf.GPS_LOCK = 0; + mGps_conf.SUPL_VER = 0x10000; + mGps_conf.SUPL_MODE = 0x3; + mGps_conf.SUPL_ES = 0; + mGps_conf.CAPABILITIES = 0x7; + /* LTE Positioning Profile configuration is disable by default*/ + mGps_conf.LPP_PROFILE = 0; + /*By default no positioning protocol is selected on A-GLONASS system*/ + mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0; + /*XTRA version check is disabled by default*/ + mGps_conf.XTRA_VERSION_CHECK=0; + /*Use emergency PDN by default*/ + mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1; + /* By default no LPPe CP technology is enabled*/ + mGps_conf.LPPE_CP_TECHNOLOGY = 0; + /* By default no LPPe UP technology is enabled*/ + mGps_conf.LPPE_UP_TECHNOLOGY = 0; + + /*Defaults for sap.conf*/ + mSap_conf.GYRO_BIAS_RANDOM_WALK = 0; + mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2; + mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5; + mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2; + mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5; + mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4; + mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25; + mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4; + mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25; + mSap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */ + mSap_conf.SENSOR_USAGE = 0; /* Enabled */ + mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/ + /* Values MUST be set by OEMs in configuration for sensor-assisted + navigation to work. There are NO default values */ + mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0; + mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + /* default provider is SSC */ + mSap_conf.SENSOR_PROVIDER = 1; + + /* None of the 10 slots for agps certificates are writable by default */ + mGps_conf.AGPS_CERT_WRITABLE_MASK = 0; + + /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */ + mGps_conf.AGPS_CONFIG_INJECT = 1; + + const char* GPS_CONF_FILE = "/etc/gps.conf"; + const char* SAP_CONF_FILE = "/etc/sap.conf"; + UTIL_READ_CONF(GPS_CONF_FILE, mGps_conf_table); + UTIL_READ_CONF(SAP_CONF_FILE, mSap_conf_table); +} uint32_t ContextBase::getCarrierCapabilities() { #define carrierMSA (uint32_t)0x2 diff --git a/core/ContextBase.h b/core/ContextBase.h index 87d2acfa..83de9996 100644 --- a/core/ContextBase.h +++ b/core/ContextBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -34,6 +34,7 @@ #include #include #include +#include #define MAX_XTRA_SERVER_URL_LENGTH 256 @@ -105,6 +106,8 @@ class LocAdapterBase; class ContextBase { static LBSProxyBase* getLBSProxy(const char* libName); LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask); + static const loc_param_s_type mGps_conf_table[]; + static const loc_param_s_type mSap_conf_table[]; protected: const LBSProxyBase* mLBSProxy; const MsgTask* mMsgTask; @@ -135,6 +138,7 @@ public: static loc_gps_cfg_s_type mGps_conf; static loc_sap_cfg_s_type mSap_conf; + void readConfig(); static uint32_t getCarrierCapabilities(); }; diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index 166fd910..27132b79 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -50,6 +50,16 @@ LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask, mLocApi->addAdapter(this); } +uint32_t LocAdapterBase::mSessionIdCounter(1); + +uint32_t LocAdapterBase::generateSessionId() +{ + if (++mSessionIdCounter == 0xFFFFFFFF) + mSessionIdCounter = 1; + + return mSessionIdCounter; +} + void LocAdapterBase::handleEngineUpEvent() { if (mLocAdapterProxyBase) { @@ -65,32 +75,31 @@ void LocAdapterBase::handleEngineDownEvent() } void LocAdapterBase:: - reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) { - if (mLocAdapterProxyBase == NULL || - !mLocAdapterProxyBase->reportPosition(location, - locationExtended, - status, - loc_technology_mask)) { + reportPositionEvent(const UlpLocation& location, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask, + bool fromUlp) { + if (mLocAdapterProxyBase != NULL) { + mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location, + (GpsLocationExtended&)locationExtended, + status, + loc_technology_mask); + } else { DEFAULT_IMPL() } } void LocAdapterBase:: - reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) + reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp) DEFAULT_IMPL() void LocAdapterBase:: - reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) + reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet) DEFAULT_IMPL() void LocAdapterBase:: - reportSvPolynomial(GnssSvPolynomial &svPolynomial) + reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial) DEFAULT_IMPL() void LocAdapterBase:: @@ -99,7 +108,7 @@ DEFAULT_IMPL() void LocAdapterBase:: - reportNmea(const char* nmea, int length) + reportNmeaEvent(const char* nmea, size_t length, bool fromUlp) DEFAULT_IMPL() bool LocAdapterBase:: @@ -140,11 +149,11 @@ bool LocAdapterBase:: DEFAULT_IMPL(false) bool LocAdapterBase:: - requestNiNotify(LocGpsNiNotification ¬ify, const void* data) + requestNiNotifyEvent(GnssNiNotification ¬ify, const void* data) DEFAULT_IMPL(false) void LocAdapterBase:: - reportGnssMeasurementData(LocGnssData &gnssMeasurementData) + reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify) DEFAULT_IMPL() bool LocAdapterBase:: diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h index f3ec4890..824a3407 100644 --- a/core/LocAdapterBase.h +++ b/core/LocAdapterBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -32,19 +32,39 @@ #include #include #include +#include +#include + +typedef struct LocationSessionKey { + LocationAPI* client; + uint32_t id; + inline LocationSessionKey(LocationAPI* _client, uint32_t _id) : + client(_client), id(_id) {} +} LocationSessionKey; +inline bool operator <(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id < right.id || (left.id == right.id && left.client < right.client); +} +inline bool operator ==(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id == right.id && left.client == right.client; +} +inline bool operator !=(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id != right.id || left.client != right.client; +} +typedef std::map LocationSessionMap; namespace loc_core { class LocAdapterProxyBase; class LocAdapterBase { +private: + static uint32_t mSessionIdCounter; protected: LOC_API_ADAPTER_EVENT_MASK_T mEvtMask; ContextBase* mContext; LocApiBase* mLocApi; LocAdapterProxyBase* mLocAdapterProxyBase; const MsgTask* mMsgTask; - inline LocAdapterBase(const MsgTask* msgTask) : mEvtMask(0), mContext(NULL), mLocApi(NULL), mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {} @@ -70,11 +90,19 @@ public: } inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event, - loc_registration_mask_status isEnabled) + loc_registration_mask_status status) { - mEvtMask = - isEnabled == LOC_REGISTRATION_MASK_ENABLED ? (mEvtMask|event):(mEvtMask&~event); - + switch(status) { + case (LOC_REGISTRATION_MASK_ENABLED): + mEvtMask = mEvtMask | event; + break; + case (LOC_REGISTRATION_MASK_DISABLED): + mEvtMask = mEvtMask &~ event; + break; + case (LOC_REGISTRATION_MASK_SET): + mEvtMask = event; + break; + } mLocApi->updateEvtMask(); } @@ -82,33 +110,33 @@ public: return mLocApi->isFeatureSupported(featureVal); } + uint32_t generateSessionId(); + // This will be overridden by the individual adapters // if necessary. - inline virtual void setUlpProxy(UlpProxyBase* ulp) { + inline virtual void setUlpProxyCommand(UlpProxyBase* ulp) { (void)ulp; } virtual void handleEngineUpEvent(); virtual void handleEngineDownEvent(); - inline virtual void setPositionModeInt(LocPosMode& posMode) { + inline virtual void setPositionModeCommand(LocPosMode& posMode) { (void)posMode; } - virtual void startFixInt() {} - virtual void stopFixInt() {} - virtual void getZppInt() {} - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); - virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial); + virtual void startTrackingCommand() {} + virtual void stopTrackingCommand() {} + virtual void getZppCommand() {} + virtual void reportPositionEvent(const UlpLocation& location, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask, + bool fromUlp=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); + virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); + virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); virtual void reportStatus(LocGpsStatusValue status); - virtual void reportNmea(const char* nmea, int length); virtual bool reportXtraServer(const char* url1, const char* url2, const char* url3, const int maxlength); virtual bool requestXtraData(); @@ -119,11 +147,10 @@ public: virtual bool requestSuplES(int connHandle); virtual bool reportDataCallOpened(); virtual bool reportDataCallClosed(); - virtual bool requestNiNotify(LocGpsNiNotification ¬ify, - const void* data); + virtual bool requestNiNotifyEvent(GnssNiNotification ¬ify, const void* data); inline virtual bool isInSession() { return false; } ContextBase* getContext() const { return mContext; } - virtual void reportGnssMeasurementData(LocGnssData &gnssMeasurementData); + virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify); virtual bool reportWwanZppFix(LocGpsLocation &zppLoc); }; diff --git a/core/LocAdapterProxyBase.h b/core/LocAdapterProxyBase.h index 82cba6b7..044f59bd 100644 --- a/core/LocAdapterProxyBase.h +++ b/core/LocAdapterProxyBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -51,22 +51,25 @@ protected: mLocAdapterBase->updateEvtMask(event,isEnabled); } + inline uint32_t generateSessionId() { + return mLocAdapterBase->generateSessionId(); + } public: inline ContextBase* getContext() const { return mLocAdapterBase->getContext(); } + inline virtual void handleEngineUpEvent() {}; inline virtual void handleEngineDownEvent() {}; - inline virtual bool reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) { + inline virtual void reportPositionEvent(UlpLocation &location, + GpsLocationExtended &locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask) { (void)location; (void)locationExtended; (void)status; (void)loc_technology_mask; - return false; } }; diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 4cc8cb8d..3bbbf8f3 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -227,14 +227,13 @@ void LocApiBase::handleEngineDownEvent() TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent()); } -void LocApiBase::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, +void LocApiBase::reportPosition(UlpLocation& location, + GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { // print the location info before delivering - LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " + LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n " "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n " "Session status: %d\n Technology mask: %u\n " @@ -251,11 +250,8 @@ void LocApiBase::reportPosition(UlpLocation &location, locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask); // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask) + mLocAdapters[i]->reportPositionEvent(location, locationExtended, + status, loc_technology_mask) ); } @@ -265,9 +261,7 @@ void LocApiBase::reportWwanZppFix(LocGpsLocation &zppLoc) TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportWwanZppFix(zppLoc)); } -void LocApiBase::reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) +void LocApiBase::reportSv(GnssSvNotification& svNotify) { const char* constellationString[] = { "Unknown", "GPS", "SBAS", "GLONASS", "QZSS", "BEIDOU", "GALILEO" }; @@ -276,27 +270,25 @@ void LocApiBase::reportSv(LocGnssSvStatus &svStatus, LOC_LOGV("num sv: %d\n" " sv: constellation svid cN0" " elevation azimuth flags", - svStatus.num_svs); - for (int i = 0; i < svStatus.num_svs && i < LOC_GNSS_MAX_SVS; i++) { - if (svStatus.gnss_sv_list[i].constellation > + svNotify.count); + for (int i = 0; i < svNotify.count && i < LOC_GNSS_MAX_SVS; i++) { + if (svNotify.gnssSvs[i].type > sizeof(constellationString) / sizeof(constellationString[0]) - 1) { - svStatus.gnss_sv_list[i].constellation = 0; + svNotify.gnssSvs[i].type = GNSS_SV_TYPE_UNKNOWN; } LOC_LOGV(" %03d: %*s %02d %f %f %f 0x%02X", i, 13, - constellationString[svStatus.gnss_sv_list[i].constellation], - svStatus.gnss_sv_list[i].svid, - svStatus.gnss_sv_list[i].c_n0_dbhz, - svStatus.gnss_sv_list[i].elevation, - svStatus.gnss_sv_list[i].azimuth, - svStatus.gnss_sv_list[i].flags); + constellationString[svNotify.gnssSvs[i].type], + svNotify.gnssSvs[i].svId, + svNotify.gnssSvs[i].cN0Dbhz, + svNotify.gnssSvs[i].elevation, + svNotify.gnssSvs[i].azimuth, + svNotify.gnssSvs[i].gnssSvOptionsMask); } // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSv(svStatus, - locationExtended, - svExt) + mLocAdapters[i]->reportSvEvent(svNotify) ); } @@ -304,7 +296,7 @@ void LocApiBase::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) { // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSvMeasurement(svMeasurementSet) + mLocAdapters[i]->reportSvMeasurementEvent(svMeasurementSet) ); } @@ -312,7 +304,7 @@ void LocApiBase::reportSvPolynomial(GnssSvPolynomial &svPolynomial) { // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSvPolynomial(svPolynomial) + mLocAdapters[i]->reportSvPolynomialEvent(svPolynomial) ); } @@ -325,7 +317,7 @@ void LocApiBase::reportStatus(LocGpsStatusValue status) void LocApiBase::reportNmea(const char* nmea, int length) { // loop through adapters, and deliver to all adapters. - TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length)); + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmeaEvent(nmea, length)); } void LocApiBase::reportXtraServer(const char* url1, const char* url2, @@ -384,10 +376,10 @@ void LocApiBase::reportDataCallClosed() TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed()); } -void LocApiBase::requestNiNotify(LocGpsNiNotification ¬ify, const void* data) +void LocApiBase::requestNiNotify(GnssNiNotification ¬ify, const void* data) { // loop through adapters, and deliver to the first handling adapter. - TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data)); + TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotifyEvent(notify, data)); } void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList) @@ -406,10 +398,10 @@ void* LocApiBase :: getSibling() LocApiProxyBase* LocApiBase :: getLocApiProxy() DEFAULT_IMPL(NULL) -void LocApiBase::reportGnssMeasurementData(LocGnssData &gnssMeasurementData) +void LocApiBase::reportGnssMeasurementData(GnssMeasurementsNotification& measurementsNotify) { // loop through adapters, and deliver to all adapters. - TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData)); + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementDataEvent(measurementsNotify)); } enum loc_api_adapter_err LocApiBase:: @@ -428,9 +420,9 @@ enum loc_api_adapter_err LocApiBase:: stopFix() DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - deleteAidingData(LocGpsAidingData f) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + deleteAidingData(const GnssAidingData& data) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: enableData(int enable) @@ -469,31 +461,29 @@ enum loc_api_adapter_err LocApiBase:: setPositionMode(const LocPosMode& posMode) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: +LocationError LocApiBase:: setServer(const char* url, int len) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - setServer(unsigned int ip, int port, - LocServerType type) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setServer(unsigned int ip, int port, LocServerType type) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - informNiResponse(LocGpsUserResponseType userResponse, - const void* passThroughData) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + informNiResponse(GnssNiResponse userResponse, const void* passThroughData) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - setSUPLVersion(uint32_t version) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setSUPLVersion(GnssConfigSuplVersion version) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: setNMEATypes (uint32_t typesMask) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - setLPPConfig(uint32_t profile) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setLPPConfig(GnssConfigLppProfile profile) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: setSensorControlConfig(int sensorUsage, @@ -526,13 +516,17 @@ enum loc_api_adapter_err LocApiBase:: int algorithmConfig) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - setAGLONASSProtocol(unsigned long aGlonassProtocol) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) - DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: getWwanZppFix() @@ -573,9 +567,9 @@ void LocApiBase:: releaseDataServiceClient() DEFAULT_IMPL() -int LocApiBase:: - setGpsLock(LOC_GPS_LOCK_MASK lock) -DEFAULT_IMPL(-1) +LocationError LocApiBase:: + setGpsLock(GnssConfigGpsLock lock) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) void LocApiBase:: installAGpsCert(const LocDerEncodedCertificate* pData, @@ -587,9 +581,9 @@ int LocApiBase:: getGpsLock() DEFAULT_IMPL(-1) -enum loc_api_adapter_err LocApiBase:: - setXtraVersionCheck(enum xtra_version_check check) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setXtraVersionCheck(uint32_t check) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) bool LocApiBase:: gnssConstellationConfig() diff --git a/core/LocApiBase.h b/core/LocApiBase.h index 9127a2ea..86610e72 100644 --- a/core/LocApiBase.h +++ b/core/LocApiBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, 2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -102,22 +103,18 @@ public: inline void sendMsg(const LocMsg* msg) const { mMsgTask->sendMsg(msg); } - void addAdapter(LocAdapterBase* adapter); void removeAdapter(LocAdapterBase* adapter); // upward calls void handleEngineUpEvent(); void handleEngineDownEvent(); - void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, + void reportPosition(UlpLocation& location, + GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask = LOC_POS_TECH_MASK_DEFAULT); - void reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); + void reportSv(GnssSvNotification& svNotify); void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); void reportSvPolynomial(GnssSvPolynomial &svPolynomial); void reportStatus(LocGpsStatusValue status); @@ -132,9 +129,9 @@ public: void requestSuplES(int connHandle); void reportDataCallOpened(); void reportDataCallClosed(); - void requestNiNotify(LocGpsNiNotification ¬ify, const void* data); + void requestNiNotify(GnssNiNotification ¬ify, const void* data); void saveSupportedMsgList(uint64_t supportedMsgList); - void reportGnssMeasurementData(LocGnssData &gnssMeasurementData); + void reportGnssMeasurementData(GnssMeasurementsNotification& measurementsNotify); void saveSupportedFeatureList(uint8_t *featureList); void reportWwanZppFix(LocGpsLocation &zppLoc); @@ -148,8 +145,8 @@ public: startFix(const LocPosMode& posMode); virtual enum loc_api_adapter_err stopFix(); - virtual enum loc_api_adapter_err - deleteAidingData(LocGpsAidingData f); + virtual LocationError + deleteAidingData(const GnssAidingData& data); virtual enum loc_api_adapter_err enableData(int enable); virtual enum loc_api_adapter_err @@ -168,19 +165,17 @@ public: atlCloseStatus(int handle, int is_succ); virtual enum loc_api_adapter_err setPositionMode(const LocPosMode& posMode); - virtual enum loc_api_adapter_err + virtual LocationError setServer(const char* url, int len); - virtual enum loc_api_adapter_err + virtual LocationError setServer(unsigned int ip, int port, LocServerType type); - virtual enum loc_api_adapter_err - informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData); - virtual enum loc_api_adapter_err - setSUPLVersion(uint32_t version); + virtual LocationError + informNiResponse(GnssNiResponse userResponse, const void* passThroughData); + virtual LocationError setSUPLVersion(GnssConfigSuplVersion version); virtual enum loc_api_adapter_err setNMEATypes (uint32_t typesMask); - virtual enum loc_api_adapter_err - setLPPConfig(uint32_t profile); + virtual LocationError setLPPConfig(GnssConfigLppProfile profile); virtual enum loc_api_adapter_err setSensorControlConfig(int sensorUsage, int sensorProvider); virtual enum loc_api_adapter_err @@ -205,10 +200,10 @@ public: int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig); - virtual enum loc_api_adapter_err - setAGLONASSProtocol(unsigned long aGlonassProtocol); - virtual enum loc_api_adapter_err - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP); + virtual LocationError + setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol); + virtual LocationError setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP); + virtual LocationError setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP); virtual enum loc_api_adapter_err getWwanZppFix(); virtual enum loc_api_adapter_err @@ -238,15 +233,10 @@ public: return (messageChecker & mSupportedMsg) == messageChecker; } } + void updateEvtMask(); - /*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions - */ - virtual int setGpsLock(LOC_GPS_LOCK_MASK lock); + virtual LocationError setGpsLock(GnssConfigGpsLock lock); /* Returns Current value of GPS Lock on success @@ -254,8 +244,7 @@ public: */ virtual int getGpsLock(void); - virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check); - + virtual LocationError setXtraVersionCheck(uint32_t check); /* Check if the modem support the service */ diff --git a/core/LocDualContext.cpp b/core/LocDualContext.cpp index 74b2903a..fd465e9d 100644 --- a/core/LocDualContext.cpp +++ b/core/LocDualContext.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -44,8 +44,7 @@ LocDualContext::mFgExclMask = 0; // excluded events for background clients const LOC_API_ADAPTER_EVENT_MASK_T LocDualContext::mBgExclMask = - (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | - LOC_API_ADAPTER_BIT_SATELLITE_REPORT | + (LOC_API_ADAPTER_BIT_SATELLITE_REPORT | LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT | LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT | LOC_API_ADAPTER_BIT_IOCTL_REPORT | diff --git a/core/UlpProxyBase.h b/core/UlpProxyBase.h index d30e9cc5..8863b66c 100644 --- a/core/UlpProxyBase.h +++ b/core/UlpProxyBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -30,7 +30,8 @@ #define ULP_PROXY_BASE_H #include -#include "fused_location_extended.h" +#include + namespace loc_core { class LocAdapterBase; @@ -51,24 +52,18 @@ public: return false; } - inline virtual bool reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, + inline virtual bool reportPosition(const UlpLocation &location, + const GpsLocationExtended &locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { (void)location; (void)locationExtended; - (void)locationExt; (void)status; (void)loc_technology_mask; return false; } - inline virtual bool reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) { - (void)svStatus; - (void)locationExtended; - (void)svExt; + inline virtual bool reportSv(const GnssSvNotification& svNotify) { + (void)svNotify; return false; } inline virtual bool reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) { @@ -94,17 +89,21 @@ public: (void)capabilities; } - inline virtual bool reportBatchingSession(FlpExtBatchOptions &options, - bool active) { - - (void)options; - (void)active; - return false; + inline virtual bool reportBatchingSession(const LocationOptions& options, bool active) + { + (void)options; + (void)active; + return false; } - inline virtual bool reportPositions(const FlpExtLocation* locations, - int32_t number_of_locations) { - (void)locations; - (void)number_of_locations; + inline virtual bool reportPositions(const UlpLocation* ulpLocations, + const GpsLocationExtended* extendedLocations, + const uint32_t* techMasks, + const size_t count) + { + (void)ulpLocations; + (void)extendedLocations; + (void)techMasks; + (void)count; return false; } inline virtual bool reportDeleteAidingData(LocGpsAidingData aidingData) diff --git a/core/gps_extended.h b/core/gps_extended.h index 5255da1a..dc6ad1eb 100644 --- a/core/gps_extended.h +++ b/core/gps_extended.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -29,19 +29,21 @@ #ifndef GPS_EXTENDED_H #define GPS_EXTENDED_H -#include /** * @file * @brief C++ declarations for GPS types */ +#include +#if defined(USE_GLIB) || defined(OFF_TARGET) +#include +#endif + #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ -#if defined(USE_GLIB) || defined(OFF_TARGET) -#include -#endif + struct LocPosMode { diff --git a/core/gps_extended_c.h b/core/gps_extended_c.h index 3985e994..55fd03eb 100644 --- a/core/gps_extended_c.h +++ b/core/gps_extended_c.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, 2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -34,6 +34,7 @@ #include #include #include +#include #include /** @@ -88,7 +89,8 @@ extern "C" { enum loc_registration_mask_status { LOC_REGISTRATION_MASK_ENABLED, - LOC_REGISTRATION_MASK_DISABLED + LOC_REGISTRATION_MASK_DISABLED, + LOC_REGISTRATION_MASK_SET }; typedef enum { diff --git a/core/loc_core_log.h b/core/loc_core_log.h index 4fe8d3f2..2beb6873 100644 --- a/core/loc_core_log.h +++ b/core/loc_core_log.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2013, 2016-2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -30,14 +30,14 @@ #ifndef LOC_CORE_LOG_H #define LOC_CORE_LOG_H +#include +#include + #ifdef __cplusplus extern "C" { #endif -#include -#include - const char* loc_get_gps_status_name(LocGpsStatusValue gps_status); const char* loc_get_position_mode_name(LocGpsPositionMode mode); const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur); diff --git a/gnss/Android.mk b/gnss/Android.mk new file mode 100644 index 00000000..16d796cc --- /dev/null +++ b/gnss/Android.mk @@ -0,0 +1,43 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) +ifneq ($(BUILD_TINY_ANDROID),true) + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := libgnss +LOCAL_MODULE_OWNER := qti + +LOCAL_MODULE_TAGS := optional + +LOCAL_SHARED_LIBRARIES := \ + libutils \ + libcutils \ + libdl \ + liblog \ + libloc_core \ + libgps.utils + +LOCAL_SRC_FILES += \ + location_gnss.cpp \ + GnssAdapter.cpp + +LOCAL_CFLAGS += \ + -fno-short-enums \ + +ifeq ($(TARGET_BUILD_VARIANT),user) + LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER +endif + +LOCAL_C_INCLUDES:= \ + $(TARGET_OUT_HEADERS)/gps.utils \ + $(TARGET_OUT_HEADERS)/libloc_core \ + $(TARGET_OUT_HEADERS)/libloc_pla \ + $(TARGET_OUT_HEADERS)/liblocation_api + +LOCAL_PRELINK_MODULE := false + +include $(BUILD_SHARED_LIBRARY) + +endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp new file mode 100644 index 00000000..1ddb41dc --- /dev/null +++ b/gnss/GnssAdapter.cpp @@ -0,0 +1,2880 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#define LOG_TAG "LocSvc_GnssAdapter" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace loc_core; + +GnssAdapter::GnssAdapter() : + LocAdapterBase(0, + LocDualContext::getLocFgContext(NULL, + NULL, + LocDualContext::mLocationHalName, + false)), + mUlpProxy(new UlpProxyBase()), + mSuplMode(GNSS_SUPL_MODE_STANDALONE), + mUlpPositionMode(), + mGnssSvIdUsedInPosition(), + mGnssSvIdUsedInPosAvail(false), + mControlCallbacks(), + mPowerVoteId(0), + mNiData() +{ + LOC_LOGD("%s]: Constructor %p", __func__, this); + mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID; + readConfigCommand(); + setConfigCommand(); + +} + +inline +GnssAdapter::~GnssAdapter() +{ + LOC_LOGD("%s]: Destructor", __func__); + delete mUlpProxy; +} + +void +GnssAdapter::setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks) +{ + struct MsgSetControlCallbacks : public LocMsg { + GnssAdapter& mAdapter; + const LocationControlCallbacks mControlCallbacks; + inline MsgSetControlCallbacks(GnssAdapter& adapter, + LocationControlCallbacks& controlCallbacks) : + LocMsg(), + mAdapter(adapter), + mControlCallbacks(controlCallbacks) {} + inline virtual void proc() const { + mAdapter.setControlCallbacks(mControlCallbacks); + } + }; + + sendMsg(new MsgSetControlCallbacks(*this, controlCallbacks)); +} + +void +GnssAdapter::convertOptions(LocPosMode& out, const LocationOptions& options) +{ + LocPosMode locPosMode = {}; + switch (options.mode) { + case GNSS_SUPL_MODE_MSB: + out.mode = LOC_POSITION_MODE_MS_BASED; + break; + case GNSS_SUPL_MODE_MSA: + out.mode = LOC_POSITION_MODE_MS_ASSISTED; + break; + default: + out.mode = LOC_POSITION_MODE_STANDALONE; + break; + } + out.share_position = true; + out.min_interval = options.minInterval; +} + +void +GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation, + const LocPosTechMask techMask) +{ + out.size = sizeof(Location); + if (LOC_GPS_LOCATION_HAS_LAT_LONG & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_LAT_LONG_BIT; + out.latitude = locGpsLocation.latitude; + out.longitude = locGpsLocation.longitude; + } + if (LOC_GPS_LOCATION_HAS_ALTITUDE & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_ALTITUDE_BIT; + out.altitude = locGpsLocation.altitude; + } + if (LOC_GPS_LOCATION_HAS_SPEED & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_SPEED_BIT; + out.speed = locGpsLocation.speed; + } + if (LOC_GPS_LOCATION_HAS_BEARING & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_BEARING_BIT; + out.bearing = locGpsLocation.bearing; + } + if (LOC_GPS_LOCATION_HAS_ACCURACY & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_ACCURACY_BIT; + out.accuracy = locGpsLocation.accuracy; + } + out.timestamp = locGpsLocation.timestamp; + if (LOC_POS_TECH_MASK_SATELLITE & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_GNSS_BIT; + } + if (LOC_POS_TECH_MASK_CELLID & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_CELL_BIT; + } + if (LOC_POS_TECH_MASK_WIFI & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_WIFI_BIT; + } + if (LOC_POS_TECH_MASK_SENSORS & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_SENSORS_BIT; + } +} + +void +GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, + const GpsLocationExtended& locationExtended) +{ + out.size = sizeof(GnssLocationInfoNotification); + if (GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT; + out.altitudeMeanSeaLevel = locationExtended.altitudeMeanSeaLevel; + } + if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_DOP_BIT; + out.pdop = locationExtended.pdop; + out.hdop = locationExtended.hdop; + out.vdop = locationExtended.vdop; + } + if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT; + out.magneticDeviation = locationExtended.magneticDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_VERT_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_VER_ACCURACY_BIT; + out.verAccuracy = locationExtended.vert_unc; + } + if (GPS_LOCATION_EXTENDED_HAS_SPEED_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_SPEED_ACCURACY_BIT; + out.speedAccuracy = locationExtended.speed_unc; + } + if (GPS_LOCATION_EXTENDED_HAS_BEARING_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_BEARING_ACCURACY_BIT; + out.bearingAccuracy = locationExtended.bearing_unc; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT; + switch (locationExtended.horizontal_reliability) { + case LOC_RELIABILITY_VERY_LOW: + out.horReliability = LOCATION_RELIABILITY_VERY_LOW; + break; + case LOC_RELIABILITY_LOW: + out.horReliability = LOCATION_RELIABILITY_LOW; + break; + case LOC_RELIABILITY_MEDIUM: + out.horReliability = LOCATION_RELIABILITY_MEDIUM; + break; + case LOC_RELIABILITY_HIGH: + out.horReliability = LOCATION_RELIABILITY_HIGH; + break; + default: + out.horReliability = LOCATION_RELIABILITY_NOT_SET; + break; + } + } + if (GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_VER_RELIABILITY_BIT; + switch (locationExtended.vertical_reliability) { + case LOC_RELIABILITY_VERY_LOW: + out.verReliability = LOCATION_RELIABILITY_VERY_LOW; + break; + case LOC_RELIABILITY_LOW: + out.verReliability = LOCATION_RELIABILITY_LOW; + break; + case LOC_RELIABILITY_MEDIUM: + out.verReliability = LOCATION_RELIABILITY_MEDIUM; + break; + case LOC_RELIABILITY_HIGH: + out.verReliability = LOCATION_RELIABILITY_HIGH; + break; + default: + out.verReliability = LOCATION_RELIABILITY_NOT_SET; + break; + } + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT; + out.horUncEllipseSemiMajor = locationExtended.horUncEllipseSemiMajor; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT; + out.horUncEllipseSemiMinor = locationExtended.horUncEllipseSemiMinor; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT; + out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth; + } +} + +inline uint32_t +GnssAdapter::convertGpsLock(const GnssConfigGpsLock gpsLock) +{ + switch (gpsLock) { + case GNSS_CONFIG_GPS_LOCK_MO: + return 1; + case GNSS_CONFIG_GPS_LOCK_NI: + return 2; + case GNSS_CONFIG_GPS_LOCK_MO_AND_NI: + return 3; + case GNSS_CONFIG_GPS_LOCK_NONE: + default: + return 0; + } +} + +inline GnssConfigGpsLock +GnssAdapter::convertGpsLock(const uint32_t gpsLock) +{ + switch (gpsLock) { + case 1: + return GNSS_CONFIG_GPS_LOCK_MO; + case 2: + return GNSS_CONFIG_GPS_LOCK_NI; + case 3: + return GNSS_CONFIG_GPS_LOCK_MO_AND_NI; + case 0: + default: + return GNSS_CONFIG_GPS_LOCK_NONE; + } +} + +inline uint32_t +GnssAdapter::convertSuplVersion(const GnssConfigSuplVersion suplVersion) +{ + switch (suplVersion) { + case GNSS_CONFIG_SUPL_VERSION_2_0_0: + return 0x00020000; + case GNSS_CONFIG_SUPL_VERSION_2_0_2: + return 0x00020002; + case GNSS_CONFIG_SUPL_VERSION_1_0_0: + default: + return 0x00010000; + } +} + +inline GnssConfigSuplVersion +GnssAdapter::convertSuplVersion(const uint32_t suplVersion) +{ + switch (suplVersion) { + case 0x00020000: + return GNSS_CONFIG_SUPL_VERSION_2_0_0; + case 0x00020002: + return GNSS_CONFIG_SUPL_VERSION_2_0_2; + case 0x00010000: + default: + return GNSS_CONFIG_SUPL_VERSION_1_0_0; + } +} + +inline uint32_t +GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile) +{ + switch (lppProfile) { + case GNSS_CONFIG_LPP_PROFILE_USER_PLANE: + return 1; + case GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE: + return 2; + case GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE: + return 3; + case GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE: + default: + return 0; + } +} + +inline GnssConfigLppProfile +GnssAdapter::convertLppProfile(const uint32_t lppProfile) +{ + switch (lppProfile) { + case 1: + return GNSS_CONFIG_LPP_PROFILE_USER_PLANE; + case 2: + return GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE; + case 3: + return GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE; + case 0: + default: + return GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; + } +} + +uint32_t +GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT & lppeControlPlaneMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) { + mask |= (1<<1); + } + return mask; +} + +GnssConfigLppeControlPlaneMask +GnssAdapter::convertLppeCp(const uint32_t lppeControlPlaneMask) +{ + GnssConfigLppeControlPlaneMask mask = 0; + if ((1<<0) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT; + } + if ((1<<1) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT; + } + return mask; +} + + +uint32_t +GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT & lppeUserPlaneMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) { + mask |= (1<<1); + } + return mask; +} + +GnssConfigLppeUserPlaneMask +GnssAdapter::convertLppeUp(const uint32_t lppeUserPlaneMask) +{ + GnssConfigLppeUserPlaneMask mask = 0; + if ((1<<0) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT; + } + if ((1<<1) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT; + } + return mask; +} + +uint32_t +GnssAdapter::convertAGloProt(const GnssConfigAGlonassPositionProtocolMask aGloPositionProtocolMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_RRC_CONTROL_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_RRLP_USER_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<1); + } + if (GNSS_CONFIG_LLP_USER_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<2); + } + if (GNSS_CONFIG_LLP_CONTROL_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<3); + } + return mask; +} + +uint32_t +GnssAdapter::convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl) +{ + switch (emergencyPdnForEmergencySupl) { + case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES: + return 1; + case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO: + default: + return 0; + } +} + +uint32_t +GnssAdapter::convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices) +{ + switch (suplEmergencyServices) { + case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES: + return 1; + case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO: + default: + return 0; + } +} + +uint32_t +GnssAdapter::convertSuplMode(const GnssConfigSuplModeMask suplModeMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_SUPL_MODE_MSB & suplModeMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_SUPL_MODE_MSA & suplModeMask) { + mask |= (1<<1); + } + return mask; +} + +bool +GnssAdapter::resolveInAddress(const char* hostAddress, struct in_addr* inAddress) +{ + bool ret = true; + + struct hostent* hp; + hp = gethostbyname(hostAddress); + if (hp != NULL) { /* DNS OK */ + memcpy(inAddress, hp->h_addr_list[0], hp->h_length); + } else { + /* Try IP representation */ + if (inet_aton(hostAddress, inAddress) == 0) { + /* IP not valid */ + LOC_LOGE("%s]: DNS query on '%s' failed", __func__, hostAddress); + ret = false; + } + } + + return ret; +} + +void +GnssAdapter::readConfigCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgReadConfig : public LocMsg { + GnssAdapter* mAdapter; + ContextBase& mContext; + inline MsgReadConfig(GnssAdapter* adapter, + ContextBase& context) : + LocMsg(), + mAdapter(adapter), + mContext(context) {} + inline virtual void proc() const { + // reads config into mContext->mGps_conf + mContext.readConfig(); + mContext.requestUlp((LocAdapterBase*)mAdapter, mContext.getCarrierCapabilities()); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgReadConfig(this, *mContext)); + } +} + +void +GnssAdapter::setConfigCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgSetConfig : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgSetConfig(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + mApi.setSUPLVersion(mAdapter.convertSuplVersion(ContextBase::mGps_conf.SUPL_VER)); + mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE)); + mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT); + } + mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE, + ContextBase::mSap_conf.SENSOR_PROVIDER); + mApi.setLPPeProtocolCp( + mAdapter.convertLppeCp(ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY)); + mApi.setLPPeProtocolUp( + mAdapter.convertLppeUp(ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY)); + if (NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) { + mApi.setNMEATypes(LOC_NMEA_ALL_SUPPORTED_MASK); + } + mApi.setXtraVersionCheck(ContextBase::mGps_conf.XTRA_VERSION_CHECK); + if (ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID || + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { + mApi.setSensorProperties( + ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, + ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK, + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY); + } + mApi.setSensorPerfControlConfig( + ContextBase::mSap_conf.SENSOR_CONTROL_MODE, + ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, + ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, + ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, + ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, + ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, + ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, + ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, + ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, + ContextBase::mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK); + } + }; + + sendMsg(new MsgSetConfig(*this, *mLocApi)); +} + +uint32_t* +GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) +{ + // count the number of bits set + GnssConfigFlagsMask flagsCopy = config.flags; + size_t count = 0; + while (flagsCopy > 0) { + if (flagsCopy & 1) { + count++; + } + flagsCopy >>= 1; + } + std::string idsString = "["; + uint32_t* ids = NULL; + if (count > 0) { + ids = new uint32_t[count]; + for (size_t i=0; i < count; ++i) { + ids[i] = generateSessionId(); + IF_LOC_LOGD { + idsString += std::to_string(ids[i]) + " "; + } + } + } + idsString += "]"; + + LOC_LOGD("%s]: ids %s flags 0x%X", __func__, idsString.c_str(), config.flags); + + struct MsgGnssUpdateConfig : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + GnssConfig mConfig; + uint32_t* mIds; + size_t mCount; + inline MsgGnssUpdateConfig(GnssAdapter& adapter, + LocApiBase& api, + GnssConfig config, + uint32_t* ids, + size_t count) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mConfig(config), + mIds(ids), + mCount(count) {} + inline virtual ~MsgGnssUpdateConfig() + { + delete[] mIds; + } + inline virtual void proc() const { + //const size_t MAX_BITS_COUNT = 10; + //LocationError errs[MAX_BITS_COUNT] = {}; + LocationError* errs = new LocationError[mCount]; + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t index = 0; + + if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock); + ContextBase::mGps_conf.GPS_LOCK = newGpsLock; + if (0 == mAdapter.getPowerVoteId()) { + err = mApi.setGpsLock(mConfig.gpsLock); + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + uint32_t newSuplVersion = mAdapter.convertSuplVersion(mConfig.suplVersion); + if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.SUPL_VER = newSuplVersion; + err = mApi.setSUPLVersion(mConfig.suplVersion); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + char serverUrl[MAX_URL_LEN] = {}; + uint32_t length = 0; + const char noHost[] = "NONE"; + if (NULL == mConfig.assistanceServer.hostName || + strncasecmp(noHost, + mConfig.assistanceServer.hostName, + sizeof(noHost)) == 0) { + } else { + length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", + mConfig.assistanceServer.hostName, + mConfig.assistanceServer.port); + } + + if (sizeof(serverUrl) > length) { + err = mApi.setServer(serverUrl, length); + } else { + err = LOCATION_ERROR_INVALID_PARAMETER; + } + } else { + err = LOCATION_ERROR_SUCCESS; + } + } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + struct in_addr addr; + if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, &addr)) { + LOC_LOGE("%s]: hostName %s cannot be resolved", + __func__, mConfig.assistanceServer.hostName); + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + unsigned int ip = htonl(addr.s_addr); + err = mApi.setServer(ip, mConfig.assistanceServer.port, + LOC_AGPS_CDMA_PDE_SERVER); + } + } else { + err = LOCATION_ERROR_SUCCESS; + } + } else { + LOC_LOGE("%s]: Not a valid gnss assistance type %u", + __func__, mConfig.assistanceServer.type); + err = LOCATION_ERROR_INVALID_PARAMETER; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + uint32_t newLppProfile = mAdapter.convertLppProfile(mConfig.lppProfile); + if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.LPP_PROFILE = newLppProfile; + err = mApi.setLPPConfig(mConfig.lppProfile); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + uint32_t newLppeControlPlaneMask = + mAdapter.convertLppeCp(mConfig.lppeControlPlaneMask); + if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) { + ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask; + err = mApi.setLPPeProtocolCp(mConfig.lppeControlPlaneMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + uint32_t newLppeUserPlaneMask = + mAdapter.convertLppeUp(mConfig.lppeUserPlaneMask); + if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) { + ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask; + err = mApi.setLPPeProtocolUp(mConfig.lppeUserPlaneMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + uint32_t newAGloProtMask = + mAdapter.convertAGloProt(mConfig.aGlonassPositionProtocolMask); + if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask; + err = mApi.setAGLONASSProtocol(mConfig.aGlonassPositionProtocolMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) { + uint32_t newEP4ES = mAdapter.convertEP4ES(mConfig.emergencyPdnForEmergencySupl); + if (newEP4ES != ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = newEP4ES; + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) { + uint32_t newSuplEs = mAdapter.convertSuplEs(mConfig.suplEmergencyServices); + if (newSuplEs != ContextBase::mGps_conf.SUPL_ES) { + ContextBase::mGps_conf.SUPL_ES = newSuplEs; + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) { + uint32_t newSuplMode = mAdapter.convertSuplMode(mConfig.suplModeMask); + if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) { + ContextBase::mGps_conf.SUPL_MODE = newSuplMode; + mAdapter.getUlpProxy()->setCapabilities( + ContextBase::getCarrierCapabilities()); + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + + mAdapter.reportResponse(index, errs, mIds); + delete[] errs; + } + }; + + if (NULL != ids) { + sendMsg(new MsgGnssUpdateConfig(*this, *mLocApi, config, ids, count)); + } else { + LOC_LOGE("%s]: No GNSS config items to update", __func__); + } + + return ids; +} + +uint32_t +GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: client %p id %u", __func__, sessionId); + + struct MsgDeleteAidingData : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + uint32_t mSessionId; + GnssAidingData mData; + inline MsgDeleteAidingData(GnssAdapter& adapter, + LocApiBase& api, + uint32_t sessionId, + GnssAidingData& data) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mSessionId(sessionId), + mData(data) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + #ifdef TARGET_BUILD_VARIANT_USER + err = LOCATION_ERROR_NOT_SUPPORTED; + #endif + if (LOCATION_ERROR_SUCCESS == err) { + err = mApi.deleteAidingData(mData); + } + mAdapter.reportResponse(err, mSessionId); + } + }; + + sendMsg(new MsgDeleteAidingData(*this, *mLocApi, sessionId, data)); + return sessionId; +} + +void +GnssAdapter::injectLocationCommand(double latitude, double longitude, float accuracy) +{ + LOC_LOGD("%s]: latitude %8.4f longitude %8.4f accuracy %8.4f", + __func__, latitude, longitude, accuracy); + + struct MsgInjectLocation : public LocMsg { + LocApiBase& mApi; + ContextBase& mContext; + double mLatitude; + double mLongitude; + float mAccuracy; + inline MsgInjectLocation(LocApiBase& api, + ContextBase& context, + double latitude, + double longitude, + float accuracy) : + LocMsg(), + mApi(api), + mContext(context), + mLatitude(latitude), + mLongitude(longitude), + mAccuracy(accuracy) {} + inline virtual void proc() const { + if (!mContext.hasCPIExtendedCapabilities()) { + mApi.injectPosition(mLatitude, mLongitude, mAccuracy); + } + } + }; + + sendMsg(new MsgInjectLocation(*mLocApi, *mContext, latitude, longitude, accuracy)); +} + +void +GnssAdapter::injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty) +{ + LOC_LOGD("%s]: time %lld timeReference %lld uncertainty %d", + __func__, time, timeReference, uncertainty); + + struct MsgInjectTime : public LocMsg { + LocApiBase& mApi; + ContextBase& mContext; + int64_t mTime; + int64_t mTimeReference; + int32_t mUncertainty; + inline MsgInjectTime(LocApiBase& api, + ContextBase& context, + int64_t time, + int64_t timeReference, + int32_t uncertainty) : + LocMsg(), + mApi(api), + mContext(context), + mTime(time), + mTimeReference(timeReference), + mUncertainty(uncertainty) {} + inline virtual void proc() const { + mApi.setTime(mTime, mTimeReference, mUncertainty); + } + }; + + sendMsg(new MsgInjectTime(*mLocApi, *mContext, time, timeReference, uncertainty)); +} + +void +GnssAdapter::setUlpProxyCommand(UlpProxyBase* ulp) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgSetUlpProxy : public LocMsg { + GnssAdapter& mAdapter; + UlpProxyBase* mUlp; + inline MsgSetUlpProxy(GnssAdapter& adapter, + UlpProxyBase* ulp) : + LocMsg(), + mAdapter(adapter), + mUlp(ulp) {} + inline virtual void proc() const { + mAdapter.setUlpProxy(mUlp); + } + }; + + sendMsg(new MsgSetUlpProxy(*this, ulp)); +} + +void +GnssAdapter::setUlpProxy(UlpProxyBase* ulp) +{ + if (ulp == mUlpProxy) { + //This takes care of the case when double initalization happens + //and we get the same object back for UlpProxyBase . Do nothing + return; + } + + LOC_LOGV("%s]: %p", __func__, ulp); + if (NULL == ulp) { + LOC_LOGE("%s]: ulp pointer is NULL", __func__); + ulp = new UlpProxyBase(); + } + + if (LOC_POSITION_MODE_INVALID != mUlpProxy->mPosMode.mode) { + // need to send this mode and start msg to ULP + ulp->sendFixMode(mUlpProxy->mPosMode); + } + + if (mUlpProxy->mFixSet) { + ulp->sendStartFix(); + } + + delete mUlpProxy; + mUlpProxy = ulp; +} + +void +GnssAdapter::addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks) +{ + LOC_LOGD("%s]: client %p", __func__, client); + + struct MsgAddClient : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + const LocationCallbacks mCallbacks; + inline MsgAddClient(GnssAdapter& adapter, + LocationAPI* client, + const LocationCallbacks& callbacks) : + LocMsg(), + mAdapter(adapter), + mClient(client), + mCallbacks(callbacks) {} + inline virtual void proc() const { + mAdapter.saveClient(mClient, mCallbacks); + } + }; + + sendMsg(new MsgAddClient(*this, client, callbacks)); +} + +void +GnssAdapter::removeClientCommand(LocationAPI* client) +{ + LOC_LOGD("%s]: client %p", __func__, client); + + struct MsgRemoveClient : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + inline MsgRemoveClient(GnssAdapter& adapter, + LocationAPI* client) : + LocMsg(), + mAdapter(adapter), + mClient(client) {} + inline virtual void proc() const { + mAdapter.stopClientSessions(mClient); + mAdapter.eraseClient(mClient); + } + }; + + sendMsg(new MsgRemoveClient(*this, client)); +} + +void +GnssAdapter::stopClientSessions(LocationAPI* client) +{ + LOC_LOGD("%s]: client %p", __func__, client); + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end();) { + if (client == it->first.client) { + LocationError err = stopTrackingMultiplex(it->first.client, it->first.id); + if (LOCATION_ERROR_SUCCESS == err) { + it = mTrackingSessions.erase(it); + continue; + } + } + ++it; // increment only when not erasing an iterator + } + +} + +void +GnssAdapter::updateClientsEventMask() +{ + LOC_API_ADAPTER_EVENT_MASK_T mask = 0; + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (it->second.trackingCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT; + } + if (it->second.gnssNiCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; + } + if (it->second.gnssSvCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_SATELLITE_REPORT; + } + if (it->second.gnssNmeaCb != nullptr && + NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) { + mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; + } + if (it->second.gnssMeasurementsCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; + } + } + updateEvtMask(mask, LOC_REGISTRATION_MASK_SET); +} + +void +GnssAdapter::handleEngineUpEvent() +{ + struct MsgRestartSessions : public LocMsg { + GnssAdapter& mAdapter; + inline MsgRestartSessions(GnssAdapter& adapter) : + LocMsg(), + mAdapter(adapter) {} + virtual void proc() const { + mAdapter.restartSessions(); + } + }; + + setConfigCommand(); + sendMsg(new MsgRestartSessions(*this)); +} + +void +GnssAdapter::restartSessions() +{ + LOC_LOGD("%s]: ", __func__); + + if (mTrackingSessions.empty()) { + return; + } + + // get the LocationOptions that has the smallest interval, which should be the active one + LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) { + if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet + it->second.minInterval < smallestIntervalOptions.minInterval) { + smallestIntervalOptions = it->second; + } + } + + startTracking(smallestIntervalOptions); +} + +void +GnssAdapter::requestCapabilitiesCommand(LocationAPI* client) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgRequestCapabilities : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + inline MsgRequestCapabilities(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client) {} + inline virtual void proc() const { + LocationCallbacks callbacks = mAdapter.getClientCallbacks(mClient); + if (callbacks.capabilitiesCb == nullptr) { + LOC_LOGE("%s]: capabilitiesCb is NULL", __func__); + return; + } + + LocationCapabilitiesMask mask = {}; + // time based tracking always supported + mask |= LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT; + if (mApi.isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)){ + mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT | + LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT; + } + if (mApi.isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) { + mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT; + } + // geofence always supported + mask |= LOCATION_CAPABILITIES_GEOFENCE_BIT; + if (mApi.gnssConstellationConfig()) { + mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT; + } + uint32_t carrierCapabilities = ContextBase::getCarrierCapabilities(); + if (carrierCapabilities & LOC_GPS_CAPABILITY_MSB) { + mask |= LOCATION_CAPABILITIES_GNSS_MSB_BIT; + } + if (LOC_GPS_CAPABILITY_MSA & carrierCapabilities) { + mask |= LOCATION_CAPABILITIES_GNSS_MSA_BIT; + } + + callbacks.capabilitiesCb(mask); + } + }; + + sendMsg(new MsgRequestCapabilities(*this, *mLocApi, client)); +} + +LocationCallbacks +GnssAdapter::getClientCallbacks(LocationAPI* client) +{ + LocationCallbacks callbacks = {}; + auto it = mClientData.find(client); + if (it != mClientData.end()) { + callbacks = it->second; + } + return callbacks; +} + +void +GnssAdapter::saveClient(LocationAPI* client, const LocationCallbacks& callbacks) +{ + mClientData[client] = callbacks; + updateClientsEventMask(); +} + +void +GnssAdapter::eraseClient(LocationAPI* client) +{ + auto it = mClientData.find(client); + if (it != mClientData.end()) { + mClientData.erase(it); + } + updateClientsEventMask(); +} + +bool +GnssAdapter::hasTrackingCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.trackingCb); +} + +bool +GnssAdapter::hasMeasurementsCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.gnssMeasurementsCb); +} + +bool +GnssAdapter::isTrackingSession(LocationAPI* client, uint32_t sessionId) +{ + LocationSessionKey key(client, sessionId); + return (mTrackingSessions.find(key) != mTrackingSessions.end()); +} + +void +GnssAdapter::saveTrackingSession(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options) +{ + LocationSessionKey key(client, sessionId); + mTrackingSessions[key] = options; +} + +void +GnssAdapter::eraseTrackingSession(LocationAPI* client, uint32_t sessionId) +{ + LocationSessionKey key(client, sessionId); + auto it = mTrackingSessions.find(key); + if (it != mTrackingSessions.end()) { + mTrackingSessions.erase(it); + } + +} + +void +GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId) +{ + LOC_LOGD("%s]: client %p id %u err %u", __func__, client, sessionId, err); + + auto it = mClientData.find(client); + if (it != mClientData.end() && + it->second.responseCb != nullptr) { + it->second.responseCb(err, sessionId); + } else { + LOC_LOGW("%s]: client %p id %u not found in data", __func__, client, sessionId); + } +} + +void +GnssAdapter::reportResponse(LocationError err, uint32_t sessionId) +{ + LOC_LOGD("%s]: id %u err %u", __func__, sessionId, err); + + if (mControlCallbacks.size > 0 && mControlCallbacks.responseCb != nullptr) { + mControlCallbacks.responseCb(err, sessionId); + } else { + LOC_LOGW("%s]: control client response callback not found", __func__); + } +} + +void +GnssAdapter::reportResponse(size_t count, LocationError* errs, uint32_t* ids) +{ + IF_LOC_LOGD { + std::string idsString = "["; + std::string errsString = "["; + if (NULL != ids && NULL != errs) { + for (size_t i=0; i < count; ++i) { + idsString += std::to_string(ids[i]) + " "; + errsString += std::to_string(errs[i]) + " "; + } + } + idsString += "]"; + errsString += "]"; + + LOC_LOGD("%s]: ids %s errs %s", + __func__, idsString.c_str(), errsString.c_str()); + } + + if (mControlCallbacks.size > 0 && mControlCallbacks.collectiveResponseCb != nullptr) { + mControlCallbacks.collectiveResponseCb(count, errs, ids); + } else { + LOC_LOGW("%s]: control client callback not found", __func__); + } +} + +uint32_t +GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: client %p id %u minInterval %u mode %u", + __func__, client, sessionId, options.minInterval, options.mode); + + struct MsgStartTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + LocationOptions mOptions; + inline MsgStartTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId, + LocationOptions options) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId), + mOptions(options) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mAdapter.hasTrackingCallback(mClient) && + !mAdapter.hasMeasurementsCallback(mClient)) { + err = LOCATION_ERROR_CALLBACK_MISSING; + } else if (0 == mOptions.size) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.startTrackingMultiplex(mOptions); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + }; + + sendMsg(new MsgStartTracking(*this, *mLocApi, client, sessionId, options)); + return sessionId; + +} + +LocationError +GnssAdapter::startTrackingMultiplex(const LocationOptions& options) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + bool updateTrackingSession = false; + + if (mTrackingSessions.empty()) { + err = startTracking(options); + } else { + // get the LocationOptions that has the smallest interval, which should be the active one + LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) { + if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet + it->second.minInterval < smallestIntervalOptions.minInterval) { + smallestIntervalOptions = it->second; + } + } + // if new session's minInterval is smaller than any in other sessions + if (options.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with new options + err = startTracking(options); + } + } + + return err; +} + +LocationError +GnssAdapter::startTracking(const LocationOptions& options) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + LocPosMode locPosMode = {}; + convertOptions(locPosMode, options); + if (!mUlpProxy->sendFixMode(locPosMode)) { + // do nothing + } + if (!mUlpProxy->sendStartFix()) { + loc_api_adapter_err apiErr = mLocApi->startFix(locPosMode); + if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { + err = LOCATION_ERROR_SUCCESS; + // save supl mode, which is used for NMEA generation + setSuplMode(options.mode); + } else { + err = LOCATION_ERROR_GENERAL_FAILURE; + } + } + + return err; +} + +void +GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode) +{ + LOC_LOGD("%s]: min_interval %u mode %u", + __func__, locPosMode.min_interval, locPosMode.mode); + + struct MsgSetPositionMode : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocPosMode mLocPosMode; + inline MsgSetPositionMode(GnssAdapter& adapter, + LocApiBase& api, + LocPosMode& locPosMode) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mLocPosMode(locPosMode) {} + inline virtual void proc() const { + // saves the mode in adapter to be used when startTrackingCommand is called from ULP + mAdapter.setUlpPositionMode(mLocPosMode); + mApi.setPositionMode(mLocPosMode); + } + }; + + sendMsg(new MsgSetPositionMode(*this, *mLocApi, locPosMode)); +} + +void +GnssAdapter::startTrackingCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgStartTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgStartTracking(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + // we get this call from ULP, so just call LocApi without multiplexing because + // ulp would be doing the multiplexing for us if it is present + LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode(); + mApi.startFix(ulpPositionMode); + // save supl mode, which is used for NMEA generation + mAdapter.setSuplMode((GnssSuplMode)ulpPositionMode.mode); + } + }; + + sendMsg(new MsgStartTracking(*this, *mLocApi)); +} + +void +GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, + LocationOptions& options) +{ + LOC_LOGD("%s]: client %p id %u minInterval %u mode %u", + __func__, client, id, options.minInterval, options.mode); + + struct MsgUpdateTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + LocationOptions mOptions; + inline MsgUpdateTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId, + LocationOptions options) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId), + mOptions(options) {} + inline virtual void proc() const { + if (mAdapter.isTrackingSession(mClient, mSessionId)) { + LocationError err = LOCATION_ERROR_SUCCESS; + if (0 == mOptions.size) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.startTrackingMultiplex(mOptions); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + // we do not reportResponse for the case where there is no existing tracking session + // for the client and id being used, since updateTrackingCommand can be sent to both + // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response + } + }; + + sendMsg(new MsgUpdateTracking(*this, *mLocApi, client, id, options)); +} + +void +GnssAdapter::stopTrackingCommand(LocationAPI* client, uint32_t id) +{ + LOC_LOGD("%s]: client %p id %u", __func__, client, id); + + struct MsgStopTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + inline MsgStopTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId) {} + inline virtual void proc() const { + if (mAdapter.isTrackingSession(mClient, mSessionId)) { + LocationError err = LOCATION_ERROR_SUCCESS; + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.stopTrackingMultiplex(mClient, mSessionId); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.eraseTrackingSession(mClient, mSessionId); + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + // we do not reportResponse for the case where there is no existing tracking session + // for the client and id being used, since stopTrackingCommand can be sent to both + // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response + + } + }; + + sendMsg(new MsgStopTracking(*this, *mLocApi, client, id)); +} + +LocationError +GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + + if (1 == mTrackingSessions.size()) { + err = stopTracking(); + } else { + LocationSessionKey key(client, id); + + // get the session we are stopping + auto it = mTrackingSessions.find(key); + if (it != mTrackingSessions.end()) { + // find the next smallest interval, other than the session we are stopping + LocationOptions smallestIntervalOptions; // size will be zero until set for the first time + for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) { + // if session is not the one we are stopping and either smallest interval is not set + // or there is a new smallest interval, then set the new smallest interval + if (it2->first != key && (0 == smallestIntervalOptions.size || + it2->second.minInterval < smallestIntervalOptions.minInterval)) { + smallestIntervalOptions = it2->second; + } + } + // if session we are stopping has smaller interval then next smallest + if (it->second.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with next smallest interval + err = startTracking(smallestIntervalOptions); + } + } + } + + return err; +} + +LocationError +GnssAdapter::stopTracking() +{ + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mUlpProxy->sendStopFix()) { + loc_api_adapter_err apiErr = mLocApi->stopFix(); + if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { + err = LOCATION_ERROR_SUCCESS; + } else { + err = LOCATION_ERROR_GENERAL_FAILURE; + } + } + + return err; +} + +void +GnssAdapter::stopTrackingCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgStopTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgStopTracking(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + // clear the position mode + LocPosMode mLocPosMode = {}; + mLocPosMode.mode = LOC_POSITION_MODE_INVALID; + mAdapter.setUlpPositionMode(mLocPosMode); + // don't need to multiplex because ULP will do that for us if it is present + mApi.stopFix(); + } + }; + + sendMsg(new MsgStopTracking(*this, *mLocApi)); +} + +void +GnssAdapter::getZppCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgGetZpp : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgGetZpp(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + UlpLocation location = {}; + LocPosTechMask techMask = LOC_POS_TECH_MASK_DEFAULT; + GpsLocationExtended locationExtended = {}; + locationExtended.size = sizeof(locationExtended); + + mApi.getBestAvailableZppFix(location.gpsLocation, techMask); + //Mark the location source as from ZPP + location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; + location.position_source = ULP_LOCATION_IS_FROM_ZPP; + + mAdapter.getUlpProxy()->reportPosition(location, + locationExtended, + LOC_SESS_SUCCESS, + techMask); + } + }; + + sendMsg(new MsgGetZpp(*this, *mLocApi)); +} + +bool +GnssAdapter::hasNiNotifyCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.gnssNiCb); +} + +void +GnssAdapter::gnssNiResponseCommand(LocationAPI* client, + uint32_t id, + GnssNiResponse response) +{ + LOC_LOGD("%s]: client %p id %u response %u", __func__, client, id, response); + + struct MsgGnssNiResponse : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + uint32_t mSessionId; + GnssNiResponse mResponse; + inline MsgGnssNiResponse(GnssAdapter& adapter, + LocationAPI* client, + uint32_t sessionId, + GnssNiResponse response) : + LocMsg(), + mAdapter(adapter), + mClient(client), + mSessionId(sessionId), + mResponse(response) {} + inline virtual void proc() const { + NiData& niData = mAdapter.getNiData(); + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mAdapter.hasNiNotifyCallback(mClient)) { + err = LOCATION_ERROR_ID_UNKNOWN; + } else { + NiSession* pSession = NULL; + if (mSessionId == niData.sessionEs.reqID && + NULL != niData.sessionEs.rawRequest) { + pSession = &niData.sessionEs; + // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted + if (mResponse == GNSS_NI_RESPONSE_ACCEPT && + NULL != niData.session.rawRequest) { + pthread_mutex_lock(&niData.session.tLock); + niData.session.resp = GNSS_NI_RESPONSE_IGNORE; + niData.session.respRecvd = true; + pthread_cond_signal(&niData.session.tCond); + pthread_mutex_unlock(&niData.session.tLock); + } + } else if (mSessionId == niData.session.reqID && + NULL != niData.session.rawRequest) { + pSession = &niData.session; + } + + if (pSession) { + LOC_LOGI("%s]: gnssNiResponseCommand: send user mResponse %u for id %u", + __func__, mResponse, mSessionId); + pthread_mutex_lock(&pSession->tLock); + pSession->resp = mResponse; + pSession->respRecvd = true; + pthread_cond_signal(&pSession->tCond); + pthread_mutex_unlock(&pSession->tLock); + } else { + err = LOCATION_ERROR_ID_UNKNOWN; + LOC_LOGE("%s]: gnssNiResponseCommand: id %u not an active session", + __func__, mSessionId); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + }; + + sendMsg(new MsgGnssNiResponse(*this, client, id, response)); + +} + +void +GnssAdapter::gnssNiResponseCommand(GnssNiResponse response, void* rawRequest) +{ + LOC_LOGD("%s]: response %u", __func__, response); + + struct MsgGnssNiResponse : public LocMsg { + LocApiBase& mApi; + const GnssNiResponse mResponse; + const void* mPayload; + inline MsgGnssNiResponse(LocApiBase& api, + const GnssNiResponse response, + const void* rawRequest) : + LocMsg(), + mApi(api), + mResponse(response), + mPayload(rawRequest) {} + inline virtual ~MsgGnssNiResponse() { + // this is a bit weird since mPayload is not + // allocated by this class. But there is no better way. + // mPayload actually won't be NULL here. + free((void*)mPayload); + } + inline virtual void proc() const { + mApi.informNiResponse(mResponse, mPayload); + } + }; + + sendMsg(new MsgGnssNiResponse(*mLocApi, response, rawRequest)); + +} + +uint32_t +GnssAdapter::enableCommand(LocationTechnologyType techType) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: id %u techType %u", __func__, sessionId, techType); + + struct MsgEnableGnss : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + ContextBase& mContext; + uint32_t mSessionId; + LocationTechnologyType mTechType; + inline MsgEnableGnss(GnssAdapter& adapter, + LocApiBase& api, + ContextBase& context, + uint32_t sessionId, + LocationTechnologyType techType) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mContext(context), + mSessionId(sessionId), + mTechType(techType) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t powerVoteId = mAdapter.getPowerVoteId(); + if (mTechType != LOCATION_TECHNOLOGY_TYPE_GNSS) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else if (powerVoteId > 0) { + err = LOCATION_ERROR_ALREADY_STARTED; + } else { + mContext.modemPowerVote(true); + mAdapter.setPowerVoteId(mSessionId); + mApi.setGpsLock(GNSS_CONFIG_GPS_LOCK_NONE); + } + mAdapter.reportResponse(err, mSessionId); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgEnableGnss(*this, *mLocApi, *mContext, sessionId, techType)); + } else { + LOC_LOGE("%s]: Context is NULL", __func__); + } + + return sessionId; +} + +void +GnssAdapter::disableCommand(uint32_t id) +{ + LOC_LOGD("%s]: id %u", __func__, id); + + struct MsgDisableGnss : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + ContextBase& mContext; + uint32_t mSessionId; + inline MsgDisableGnss(GnssAdapter& adapter, + LocApiBase& api, + ContextBase& context, + uint32_t sessionId) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mContext(context), + mSessionId(sessionId) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t powerVoteId = mAdapter.getPowerVoteId(); + if (powerVoteId != mSessionId) { + err = LOCATION_ERROR_ID_UNKNOWN; + } else { + mContext.modemPowerVote(false); + mAdapter.setPowerVoteId(0); + mApi.setGpsLock(mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK)); + } + mAdapter.reportResponse(err, mSessionId); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgDisableGnss(*this, *mLocApi, *mContext, id)); + } + +} + +void +GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask, + bool fromUlp) +{ + LOC_LOGD("%s]: fromUlp %u status %u", __func__, fromUlp, status); + + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp) { + if (mUlpProxy->reportPosition(ulpLocation, locationExtended, + status, techMask)) { + return; + } + } + + struct MsgReportPosition : public LocMsg { + GnssAdapter& mAdapter; + const UlpLocation mUlpLocation; + const GpsLocationExtended mLocationExtended; + loc_sess_status mStatus; + LocPosTechMask mTechMask; + inline MsgReportPosition(GnssAdapter& adapter, + const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + loc_sess_status status, + LocPosTechMask techMask) : + LocMsg(), + mAdapter(adapter), + mUlpLocation(ulpLocation), + mLocationExtended(locationExtended), + mStatus(status), + mTechMask(techMask) {} + inline virtual void proc() const { + mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask); + } + }; + + sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask)); +} + +void +GnssAdapter::reportPosition(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask) +{ + bool reported = false; + if (LOC_SESS_FAILURE == status) { + Location invalidLocation = {}; + invalidLocation.size = sizeof(Location); + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.trackingCb) { + it->second.trackingCb(invalidLocation); + } + } + reported = true; + } + // what's in the else if is... (line by line) + // 1. this is a final fix; and + // 1.1 it is a Satellite fix; or + // 1.2 it is a sensor fix + // 2. (must be intermediate fix... implicit) + // 2.1 we accepte intermediate; and + // 2.2 it is NOT the case that + // 2.2.1 there is inaccuracy; and + // 2.2.2 we care about inaccuracy; and + // 2.2.3 the inaccuracy exceeds our tolerance + else if ((LOC_SESS_SUCCESS == status && + ((LOC_POS_TECH_MASK_SATELLITE | + LOC_POS_TECH_MASK_SENSORS | + LOC_POS_TECH_MASK_HYBRID) & + techMask)) || + (LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS && + !((ulpLocation.gpsLocation.flags & + LOC_GPS_LOCATION_HAS_ACCURACY) && + (ContextBase::mGps_conf.ACCURACY_THRES != 0) && + (ulpLocation.gpsLocation.accuracy > + ContextBase::mGps_conf.ACCURACY_THRES)))) { + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) { + mGnssSvIdUsedInPosAvail = true; + mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids; + } + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.trackingCb) { + Location location = {}; + convertLocation(location, ulpLocation.gpsLocation, techMask); + it->second.trackingCb(location); + } + if (nullptr != it->second.gnssLocationInfoCb) { + GnssLocationInfoNotification locationInfo = {}; + convertLocationInfo(locationInfo, locationExtended); + it->second.gnssLocationInfoCb(locationInfo); + } + } + reported = true; + } + + if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) { + if (reported && status != LOC_SESS_FAILURE) { + generateNmea(ulpLocation, locationExtended); + } else { + generateNmeaBlank(); + } + } + + // Free the allocated memory for rawData + UlpLocation* gp = (UlpLocation*)&(ulpLocation); + if (gp != NULL && gp->rawData != NULL) + { + delete (char*)gp->rawData; + gp->rawData = NULL; + gp->rawDataSize = 0; + } +} + +void +GnssAdapter::reportSvEvent(const GnssSvNotification& svNotify, + bool fromUlp) +{ + LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp); + + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp) { + if (mUlpProxy->reportSv(svNotify)) { + return; + } + } + + struct MsgReportSv : public LocMsg { + GnssAdapter& mAdapter; + const GnssSvNotification mSvNotify; + inline MsgReportSv(GnssAdapter& adapter, + const GnssSvNotification& svNotify) : + LocMsg(), + mAdapter(adapter), + mSvNotify(svNotify) {} + inline virtual void proc() const { + mAdapter.reportSv((GnssSvNotification&)mSvNotify); + } + }; + + sendMsg(new MsgReportSv(*this, svNotify)); +} + +void +GnssAdapter::reportSv(GnssSvNotification& svNotify) +{ + if (mGnssSvIdUsedInPosAvail) { + int numSv = svNotify.count; + int16_t gnssSvId = 0; + int prnMin = 0; + uint64_t svUsedIdMask = 0; + for (int i=0; i < numSv; i++) { + gnssSvId = svNotify.gnssSvs[i].svId; + if (gnssSvId <= GPS_SV_PRN_MAX) { + svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask; + prnMin = GPS_SV_PRN_MIN; + } else if ((gnssSvId >= GLO_SV_PRN_MIN) && (gnssSvId <= GLO_SV_PRN_MAX)) { + svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask; + prnMin = GLO_SV_PRN_MIN; + } else if ((gnssSvId >= BDS_SV_PRN_MIN) && (gnssSvId <= BDS_SV_PRN_MAX)) { + svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask; + prnMin = BDS_SV_PRN_MIN; + } else if ((gnssSvId >= GAL_SV_PRN_MIN) && (gnssSvId <= GAL_SV_PRN_MAX)) { + svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask; + prnMin = GAL_SV_PRN_MIN; + } + + // If SV ID was used in previous position fix, then set USED_IN_FIX + // flag, else clear the USED_IN_FIX flag. + if (svUsedIdMask & (1 << (gnssSvId - prnMin))) { + svNotify.gnssSvs[i].gnssSvOptionsMask |= GNSS_SV_OPTIONS_USED_IN_FIX_BIT; + } else { + svNotify.gnssSvs[i].gnssSvOptionsMask &= ~GNSS_SV_OPTIONS_USED_IN_FIX_BIT; + } + } + } + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssSvCb) { + it->second.gnssSvCb(svNotify); + } + } + + if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) { + generateNmea(svNotify); + } + + mGnssSvIdUsedInPosAvail = false; +} + +void +GnssAdapter::reportNmeaEvent(const char* nmea, size_t length, bool fromUlp) +{ + //LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp); + + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp) { + if (mUlpProxy->reportNmea(nmea, length)) { + return; + } + } + + struct MsgReportNmea : public LocMsg { + GnssAdapter& mAdapter; + const char* mNmea; + size_t mLength; + inline MsgReportNmea(GnssAdapter& adapter, + const char* nmea, + size_t length) : + LocMsg(), + mAdapter(adapter), + mNmea(new char[length]), + mLength(length) { + memcpy((void*)mNmea, (void*)nmea, length); + } + inline virtual ~MsgReportNmea() + { + delete[] mNmea; + } + inline virtual void proc() const { + mAdapter.reportNmea(mNmea, mLength); + } + }; + + sendMsg(new MsgReportNmea(*this, nmea, length)); +} + +void +GnssAdapter::reportNmea(const char* nmea, size_t length) +{ + GnssNmeaNotification nmeaNotification = {}; + nmeaNotification.size = sizeof(GnssNmeaNotification); + + struct timeval tv; + gettimeofday(&tv, (struct timezone *) NULL); + int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; + nmeaNotification.timestamp = now; + nmeaNotification.nmea = nmea; + nmeaNotification.length = length; + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssNmeaCb) { + it->second.gnssNmeaCb(nmeaNotification); + } + } + +} + +bool +GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* data) +{ + LOC_LOGI("%s]: notif_type: %d, timeout: %d, default_resp: %d" + "requestor_id: %s (encoding: %d) text: %s text (encoding: %d) extras: %s", + __func__, notify.type, notify.timeout, notify.timeoutResponse, + notify.requestor, notify.requestorEncoding, + notify.message, notify.messageEncoding, notify.extras); + + struct MsgReportNiNotify : public LocMsg { + GnssAdapter& mAdapter; + const GnssNiNotification mNotify; + const void* mData; + inline MsgReportNiNotify(GnssAdapter& adapter, + const GnssNiNotification& notify, + const void* data) : + LocMsg(), + mAdapter(adapter), + mNotify(notify), + mData(data) {} + inline virtual void proc() const { + mAdapter.requestNiNotify(mNotify, mData); + } + }; + + sendMsg(new MsgReportNiNotify(*this, notify, data)); + + return true; +} + +static void* niThreadProc(void *args) +{ + NiSession* pSession = (NiSession*)args; + int rc = 0; /* return code from pthread calls */ + + struct timeval present_time; + struct timespec expire_time; + + pthread_mutex_lock(&pSession->tLock); + /* Calculate absolute expire time */ + gettimeofday(&present_time, NULL); + expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft; + expire_time.tv_nsec = present_time.tv_usec * 1000; + LOC_LOGD("%s]: time out set for abs time %ld with delay %d sec", + __func__, (long)expire_time.tv_sec, pSession->respTimeLeft); + + while (!pSession->respRecvd) { + rc = pthread_cond_timedwait(&pSession->tCond, + &pSession->tLock, + &expire_time); + if (rc == ETIMEDOUT) { + pSession->resp = GNSS_NI_RESPONSE_NO_RESPONSE; + LOC_LOGD("%s]: time out after valting for specified time. Ret Val %d", + __func__, rc); + break; + } + } + LOC_LOGD("%s]: Java layer has sent us a user response and return value from " + "pthread_cond_timedwait = %d pSession->resp is %u", __func__, rc, pSession->resp); + pSession->respRecvd = false; /* Reset the user response flag for the next session*/ + + // adding this check to support modem restart, in which case, we need the thread + // to exit without calling sending data. We made sure that rawRequest is NULL in + // loc_eng_ni_reset_on_engine_restart() + GnssAdapter* adapter = pSession->adapter; + GnssNiResponse resp; + void* rawRequest = NULL; + bool sendResponse = false; + + if (NULL != pSession->rawRequest) { + if (pSession->resp != GNSS_NI_RESPONSE_IGNORE) { + resp = pSession->resp; + rawRequest = pSession->rawRequest; + sendResponse = true; + } else { + free(pSession->rawRequest); + } + pSession->rawRequest = NULL; + } + pthread_mutex_unlock(&pSession->tLock); + + pSession->respTimeLeft = 0; + pSession->reqID = 0; + + if (sendResponse) { + adapter->gnssNiResponseCommand(resp, rawRequest); + } + + return NULL; +} + +bool +GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data) +{ + NiSession* pSession = NULL; + gnssNiCallback gnssNiCb = nullptr; + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssNiCb) { + gnssNiCb = it->second.gnssNiCb; + break; + } + } + if (nullptr == gnssNiCb) { + EXIT_LOG(%s, "no clients with gnssNiCb."); + return false; + } + + if (notify.type == GNSS_NI_TYPE_EMERGENCY_SUPL) { + if (NULL != mNiData.sessionEs.rawRequest) { + LOC_LOGI("%s]: supl es NI in progress, new supl es NI ignored, type: %d", + __func__, notify.type); + if (NULL != data) { + free((void*)data); + } + } else { + pSession = &mNiData.sessionEs; + } + } else { + if (NULL != mNiData.session.rawRequest || + NULL != mNiData.sessionEs.rawRequest) { + LOC_LOGI("%s]: supl NI in progress, new supl NI ignored, type: %d", + __func__, notify.type); + if (NULL != data) { + free((void*)data); + } + } else { + pSession = &mNiData.session; + } + } + + if (pSession) { + /* Save request */ + pSession->rawRequest = (void*)data; + pSession->reqID = ++mNiData.reqIDCounter; + pSession->adapter = this; + + int sessionId = pSession->reqID; + + /* For robustness, spawn a thread at this point to timeout to clear up the notification + * status, even though the OEM layer in java does not do so. + **/ + pSession->respTimeLeft = + 5 + (notify.timeout != 0 ? notify.timeout : LOC_NI_NO_RESPONSE_TIME); + + int rc = 0; + rc = pthread_create(&pSession->thread, NULL, niThreadProc, pSession); + if (rc) { + LOC_LOGE("%s]: Loc NI thread is not created.", __func__); + } + rc = pthread_detach(pSession->thread); + if (rc) { + LOC_LOGE("%s]: Loc NI thread is not detached.", __func__); + } + + if (nullptr != gnssNiCb) { + gnssNiCb(sessionId, notify); + } + } + + return true; +} + +void +GnssAdapter::reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgReportGnssMeasurementData : public LocMsg { + GnssAdapter& mAdapter; + const GnssMeasurementsNotification mMeasurementsNotify; + inline MsgReportGnssMeasurementData(GnssAdapter& adapter, + const GnssMeasurementsNotification& measurementsNotify) : + LocMsg(), + mAdapter(adapter), + mMeasurementsNotify(measurementsNotify) {} + inline virtual void proc() const { + mAdapter.reportGnssMeasurementData(mMeasurementsNotify); + } + }; + + sendMsg(new MsgReportGnssMeasurementData(*this, measurementsNotify)); +} + +void +GnssAdapter::reportGnssMeasurementData(const GnssMeasurementsNotification& measurementsNotify) +{ + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssMeasurementsCb) { + it->second.gnssMeasurementsCb(measurementsNotify); + } + } +} + +void +GnssAdapter::reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet) +{ + LOC_LOGD("%s]: ", __func__); + + // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. + mUlpProxy->reportSvMeasurement(svMeasurementSet); +} + +void +GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial) +{ + LOC_LOGD("%s]: ", __func__); + + // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. + mUlpProxy->reportSvPolynomial(svPolynomial); +} + +int +GnssAdapter::nmeaPutChecksum(char *nmea, size_t maxSize) +{ + uint8_t checksum = 0; + int length = 0; + + nmea++; //skip the $ + while (*nmea != '\0') { + checksum ^= *nmea++; + length++; + } + + // length now contains nmea sentence string length not including $ sign. + int checksumLength = snprintf(nmea,(maxSize-length-1),"*%02X\r\n", checksum); + + // total length of nmea sentence is length of nmea sentence inc $ sign plus + // length of checksum (+1 is to cover the $ character in the length). + return (length + checksumLength + 1); +} + +void +GnssAdapter::generateNmea(const GnssSvNotification& svNotify) +{ + char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; + + // ------$GPGSV------ + NmeaSvMeta gpsSvMeta = + {GNSS_SV_TYPE_GPS, "GP", 0, 0}; + generateNmeaGSV(svNotify, gpsSvMeta, sentence, sizeof(sentence)); + + // ------$GLGSV------ + NmeaSvMeta gloSvMeta = + {GNSS_SV_TYPE_GLONASS, "GL", 0, GLONASS_SV_ID_OFFSET}; + generateNmeaGSV(svNotify, gloSvMeta, sentence, sizeof(sentence)); + + // ------$GAGSV------ + NmeaSvMeta galSvMeta = + {GNSS_SV_TYPE_GALILEO, "GA", 0, 0}; + generateNmeaGSV(svNotify, galSvMeta, sentence, sizeof(sentence)); +} + +void +GnssAdapter::generateNmea(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended) +{ + + char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; + + time_t utcTime(ulpLocation.gpsLocation.timestamp/1000); + tm * pTm = gmtime(&utcTime); + if (NULL == pTm) { + LOC_LOGE("%s]: gmtime failed", __func__); + return; + } + + uint32_t svUsedCount = 0; + uint32_t count = 0; + bool isCombinedFix = (mGnssSvIdUsedInPosition.gps_sv_used_ids_mask ? 1 : 0) + + (mGnssSvIdUsedInPosition.glo_sv_used_ids_mask ? 1 : 0) + + (mGnssSvIdUsedInPosition.gal_sv_used_ids_mask ? 1 : 0) > 1; + NmeaSvMeta gnssSvMeta = + {GNSS_SV_TYPE_GPS, isCombinedFix ? "GN" : "GP", + mGnssSvIdUsedInPosition.gps_sv_used_ids_mask, 0}; + + // ---$GPGSA/$GNGSA--- + NmeaSvMeta gpsSvMeta = + {GNSS_SV_TYPE_GPS, isCombinedFix ? "GN" : "GP", + mGnssSvIdUsedInPosition.gps_sv_used_ids_mask, 0}; + count = generateNmeaGSA(locationExtended, gpsSvMeta, sentence, sizeof(sentence)); + if (count > 0) { + svUsedCount += count; + gnssSvMeta = gpsSvMeta; + } + + // ---$GLGSA/$GNGSA--- + NmeaSvMeta gloSvMeta = + {GNSS_SV_TYPE_GLONASS, isCombinedFix ? "GN" : "GL", + mGnssSvIdUsedInPosition.glo_sv_used_ids_mask, GLONASS_SV_ID_OFFSET}; + count = generateNmeaGSA(locationExtended, gloSvMeta, sentence, sizeof(sentence)); + if (count > 0) { + svUsedCount += count; + gnssSvMeta = gloSvMeta; + } + + // ---$GAGSA/$GNGSA--- + NmeaSvMeta galSvMeta = + {GNSS_SV_TYPE_GALILEO, isCombinedFix ? "GN" : "GA", + mGnssSvIdUsedInPosition.gal_sv_used_ids_mask, 0}; + count = generateNmeaGSA(locationExtended, galSvMeta, sentence, sizeof(sentence)); + if (count > 0) { + svUsedCount += count; + gnssSvMeta = galSvMeta; + } + + // ---$GPVTG/$GLVTG/$GAVTG/$GNVTG--- + generateNmeaVTG(ulpLocation, locationExtended, gnssSvMeta, + sentence, sizeof(sentence)); + + // ---$GPRMC/$GLRMC/$GARMC/$GNRMC--- + generateNmeaRMC(ulpLocation, locationExtended, gnssSvMeta, + *pTm, sentence, sizeof(sentence)); + + // ---$GPGGA/$GLGGA/$GAGGA/$GNGGA--- + generateNmeaGGA(ulpLocation, locationExtended, gnssSvMeta, + *pTm, svUsedCount, sentence, sizeof(sentence)); + +} + +void +GnssAdapter::generateNmeaBlank() +{ + char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; + int length = 0; + + strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = nmeaPutChecksum(sentence, sizeof(sentence)); + reportNmeaEvent(sentence, length); + + strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = nmeaPutChecksum(sentence, sizeof(sentence)); + reportNmeaEvent(sentence, length); + + strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence)); + length = nmeaPutChecksum(sentence, sizeof(sentence)); + reportNmeaEvent(sentence, length); + + strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence)); + length = nmeaPutChecksum(sentence, sizeof(sentence)); + reportNmeaEvent(sentence, length); + + strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence)); + length = nmeaPutChecksum(sentence, sizeof(sentence)); + reportNmeaEvent(sentence, length); +} + +void +GnssAdapter::generateNmeaGSV(const GnssSvNotification& svNotify, NmeaSvMeta& svMeta, + char* sentence, size_t size) +{ + if (!sentence || size == 0) { + LOC_LOGE("%s]: NMEA Error invalid argument.", __func__); + return; + } + + char* pMarker = sentence; + int lengthRemaining = size; + int length = 0; + int sentenceCount = 0; + int sentenceNumber = 1; + int svCount = 0; + int sv = 1; + + for (sv=1; sv <= svNotify.count; sv++) { + if (svMeta.svType == svNotify.gnssSvs[sv - 1].type) { + // cache the used in fix mask, as it will be needed to send $GPGSA + // during the position report + if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == + (svNotify.gnssSvs[sv - 1].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { + svCount++; + } + } + } + + if (svCount == 0) { + // no svs in view, so just send a blank $--GSV sentence + snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", svMeta.talker); + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); + return; + } + + sv = 1; + sentenceNumber = 1; + sentenceCount = svCount / 4 + (svCount % 4 != 0); + + while (sentenceNumber <= sentenceCount) { + pMarker = sentence; + lengthRemaining = size; + + length = snprintf(pMarker, lengthRemaining, "$%sGSV,%d,%d,%02d", + svMeta.talker, sentenceCount, sentenceNumber, svCount); + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + for (int i=0; (sv <= svNotify.count) && (i < 4); sv++) { + if (svMeta.svType == svNotify.gnssSvs[sv - 1].type) { + length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", + svNotify.gnssSvs[sv - 1].svId, + (int)(0.5 + svNotify.gnssSvs[sv - 1].elevation), //float to int + (int)(0.5 + svNotify.gnssSvs[sv - 1].azimuth)); //float to int + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (svNotify.gnssSvs[sv - 1].cN0Dbhz > 0) { + length = snprintf(pMarker, lengthRemaining,"%02d", + (int)(0.5 + svNotify.gnssSvs[sv - 1].cN0Dbhz)); //float to int + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + } + i++; + } + } + + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); + sentenceNumber++; + } //while +} + +uint8_t +GnssAdapter::generateNmeaGSA(const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, char* sentence, size_t size) +{ + if (!sentence || size == 0) { + LOC_LOGE("%s]: NMEA Error invalid arguments.", __func__); + return 0; + } + + char* pMarker = sentence; + int lengthRemaining = size; + int length = 0; + + uint8_t svUsedCount = 0; + uint32_t svUsedList[32] = {0}; + + char fixType = '\0'; + + uint32_t svIdOffset = svMeta.svIdOffset; + uint32_t mask = svMeta.mask; + + for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) { + if (mask & 1) { + svUsedList[svUsedCount++] = i + svIdOffset; + } + mask = mask >> 1; + } + + if (svUsedCount == 0 && LOC_GNSS_CONSTELLATION_GPS != svMeta.svType) { + return 0; + } + + if (svUsedCount == 0) { + fixType = '1'; // no fix + } else if (svUsedCount <= 3) { + fixType = '2'; // 2D fix + } else { + fixType = '3'; // 3D fix + } + + // Start printing the sentence + // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc + // a : Mode : A : Automatic, allowed to automatically switch 2D/3D + // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix) + // xx : 12 SV ID + // p.p : Position DOP (Dilution of Precision) + // h.h : Horizontal DOP + // v.v : Vertical DOP + // cc : Checksum value + length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", svMeta.talker, fixType); + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);; + return 0; + } + pMarker += length; + lengthRemaining -= length; + + // Add first 12 satellite IDs + for (uint8_t i = 0; i < 12; i++) { + if (i < svUsedCount) { + length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]); + } else { + length = snprintf(pMarker, lengthRemaining, ","); + } + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return 0; + } + pMarker += length; + lengthRemaining -= length; + } + + // Add the position/horizontal/vertical DOP values + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) { + length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", + locationExtended.pdop, + locationExtended.hdop, + locationExtended.vdop); + } else { + length = snprintf(pMarker, lengthRemaining, ",,"); + } + + /* Sentence is ready, add checksum and broadcast */ + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); + + return svUsedCount; +} + +void +GnssAdapter::generateNmeaVTG(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, char* sentence, size_t size) +{ + if (!sentence || size == 0) { + LOC_LOGE("%s]: NMEA Error invalid arguments.", __func__); + return; + } + + char* pMarker = sentence; + int lengthRemaining = size; + int length = 0; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) + { + float magTrack = ulpLocation.gpsLocation.bearing; + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) + { + float magTrack = ulpLocation.gpsLocation.bearing - locationExtended.magneticDeviation; + if (magTrack < 0.0) + magTrack += 360.0; + else if (magTrack > 360.0) + magTrack -= 360.0; + } + + length = snprintf(pMarker, lengthRemaining, "$%sVTG,%.1lf,T,%.1lf,M,", + svMeta.talker, ulpLocation.gpsLocation.bearing, magTrack); + } + else + { + length = snprintf(pMarker, lengthRemaining, "$%sVTG,,T,,M,", svMeta.talker); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) + { + float speedKnots = ulpLocation.gpsLocation.speed * (3600.0/1852.0); + float speedKmPerHour = ulpLocation.gpsLocation.speed * 3.6; + + length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour); + } + else + { + length = snprintf(pMarker, lengthRemaining, ",N,,K,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) + length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix + else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode) + length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous + else + length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential + + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); +} + +void +GnssAdapter::generateNmeaRMC(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, tm& utcTime, + char* sentence, size_t size) +{ + if (!sentence || size == 0) { + LOC_LOGE("NMEA Error invalid arguments."); + return; + } + + int utcYear = utcTime.tm_year % 100; // 2 digit year + int utcMonth = utcTime.tm_mon + 1; // tm_mon starts at zero + int utcDay = utcTime.tm_mday; + int utcHours = utcTime.tm_hour; + int utcMinutes = utcTime.tm_min; + int utcSeconds = utcTime.tm_sec; + int utcMSeconds = (ulpLocation.gpsLocation.timestamp)%1000; + + char* pMarker = sentence; + int lengthRemaining = size; + int length = 0; + + length = snprintf(pMarker, lengthRemaining, "$%sRMC,%02d%02d%02d.%02d,A," , + svMeta.talker, utcHours, utcMinutes, utcSeconds,utcMSeconds/10); + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) { + double latitude = ulpLocation.gpsLocation.latitude; + double longitude = ulpLocation.gpsLocation.longitude; + char latHemisphere; + char lonHemisphere; + double latMinutes; + double lonMinutes; + + if (latitude > 0) { + latHemisphere = 'N'; + } else { + latHemisphere = 'S'; + latitude *= -1.0; + } + + if (longitude < 0) { + lonHemisphere = 'W'; + longitude *= -1.0; + } else { + lonHemisphere = 'E'; + } + + latMinutes = fmod(latitude * 60.0 , 60.0); + lonMinutes = fmod(longitude * 60.0 , 60.0); + + length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", + (uint8_t)floor(latitude), latMinutes, latHemisphere, + (uint8_t)floor(longitude),lonMinutes, lonHemisphere); + } else { + length = snprintf(pMarker, lengthRemaining,",,,,"); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) { + float speedKnots = ulpLocation.gpsLocation.speed * (3600.0/1852.0); + length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots); + } else { + length = snprintf(pMarker, lengthRemaining, ","); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) { + length = snprintf(pMarker, lengthRemaining, "%.1lf,", ulpLocation.gpsLocation.bearing); + } else { + length = snprintf(pMarker, lengthRemaining, ","); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,", + utcDay, utcMonth, utcYear); + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) { + float magneticVariation = locationExtended.magneticDeviation; + char direction; + if (magneticVariation < 0.0) { + direction = 'W'; + magneticVariation *= -1.0; + } else { + direction = 'E'; + } + + length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,", + magneticVariation, direction); + } else { + length = snprintf(pMarker, lengthRemaining, ",,"); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) { + length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix + } else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode) { + length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous + } else { + length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential + } + + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); +} + +void +GnssAdapter::generateNmeaGGA(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, tm& utcTime, uint32_t svUsedCount, + char* sentence, size_t size) +{ + if (!sentence || size == 0) { + LOC_LOGE("NMEA Error invalid arguments."); + return; + } + + int utcYear = utcTime.tm_year % 100; // 2 digit year + int utcMonth = utcTime.tm_mon + 1; // tm_mon starts at zero + int utcDay = utcTime.tm_mday; + int utcHours = utcTime.tm_hour; + int utcMinutes = utcTime.tm_min; + int utcSeconds = utcTime.tm_sec; + int utcMSeconds = (ulpLocation.gpsLocation.timestamp)%1000; + + char* pMarker = sentence; + int lengthRemaining = size; + int length = 0; + + length = snprintf(pMarker, lengthRemaining, "$%sGGA,%02d%02d%02d.%02d," , + svMeta.talker, utcHours, utcMinutes, utcSeconds, utcMSeconds/10); + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) { + double latitude = ulpLocation.gpsLocation.latitude; + double longitude = ulpLocation.gpsLocation.longitude; + char latHemisphere; + char lonHemisphere; + double latMinutes; + double lonMinutes; + + if (latitude > 0) { + latHemisphere = 'N'; + } else { + latHemisphere = 'S'; + latitude *= -1.0; + } + + if (longitude < 0) { + lonHemisphere = 'W'; + longitude *= -1.0; + } else { + lonHemisphere = 'E'; + } + + latMinutes = fmod(latitude * 60.0 , 60.0); + lonMinutes = fmod(longitude * 60.0 , 60.0); + + length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", + (uint8_t)floor(latitude), latMinutes, latHemisphere, + (uint8_t)floor(longitude),lonMinutes, lonHemisphere); + } else { + length = snprintf(pMarker, lengthRemaining,",,,,"); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + char gpsQuality; + if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) { + gpsQuality = '0'; // 0 means no fix + } else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode) { + gpsQuality = '1'; // 1 means GPS fix + } else { + gpsQuality = '2'; // 2 means DGPS fix + } + + // Number of satellites in use, 00-12 + if (svUsedCount > MAX_SATELLITES_IN_USE) { + svUsedCount = MAX_SATELLITES_IN_USE; + } + + // Add the position/horizontal/vertical DOP values + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) { + length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", + gpsQuality, svUsedCount, locationExtended.hdop); + } else { + length = snprintf(pMarker, lengthRemaining, "%c,%02d,,", + gpsQuality, svUsedCount); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL) { + length = snprintf(pMarker, lengthRemaining, "%.1lf,M,", + locationExtended.altitudeMeanSeaLevel); + } else { + length = snprintf(pMarker, lengthRemaining,",,"); + } + + if (length < 0 || length >= lengthRemaining) { + LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__); + return; + } + pMarker += length; + lengthRemaining -= length; + + if ((ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ALTITUDE) && + (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)) { + length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,", + ulpLocation.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel); + } else { + length = snprintf(pMarker, lengthRemaining,",,,"); + } + + length = nmeaPutChecksum(sentence, size); + reportNmeaEvent(sentence, length); +} diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h new file mode 100644 index 00000000..5bd2a12e --- /dev/null +++ b/gnss/GnssAdapter.h @@ -0,0 +1,259 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#ifndef GNSS_ADAPTER_H +#define GNSS_ADAPTER_H + +#include +#include +#include +#include + +#define MAX_URL_LEN 256 +#define NMEA_SENTENCE_MAX_LENGTH 200 +#define GLONASS_SV_ID_OFFSET 64 +#define MAX_SATELLITES_IN_USE 12 +#define LOC_NI_NO_RESPONSE_TIME 20 +#define LOC_GPS_NI_RESPONSE_IGNORE 4 + +class GnssAdapter; + +typedef struct { + pthread_t thread; /* NI thread */ + uint32_t respTimeLeft; /* examine time for NI response */ + bool respRecvd; /* NI User reponse received or not from Java layer*/ + void* rawRequest; + uint32_t reqID; /* ID to check against response */ + GnssNiResponse resp; + pthread_cond_t tCond; + pthread_mutex_t tLock; + GnssAdapter* adapter; +} NiSession; +typedef struct { + NiSession session; /* SUPL NI Session */ + NiSession sessionEs; /* Emergency SUPL NI Session */ + uint32_t reqIDCounter; +} NiData; + +typedef enum { + NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA + NMEA_PROVIDER_MP // Modem Processor Provider of NMEA +} NmeaProviderType; +typedef struct { + GnssSvType svType; + const char* talker; + uint64_t mask; + uint32_t svIdOffset; +} NmeaSvMeta; + +using namespace loc_core; + +class GnssAdapter : public LocAdapterBase { + /* ==== ULP ============================================================================ */ + UlpProxyBase* mUlpProxy; + + /* ==== CLIENT ========================================================================= */ + typedef std::map ClientDataMap; + ClientDataMap mClientData; + + /* ==== TRACKING ======================================================================= */ + LocationSessionMap mTrackingSessions; + GnssSuplMode mSuplMode; + LocPosMode mUlpPositionMode; + GnssSvUsedInPosition mGnssSvIdUsedInPosition; + bool mGnssSvIdUsedInPosAvail; + + /* ==== CONTROL ======================================================================== */ + LocationControlCallbacks mControlCallbacks; + uint32_t mPowerVoteId; + + /* ==== NI ============================================================================= */ + NiData mNiData; + + /*==== CONVERSION ===================================================================*/ + static void convertOptions(LocPosMode& out, const LocationOptions& options); + static void convertLocation(Location& out, const LocGpsLocation& locGpsLocation, + const LocPosTechMask techMask); + static void convertLocationInfo(GnssLocationInfoNotification& out, + const GpsLocationExtended& locationExtended); + +public: + + GnssAdapter(); + virtual ~GnssAdapter(); + + /* ==== SSR ============================================================================ */ + /* ======== EVENTS ====(Called from QMI Thread)========================================= */ + virtual void handleEngineUpEvent(); + /* ======== UTILITIES ================================================================== */ + void restartSessions(); + + /* ==== ULP ============================================================================ */ + /* ======== COMMANDS ====(Called from ULP Thread)==================================== */ + virtual void setUlpProxyCommand(UlpProxyBase* ulp); + /* ======== UTILITIES ================================================================== */ + void setUlpProxy(UlpProxyBase* ulp); + inline UlpProxyBase* getUlpProxy() { return mUlpProxy; } + + /* ==== CLIENT ========================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + void addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks); + void removeClientCommand(LocationAPI* client); + void requestCapabilitiesCommand(LocationAPI* client); + /* ======== UTILITIES ================================================================== */ + void saveClient(LocationAPI* client, const LocationCallbacks& callbacks); + void eraseClient(LocationAPI* client); + void updateClientsEventMask(); + void stopClientSessions(LocationAPI* client); + LocationCallbacks getClientCallbacks(LocationAPI* client); + + /* ==== TRACKING ======================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + uint32_t startTrackingCommand(LocationAPI* client, LocationOptions& options); + void updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, LocationOptions& options); + void stopTrackingCommand(LocationAPI* client, uint32_t id); + /* ======================(Called from ULP Thread)======================================= */ + virtual void setPositionModeCommand(LocPosMode& locPosMode); + virtual void startTrackingCommand(); + virtual void stopTrackingCommand(); + virtual void getZppCommand(); + /* ======== RESPONSES ================================================================== */ + void reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId); + /* ======== UTILITIES ================================================================== */ + bool hasTrackingCallback(LocationAPI* client); + bool hasMeasurementsCallback(LocationAPI* client); + bool isTrackingSession(LocationAPI* client, uint32_t sessionId); + void saveTrackingSession(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options); + void eraseTrackingSession(LocationAPI* client, uint32_t sessionId); + void setUlpPositionMode(const LocPosMode& mode) { mUlpPositionMode = mode; } + LocPosMode& getUlpPositionMode() { return mUlpPositionMode; } + void setSuplMode(GnssSuplMode mode) { mSuplMode = mode; } + LocationError startTrackingMultiplex(const LocationOptions& options); + LocationError startTracking(const LocationOptions& options); + LocationError stopTrackingMultiplex(LocationAPI* client, uint32_t id); + LocationError stopTracking(); + + /* ==== NI ============================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + void gnssNiResponseCommand(LocationAPI* client, uint32_t id, GnssNiResponse response); + /* ======================(Called from NI Thread)======================================== */ + void gnssNiResponseCommand(GnssNiResponse response, void* rawRequest); + /* ======== UTILITIES ================================================================== */ + bool hasNiNotifyCallback(LocationAPI* client); + NiData& getNiData() { return mNiData; } + + /* ==== CONTROL ======================================================================== */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + uint32_t enableCommand(LocationTechnologyType techType); + void disableCommand(uint32_t id); + void setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks); + void readConfigCommand(); + void setConfigCommand(); + uint32_t* gnssUpdateConfigCommand(GnssConfig config); + uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data); + /* ======== RESPONSES ================================================================== */ + void reportResponse(LocationError err, uint32_t sessionId); + void reportResponse(size_t count, LocationError* errs, uint32_t* ids); + /* ======== UTILITIES ================================================================== */ + LocationControlCallbacks& getControlCallbacks() { return mControlCallbacks; } + void setControlCallbacks(const LocationControlCallbacks& controlCallbacks) + { mControlCallbacks = controlCallbacks; } + void setPowerVoteId(uint32_t id) { mPowerVoteId = id; } + uint32_t getPowerVoteId() { return mPowerVoteId; } + bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress); + + /* ==== REPORTS ======================================================================== */ + /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */ + virtual void reportPositionEvent(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask, + bool fromUlp=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); + virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data); + virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify); + virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); + virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); + /* ======== UTILITIES ================================================================= */ + void reportPosition(const UlpLocation &ulpLocation, + const GpsLocationExtended &locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask); + void reportSv(GnssSvNotification& svNotify); + void reportNmea(const char* nmea, size_t length); + bool requestNiNotify(const GnssNiNotification& notify, const void* data); + void reportGnssMeasurementData(const GnssMeasurementsNotification& measurementsNotify); + + /*==== NMEA Generation =============================================================== */ + /*======== SVS ======================================================================= */ + void generateNmea(const GnssSvNotification& svNotify); + void generateNmeaGSV(const GnssSvNotification& svNotify, + NmeaSvMeta& svMeta, char* sentence, size_t size); + /*======== POSITION ================================================================== */ + void generateNmea(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended); + void generateNmeaBlank(); + uint8_t generateNmeaGSA(const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, char* sentence, size_t size); + void generateNmeaVTG(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, char* sentence, size_t size); + void generateNmeaRMC(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, tm& utcTime, char* sentence, size_t size); + void generateNmeaGGA(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + NmeaSvMeta& svMeta, tm& utcTime, uint32_t svUsedCount, + char* sentence, size_t size); + /*======== UTILITIES ================================================================*/ + int nmeaPutChecksum(char *nmea, size_t maxSize); + + /*==== CONVERSION ===================================================================*/ + static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock); + static GnssConfigGpsLock convertGpsLock(const uint32_t gpsLock); + static uint32_t convertSuplVersion(const GnssConfigSuplVersion suplVersion); + static GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion); + static uint32_t convertLppProfile(const GnssConfigLppProfile lppProfile); + static GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile); + static uint32_t convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl); + static uint32_t convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices); + static uint32_t convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask); + static GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask); + static uint32_t convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask); + static GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask); + static uint32_t convertAGloProt(const GnssConfigAGlonassPositionProtocolMask); + static uint32_t convertSuplMode(const GnssConfigSuplModeMask suplModeMask); + + void injectLocationCommand(double latitude, double longitude, float accuracy); + void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty); + +}; + +#endif //GNSS_ADAPTER_H diff --git a/gnss/location_gnss.cpp b/gnss/location_gnss.cpp new file mode 100644 index 00000000..242e72e6 --- /dev/null +++ b/gnss/location_gnss.cpp @@ -0,0 +1,206 @@ +/* Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation, nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "GnssAdapter.h" +#include "location_interface.h" + +static GnssAdapter* gGnssAdapter = NULL; + +static void initialize(); +static void deinitialize(); + +static void addClient(LocationAPI* client, const LocationCallbacks& callbacks); +static void removeClient(LocationAPI* client); +static void requestCapabilities(LocationAPI* client); + +static uint32_t startTracking(LocationAPI* client, LocationOptions& options); +static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options); +static void stopTracking(LocationAPI* client, uint32_t id); + +static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response); +static uint32_t gnssDeleteAidingData(GnssAidingData& data); + +static void setControlCallbacks(LocationControlCallbacks& controlCallbacks); +static uint32_t enable(LocationTechnologyType techType); +static void disable(uint32_t id); +static uint32_t* gnssUpdateConfig(GnssConfig config); + +static void injectLocation(double latitude, double longitude, float accuracy); +static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty); + +static const GnssInterface gGnssInterface = { + sizeof(GnssInterface), + initialize, + deinitialize, + addClient, + removeClient, + requestCapabilities, + startTracking, + updateTrackingOptions, + stopTracking, + gnssNiResponse, + setControlCallbacks, + enable, + disable, + gnssUpdateConfig, + gnssDeleteAidingData, + injectLocation, + injectTime +}; + +#ifndef DEBUG_X86 +extern "C" const GnssInterface* getGnssInterface() +#else +const GnssInterface* getGnssInterface() +#endif // DEBUG_X86 +{ + return &gGnssInterface; +} + +static void initialize() +{ + if (NULL == gGnssAdapter) { + gGnssAdapter = new GnssAdapter(); + } +} + +static void deinitialize() +{ + if (NULL != gGnssAdapter) { + delete gGnssAdapter; + gGnssAdapter = NULL; + } +} + +static void addClient(LocationAPI* client, const LocationCallbacks& callbacks) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->addClientCommand(client, callbacks); + } +} + +static void removeClient(LocationAPI* client) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->removeClientCommand(client); + } +} + +static void requestCapabilities(LocationAPI* client) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->requestCapabilitiesCommand(client); + } +} + +static uint32_t startTracking(LocationAPI* client, LocationOptions& options) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->startTrackingCommand(client, options); + } else { + return 0; + } +} + +static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->updateTrackingOptionsCommand(client, id, options); + } +} + +static void stopTracking(LocationAPI* client, uint32_t id) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->stopTrackingCommand(client, id); + } +} + +static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->gnssNiResponseCommand(client, id, response); + } +} + +static void setControlCallbacks(LocationControlCallbacks& controlCallbacks) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->setControlCallbacksCommand(controlCallbacks); + } +} + +static uint32_t enable(LocationTechnologyType techType) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->enableCommand(techType); + } else { + return 0; + } +} + +static void disable(uint32_t id) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->disableCommand(id); + } +} + +static uint32_t* gnssUpdateConfig(GnssConfig config) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->gnssUpdateConfigCommand(config); + } else { + return NULL; + } +} + +static uint32_t gnssDeleteAidingData(GnssAidingData& data) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->gnssDeleteAidingDataCommand(data); + } else { + return NULL; + } +} + +static void injectLocation(double latitude, double longitude, float accuracy) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->injectLocationCommand(latitude, longitude, accuracy); + } +} + +static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->injectTimeCommand(time, timeReference, uncertainty); + } +} + diff --git a/loc_api/Android.mk b/loc_api/Android.mk deleted file mode 100644 index 743b3860..00000000 --- a/loc_api/Android.mk +++ /dev/null @@ -1,17 +0,0 @@ -ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) - -LOCAL_PATH := $(call my-dir) - -# add RPC dirs if RPC is available -ifneq ($(TARGET_NO_RPC),true) - -GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api-rpc-50001/ - -endif #TARGET_NO_RPC - -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 diff --git a/loc_api/Makefile.am b/loc_api/Makefile.am deleted file mode 100644 index 23ccc35e..00000000 --- a/loc_api/Makefile.am +++ /dev/null @@ -1,120 +0,0 @@ -AM_CFLAGS = \ - -I./ \ - -I../core \ - -I./libloc_api_50001 \ - -I../utils \ - $(LOCPLA_CFLAGS) \ - -fno-short-enums \ - -D__func__=__PRETTY_FUNCTION__ \ - -DTARGET_USES_QCOM_BSP \ - -std=c++11 - -AM_CPPFLAGS = \ - -std=c++11 - -libloc_eng_so_la_h_sources = \ - loc_eng_dmn_conn_glue_msg.h \ - loc_eng_dmn_conn_glue_pipe.h \ - loc_eng_dmn_conn.h \ - loc_eng_dmn_conn_handler.h \ - loc_eng_dmn_conn_thread_helper.h - -libloc_eng_so_la_SOURCES = \ - libloc_api_50001/loc.cpp \ - libloc_api_50001/loc_eng.cpp \ - libloc_api_50001/loc_eng_agps.cpp \ - libloc_api_50001/loc_eng_xtra.cpp \ - libloc_api_50001/loc_eng_ni.cpp \ - libloc_api_50001/loc_eng_log.cpp \ - libloc_api_50001/loc_eng_nmea.cpp \ - libloc_api_50001/LocEngAdapter.cpp \ - libloc_api_50001/loc_eng_dmn_conn.cpp \ - libloc_api_50001/loc_eng_dmn_conn_handler.cpp \ - libloc_api_50001/loc_eng_dmn_conn_thread_helper.c \ - libloc_api_50001/loc_eng_dmn_conn_glue_msg.c \ - libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c - -libloc_eng_so_la_SOURCES += libloc_eng_so_la_h_sources - -if USE_GLIB -libloc_eng_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ -libloc_eng_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_eng_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_eng_so_la_CFLAGS = $(AM_CFLAGS) -libloc_eng_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 -libloc_eng_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) -endif - -libloc_eng_so_la_LIBADD = -lstdc++ -ldl -llog $(LOCPLA_LIBS) ../utils/libgps_utils_so.la ../core/libloc_core.la - -libloc_ds_api_CFLAGS = \ - $(QMIF_CFLAGS) \ - $(QMI_CFLAGS) \ - $(DATA_CFLAGS) \ - -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api - -libloc_ds_api_la_SOURCES = \ - $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c - -if USE_GLIB -libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@ -libloc_ds_api_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic -libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) -libloc_ds_api_la_LDFLAGS = -lstdc++ -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0 -libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic -libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS) -endif - -libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(LOCPLA_LIBS) ../utils/libgps_utils_so.la -#libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices $(LOCPLA_LIBS) ../utils/libgps_utils_so.la - -libloc_api_v02_CFLAGS = \ - $(QMIF_CFLAGS) \ - -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \ - -I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02 - -libloc_api_v02_la_SOURCES = \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c - -if USE_GLIB -libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@ -libloc_api_v02_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) -libloc_api_v02_la_LDFLAGS = -lstdc++ -lpthread -shared -version-info 1:0:0 -libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS) -endif - -libloc_api_v02_la_CXXFLAGS = -std=c++0x -libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la ../utils/libgps_utils_so.la libloc_ds_api.la - -library_include_HEADERS = \ - libloc_api_50001/LocEngAdapter.h \ - libloc_api_50001/loc.h \ - libloc_api_50001/loc_eng.h \ - libloc_api_50001/loc_eng_xtra.h \ - libloc_api_50001/loc_eng_ni.h \ - libloc_api_50001/loc_eng_agps.h \ - libloc_api_50001/loc_eng_msg.h \ - libloc_api_50001/loc_eng_log.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \ - $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h - -library_includedir = $(pkgincludedir) - -#Create and Install libraries -lib_LTLIBRARIES = libloc_eng_so.la libloc_ds_api.la libloc_api_v02.la diff --git a/loc_api/libloc_api-rpc-50001/Android.mk b/loc_api/libloc_api-rpc-50001/Android.mk deleted file mode 100644 index 6c5d5339..00000000 --- a/loc_api/libloc_api-rpc-50001/Android.mk +++ /dev/null @@ -1,3 +0,0 @@ -ifeq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001) -include $(call all-subdir-makefiles) -endif diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk deleted file mode 100644 index bb3d924b..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk +++ /dev/null @@ -1,60 +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/LocApiRpc.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_core - -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)/libloc_core \ - $(TARGET_OUT_HEADERS)/loc_api/rpcgen/inc \ - $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc \ - $(TARGET_OUT_HEADERS)/librpc \ - $(TARGET_OUT_HEADERS)/libloc-rpc/rpc_inc \ - $(TOP)/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 \ - $(RPC_INC)/LocApiRpc.h - -LOCAL_MODULE:= libloc_api-rpc-qc -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -include $(BUILD_SHARED_LIBRARY) diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am deleted file mode 100644 index f5c51369..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am +++ /dev/null @@ -1,46 +0,0 @@ -AM_CFLAGS = \ - -I../../../utils \ - -I../../../platform_lib_abstractions \ - -I./rpc_inc \ - -I../libloc_api-rpc-stub/inc \ - -I../../libloc_api_50001 \ - $(MSM7K_CFLAGS) \ - -DUSE_QCOM_AUTO_RPC - -requiredlibs = \ - ../../../utils/libgps_utils_so.la \ - $(MSM7K_LIBS) - -h_sources = \ - 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 \ - -c_sources = \ - 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 \ - - -library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc -library_include_HEADERS = $(h_sources) -libloc_api_rpc_qc_la_SOURCES = $(c_sources) $(h_sources) - -if USE_GLIB -libloc_api_rpc_qc_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ -libloc_api_rpc_qc_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_api_rpc_qc_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_api_rpc_qc_la_CFLAGS = $(AM_CFLAGS) -libloc_api_rpc_qc_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 -libloc_api_rpc_qc_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) -endif - -libloc_api_rpc_qc_la_LIBADD = $(requiredlibs) -lstdc++ - -#Create and Install Libraries -lib_LTLIBRARIES = libloc_api_rpc_qc.la diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h deleted file mode 100644 index b2b4e2ab..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h +++ /dev/null @@ -1,142 +0,0 @@ -/* Copyright (c) 2011,2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_API_RPC_H -#define LOC_API_RPC_H - -#include -#include -#include -#include -#include - -using namespace loc_core; - -class LocApiRpc : public LocApiBase { -protected: - // RPC communication establishment - rpc_loc_client_handle_type client_handle; - -private: - int dataEnableLastSet; - char apnLastSet[MAX_APN_LEN]; - - static const LOC_API_ADAPTER_EVENT_MASK_T maskAll; - static const rpc_loc_event_mask_type locBits[]; - static rpc_loc_event_mask_type convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask); - static rpc_loc_lock_e_type convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask); - static enum loc_api_adapter_err convertErr(int rpcErr); - static LocGpsNiEncodingType convertNiEncodingType(int loc_encoding); - static int NIEventFillVerfiyType(LocGpsNiNotification ¬if, - rpc_loc_ni_notify_verify_e_type notif_priv); - - 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); - -protected: - virtual enum loc_api_adapter_err - open(LOC_API_ADAPTER_EVENT_MASK_T mask); - virtual enum loc_api_adapter_err - close(); - LocApiRpc(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask); - -public: - static LocApiRpc* createLocApiRpc(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask); - ~LocApiRpc(); - - virtual 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 - startFix(const LocPosMode& posMode); - virtual enum loc_api_adapter_err - stopFix(); - virtual enum loc_api_adapter_err - setPositionMode(const LocPosMode& mode); - inline virtual enum loc_api_adapter_err - enableData(int enable) { return enableData(enable, false); } - virtual enum loc_api_adapter_err - enableData(int enable, boolean force); - virtual enum loc_api_adapter_err - setTime(LocGpsUtcTime 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(LocGpsAidingData f); - virtual enum loc_api_adapter_err - informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData); - inline virtual enum loc_api_adapter_err - setAPN(char* apn, int len) { return setAPN(apn, len, false); } - virtual enum loc_api_adapter_err - setAPN(char* apn, int len, boolean force); - 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 - requestXtraServer(); - virtual enum loc_api_adapter_err - atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, LocAGpsType agpsType); - virtual enum loc_api_adapter_err - atlCloseStatus(int handle, int is_succ); - virtual enum loc_api_adapter_err - setSUPLVersion(uint32_t version); - virtual void setInSession(bool inSession); - - /*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions - */ - virtual int setGpsLock(LOC_GPS_LOCK_MASK lock); - /* - Returns - Current value of GPS Lock on success - -1 on failure - */ - virtual int getGpsLock(void); -}; - -extern "C" LocApiBase* getLocApi(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, - ContextBase *context); - -#endif //LOC_API_RPC_H diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h deleted file mode 100644 index 49a6d0be..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h +++ /dev/null @@ -1,69 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef DEBUG_H -#define DEBUG_H - -#include - -#define LOG_TAG "LocSvc_rpc" -#include - -#define PRINT(x...) do { \ - fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \ - fprintf(stdout, ##x); \ - ALOGD(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); \ - ALOGE(x); \ - } while(0) - -#define FAILIF(cond, msg...) do { \ - if (__builtin_expect (cond, 0)) { \ - fprintf(stderr, "%s:%s:(%d): ", __FILE__, __FUNCTION__, __LINE__); \ - fprintf(stderr, ##msg); \ - ALOGE(##msg); \ - } \ - } while(0) - -#endif/*DEBUG_H*/ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h deleted file mode 100644 index c483b4a1..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h +++ /dev/null @@ -1,226 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LOC_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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h deleted file mode 100644 index f0374280..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h +++ /dev/null @@ -1,59 +0,0 @@ -/* Copyright (c) 2011 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef LOC_API_LOG_H -#define LOC_API_LOG_H - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include -#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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h deleted file mode 100644 index 6df33ae1..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h +++ /dev/null @@ -1,123 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LOC_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 "loc_api_fixup.h" -#include "loc_api_sync_call.h" -#include - -#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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h deleted file mode 100644 index 43208bda..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h +++ /dev/null @@ -1,90 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LOC_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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h deleted file mode 100644 index ba41d08b..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h +++ /dev/null @@ -1,45 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LOC_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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp deleted file mode 100644 index f0f84b50..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp +++ /dev/null @@ -1,1475 +0,0 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_api_rpc" - -#include -#include -#ifndef USE_GLIB -#include -#endif /* USE_GLIB */ -#include -#include -#include -#include -#include -#include -#ifdef USE_GLIB -#include -#endif -#include -#include - -using namespace loc_core; - -#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100) -#define XTRA_BLOCK_SIZE (3072) -#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds -#define LOC_NI_NOTIF_KEY_ADDRESS "Address" - -/*=========================================================================== -FUNCTION loc_event_cb - -DESCRIPTION - This is the callback function registered by loc_open. - -DEPENDENCIES - N/A - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int32 loc_event_cb -( - void* user, - rpc_loc_client_handle_type client_handle, - rpc_loc_event_mask_type loc_event, - const rpc_loc_event_payload_u_type* loc_event_payload -) -{ - MODEM_LOG_CALLFLOW(%s, loc_get_event_name(loc_event)); - loc_callback_log(loc_event, loc_event_payload); - int32 ret_val = ((LocApiRpc*)user)->locEventCB(client_handle, loc_event, loc_event_payload); - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_rpc_global_cb - -DESCRIPTION - This is the callback function registered by loc_open for RPC global events - -DEPENDENCIES - N/A - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_rpc_global_cb(void* user, CLIENT* clnt, enum rpc_reset_event event) -{ - MODEM_LOG_CALLFLOW(%s, loc_get_rpc_reset_event_name(event)); - ((LocApiRpc*)user)->locRpcGlobalCB(clnt, event); - EXIT_LOG(%p, VOID_RET); -} - -const LOC_API_ADAPTER_EVENT_MASK_T LocApiRpc::maskAll = - 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; - -const rpc_loc_event_mask_type LocApiRpc::locBits[] = -{ - RPC_LOC_EVENT_PARSED_POSITION_REPORT, - RPC_LOC_EVENT_SATELLITE_REPORT, - RPC_LOC_EVENT_NMEA_1HZ_REPORT, - RPC_LOC_EVENT_NMEA_POSITION_REPORT, - RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST, - RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST, - RPC_LOC_EVENT_LOCATION_SERVER_REQUEST, - RPC_LOC_EVENT_IOCTL_REPORT, - RPC_LOC_EVENT_STATUS_REPORT, - RPC_LOC_EVENT_WPS_NEEDED_REQUEST -}; - -LocApiRpc* -LocApiRpc::createLocApiRpc(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, - ContextBase* context) -{ - if (NULL == msgTask) { - return NULL; - } - return new LocApiRpc(msgTask, exMask, context); -} - -// constructor -LocApiRpc::LocApiRpc(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, - ContextBase* context) : - LocApiBase(msgTask, exMask, context), - client_handle(RPC_LOC_CLIENT_HANDLE_INVALID), - dataEnableLastSet(-1) -{ - memset(apnLastSet, 0, sizeof(apnLastSet)); - loc_api_glue_init(); -} - -LocApiRpc::~LocApiRpc() -{ - close(); -} - -rpc_loc_event_mask_type -LocApiRpc::convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask) -{ - rpc_loc_event_mask_type newMask = 0; - - for (unsigned int i = 0, bit=1; 0 != mask; i++, bit<<=1) { - if (mask & bit) { - newMask |= locBits[i]; - mask ^= bit; - } - } - - return newMask; -} - -rpc_loc_lock_e_type -LocApiRpc::convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask) -{ - if (isGpsLockAll(lockMask)) - return RPC_LOC_LOCK_ALL; - if (isGpsLockMO(lockMask)) - return RPC_LOC_LOCK_MI; - if (isGpsLockMT(lockMask)) - return RPC_LOC_LOCK_MT; - if (isGpsLockNone(lockMask)) - return RPC_LOC_LOCK_NONE; - return (rpc_loc_lock_e_type)lockMask; -} - -enum loc_api_adapter_err -LocApiRpc::convertErr(int rpcErr) -{ - switch(rpcErr) - { - case RPC_LOC_API_SUCCESS: - return LOC_API_ADAPTER_ERR_SUCCESS; - case RPC_LOC_API_GENERAL_FAILURE: - return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; - case RPC_LOC_API_UNSUPPORTED: - return LOC_API_ADAPTER_ERR_UNSUPPORTED; - case RPC_LOC_API_INVALID_HANDLE: - return LOC_API_ADAPTER_ERR_INVALID_HANDLE; - case RPC_LOC_API_INVALID_PARAMETER: - return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; - case RPC_LOC_API_ENGINE_BUSY: - return LOC_API_ADAPTER_ERR_ENGINE_BUSY; - case RPC_LOC_API_PHONE_OFFLINE: - return LOC_API_ADAPTER_ERR_PHONE_OFFLINE; - case RPC_LOC_API_TIMEOUT: - return LOC_API_ADAPTER_ERR_TIMEOUT; - case RPC_LOC_API_RPC_MODEM_RESTART: - return LOC_API_ADAPTER_ERR_ENGINE_DOWN; - case RPC_LOC_API_RPC_FAILURE: - return LOC_API_ADAPTER_ERR_FAILURE; - default: - return LOC_API_ADAPTER_ERR_UNKNOWN; - } -} - -void LocApiRpc::locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event) -{ - static rpc_loc_engine_state_e_type last_state = RPC_LOC_ENGINE_STATE_MAX; - - switch (event) { - case RPC_SUBSYSTEM_RESTART_BEGIN: - if (RPC_LOC_ENGINE_STATE_OFF != last_state) { - last_state = RPC_LOC_ENGINE_STATE_OFF; - handleEngineDownEvent(); - } - break; - case RPC_SUBSYSTEM_RESTART_END: - if (RPC_LOC_ENGINE_STATE_ON != last_state) { - last_state = RPC_LOC_ENGINE_STATE_ON; - handleEngineUpEvent(); - } - break; - } -} - -int32 LocApiRpc::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) -{ - // Parsed report - if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT) - { - reportPosition(&loc_event_payload->rpc_loc_event_payload_u_type_u. - parsed_location_report); - } - - // Satellite report - if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT) - { - reportSv(&loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report); - } - - // Status report - if (loc_event & RPC_LOC_EVENT_STATUS_REPORT) - { - reportStatus(&loc_event_payload->rpc_loc_event_payload_u_type_u.status_report); - } - - // NMEA - if (loc_event & RPC_LOC_EVENT_NMEA_1HZ_REPORT) - { - reportNmea(&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report)); - } - // XTRA support: supports only XTRA download - if (loc_event & RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST) - { - if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event == - RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ) - { - requestXtraData(); - } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event == - RPC_LOC_ASSIST_DATA_TIME_REQ) - { - requestTime(); - } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event == - RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ) - { - requestLocation(); - } - } - - // AGPS data request - if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST) - { - ATLEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u. - loc_server_request); - } - - // NI notify request - if (loc_event & RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST) - { - NIEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request); - } - - return RPC_LOC_API_SUCCESS;//We simply want to return sucess here as we do not want to - // cause any issues in RPC thread context -} - -enum loc_api_adapter_err -LocApiRpc::open(LOC_API_ADAPTER_EVENT_MASK_T mask) -{ - enum loc_api_adapter_err ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - - // RPC does not dynamically update the event mask. And in the - // case of RPC, all we support are positioning (gps + agps) - // masks anyways, so we simply mask all of them on always. - // After doing so the first time in a power cycle, we know there - // will the following if condition will never be true any more. - mask = maskAll; - - if (mask != mMask) { - if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) { - close(); - } - - mMask = mask; - // it is important to cap the mask here, because not all LocApi's - // can enable the same bits, e.g. foreground and bckground. - client_handle = loc_open(convertMask(mask), - loc_event_cb, - loc_rpc_global_cb, this); - - if (client_handle < 0) { - mMask = 0; - client_handle = RPC_LOC_CLIENT_HANDLE_INVALID; - ret_val = LOC_API_ADAPTER_ERR_INVALID_HANDLE; - } - } - - return ret_val; -} - -enum loc_api_adapter_err -LocApiRpc::close() -{ - if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) { - loc_clear(client_handle); - } - - loc_close(client_handle); - mMask = 0; - client_handle = RPC_LOC_CLIENT_HANDLE_INVALID; - - return LOC_API_ADAPTER_ERR_SUCCESS; -} - -enum loc_api_adapter_err -LocApiRpc::startFix(const LocPosMode& posMode) { - LOC_LOGD("LocApiRpc::startFix() called"); - return convertErr( - loc_start_fix(client_handle) - ); -} - -enum loc_api_adapter_err -LocApiRpc::stopFix() { - LOC_LOGD("LocApiRpc::stopFix() called"); - return convertErr( - loc_stop_fix(client_handle) - ); -} - -enum loc_api_adapter_err -LocApiRpc::setPositionMode(const LocPosMode& posMode) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_fix_criteria_s_type *fix_criteria_ptr = - &ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria; - rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_SET_FIX_CRITERIA; - rpc_loc_operation_mode_e_type op_mode; - int ret_val; - const LocPosMode* fixCriteria = &posMode; - - ALOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n", - (int32) client_handle, fixCriteria->min_interval, fixCriteria->mode); - - switch (fixCriteria->mode) - { - case LOC_POSITION_MODE_MS_BASED: - op_mode = RPC_LOC_OPER_MODE_MSB; - break; - case LOC_POSITION_MODE_MS_ASSISTED: - op_mode = RPC_LOC_OPER_MODE_MSA; - break; - case LOC_POSITION_MODE_RESERVED_1: - op_mode = RPC_LOC_OPER_MODE_SPEED_OPTIMAL; - break; - case LOC_POSITION_MODE_RESERVED_2: - op_mode = RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL; - break; - case LOC_POSITION_MODE_RESERVED_3: - op_mode = RPC_LOC_OPER_MODE_DATA_OPTIMAL; - break; - case LOC_POSITION_MODE_RESERVED_4: - case LOC_POSITION_MODE_RESERVED_5: - op_mode = RPC_LOC_OPER_MODE_MSA; - fix_criteria_ptr->preferred_response_time = 0; - break; - default: - op_mode = RPC_LOC_OPER_MODE_STANDALONE; - } - - fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE | - RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE; - fix_criteria_ptr->min_interval = fixCriteria->min_interval; - fix_criteria_ptr->preferred_operation_mode = op_mode; - - fix_criteria_ptr->min_interval = fixCriteria->min_interval; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL; - - if (fixCriteria->preferred_accuracy > 0) { - fix_criteria_ptr->preferred_accuracy = fixCriteria->preferred_accuracy; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY; - } - if (fixCriteria->preferred_time > 0) { - fix_criteria_ptr->preferred_response_time = fixCriteria->preferred_time; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME; - } - - switch (fixCriteria->recurrence) { - case LOC_GPS_POSITION_RECURRENCE_SINGLE: - fix_criteria_ptr->recurrence_type = RPC_LOC_SINGLE_FIX; - break; - case LOC_GPS_POSITION_RECURRENCE_PERIODIC: - default: - fix_criteria_ptr->recurrence_type = RPC_LOC_PERIODIC_FIX; - break; - } - ioctl_data.disc = ioctl_type; - - ret_val = loc_eng_ioctl (client_handle, - ioctl_type, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - return convertErr(ret_val); -} - -enum loc_api_adapter_err -LocApiRpc::setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_assist_data_time_s_type *time_info_ptr; - rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_UTC_TIME; - int ret_val; - - LOC_LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty); - - time_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_time; - time_info_ptr->time_utc = time; - time_info_ptr->time_utc += (int64_t)(ELAPSED_MILLIS_SINCE_BOOT_PLATFORM_LIB_ABSTRACTION - timeReference); - time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms - - ioctl_data.disc = ioctl_type; - - ret_val = loc_eng_ioctl (client_handle, - ioctl_type, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - return convertErr(ret_val); -} - -enum loc_api_adapter_err -LocApiRpc::injectPosition(double latitude, double longitude, float accuracy) -{ - /* IOCTL data */ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_assist_data_pos_s_type *assistance_data_position = - &ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_position; - int ret_val; - - /************************************************ - * Fill in latitude, longitude & accuracy - ************************************************/ - - /* This combo is required */ - assistance_data_position->valid_mask = - RPC_LOC_ASSIST_POS_VALID_LATITUDE | - RPC_LOC_ASSIST_POS_VALID_LONGITUDE | - RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR | - RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL; - - assistance_data_position->latitude = latitude; - assistance_data_position->longitude = longitude; - assistance_data_position->hor_unc_circular = accuracy; /* Meters assumed */ - assistance_data_position->confidence_horizontal = 63; /* 63% (1 std dev) assumed */ - - /* Log */ - LOC_LOGD("Inject coarse position Lat=%lf, Lon=%lf, Acc=%.2lf\n", - (double) assistance_data_position->latitude, - (double) assistance_data_position->longitude, - (double) assistance_data_position->hor_unc_circular); - - ret_val = loc_eng_ioctl( client_handle, - RPC_LOC_IOCTL_INJECT_POSITION, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - return convertErr(ret_val); -} - -enum loc_api_adapter_err -LocApiRpc::informNiResponse(LocGpsUserResponseType userResponse, - const void* passThroughData) -{ - 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, - passThroughData, sizeof (rpc_loc_ni_event_s_type)); - - rpc_loc_ni_user_resp_e_type resp; - switch (userResponse) - { - case LOC_GPS_NI_RESPONSE_ACCEPT: - data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = - RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT; - break; - case LOC_GPS_NI_RESPONSE_DENY: - data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = - RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY; - break; - case LOC_GPS_NI_RESPONSE_NORESP: - default: - data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = - RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP; - break; - } - - return convertErr( - loc_eng_ioctl(client_handle, - RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE, - &data, - LOC_IOCTL_DEFAULT_TIMEOUT, - &callback_payload) - ); -} - -enum loc_api_adapter_err -LocApiRpc::setAPN(char* apn, int len, boolean force) -{ - enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS; - int size = sizeof(apnLastSet); - if (force || memcmp(apnLastSet, apn, size)) { - if (len < size) { - // size will be not larger than its original value - size = len + 1; - } - memcpy(apnLastSet, apn, size); - - if (!isInSession()) { - rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_LBS_APN_PROFILE, {0}}; - ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].srv_system_type = LOC_APN_PROFILE_SRV_SYS_MAX; - ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].pdp_type = LOC_APN_PROFILE_PDN_TYPE_IPV4; - memcpy(&(ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].apn_name), apn, size); - - rtv = convertErr( - loc_eng_ioctl (client_handle, - RPC_LOC_IOCTL_SET_LBS_APN_PROFILE, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); - } - } - return rtv; -} - -void LocApiRpc::setInSession(bool inSession) -{ - if (!inSession) { - enableData(dataEnableLastSet, true); - setAPN(apnLastSet, sizeof(apnLastSet)-1, true); - } -} - -enum loc_api_adapter_err -LocApiRpc::setServer(const char* url, int len) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_server_info_s_type *server_info_ptr; - rpc_loc_ioctl_e_type ioctl_cmd; - - ioctl_cmd = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR; - ioctl_data.disc = ioctl_cmd; - server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr; - server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL; - server_info_ptr->addr_info.disc = server_info_ptr->addr_type; - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = len; -#if (AMSS_VERSION==3200) - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = (char*) url; - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len= len; -#else - strlcpy(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr, url, - sizeof server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr); -#endif /* #if (AMSS_VERSION==3200) */ - LOC_LOGD ("loc_eng_set_server, addr = %s\n", url); - - return convertErr( - loc_eng_ioctl (client_handle, - ioctl_cmd, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/) - ); -} - -enum loc_api_adapter_err -LocApiRpc::setServer(unsigned int ip, int port, LocServerType type) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_server_info_s_type *server_info_ptr; - rpc_loc_ioctl_e_type ioctl_cmd; - - switch (type) { - case LOC_AGPS_MPC_SERVER: - ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR; - break; - case LOC_AGPS_CUSTOM_PDE_SERVER: - ioctl_cmd = RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR; - break; - default: - ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR; - break; - } - ioctl_data.disc = ioctl_cmd; - server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr; - server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_IPV4; - server_info_ptr->addr_info.disc = server_info_ptr->addr_type; - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.addr = ip; - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.port = port; - LOC_LOGD ("setServer, addr = %X:%d\n", (unsigned int) ip, (unsigned int) port); - - return convertErr( - loc_eng_ioctl (client_handle, - ioctl_cmd, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/) - ); -} - -enum loc_api_adapter_err -LocApiRpc::enableData(int enable, boolean force) -{ - enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS; - if (force || dataEnableLastSet != enable) { - dataEnableLastSet = enable; - - if (!isInSession()) { - rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_DATA_ENABLE, {0}}; - - ioctl_data.rpc_loc_ioctl_data_u_type_u.data_enable = enable; - rtv = convertErr( - loc_eng_ioctl (client_handle, - RPC_LOC_IOCTL_SET_DATA_ENABLE, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); - } - } - return rtv; -} - -enum loc_api_adapter_err -LocApiRpc::deleteAidingData(LocGpsAidingData bits) -{ - rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_DELETE_ASSIST_DATA, {0}}; - ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete.type = bits; - - return convertErr( - loc_eng_ioctl (client_handle, - RPC_LOC_IOCTL_DELETE_ASSIST_DATA, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); -} - -void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr) -{ - LocPosTechMask tech_Mask = LOC_POS_TECH_MASK_DEFAULT; - - UlpLocation location = {0}; - GpsLocationExtended locationExtended = {0}; - - location.size = sizeof(location); - locationExtended.size = sizeof(locationExtended); - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS) - { - // Process the position from final and intermediate reports - if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS || - location_report_ptr->session_status == RPC_LOC_SESS_STATUS_IN_PROGESS) - { - // Latitude & Longitude - if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) && - (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE) && - (location_report_ptr->latitude != 0 || - location_report_ptr->longitude != 0)) - { - location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_LAT_LONG; - location.gpsLocation.latitude = location_report_ptr->latitude; - location.gpsLocation.longitude = location_report_ptr->longitude; - - // Time stamp (UTC) - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC) - { - location.gpsLocation.timestamp = location_report_ptr->timestamp_utc; - } - - // Altitude - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID ) - { - location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_ALTITUDE; - location.gpsLocation.altitude = location_report_ptr->altitude_wrt_ellipsoid; - } - - // Speed - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) - { - location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_SPEED; - location.gpsLocation.speed = location_report_ptr->speed_horizontal; - } - - // Heading - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HEADING) - { - location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_BEARING; - location.gpsLocation.bearing = location_report_ptr->heading; - } - - // Uncertainty (circular) - if ( (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR) ) - { - location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_ACCURACY; - location.gpsLocation.accuracy = location_report_ptr->hor_unc_circular; - } - - // Technology Mask - - tech_Mask |= location_report_ptr->technology_mask; - //Mark the location source as from GNSS - location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; - location.position_source = ULP_LOCATION_IS_FROM_GNSS; - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL) - { - locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL; - locationExtended.altitudeMeanSeaLevel = location_report_ptr->altitude_wrt_mean_sea_level; - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_MAGNETIC_VARIATION ) - { - locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_MAG_DEV; - locationExtended.magneticDeviation = location_report_ptr->magnetic_deviation; - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_VERTICAL_UNC) - { - locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_VERT_UNC; - locationExtended.vert_unc = location_report_ptr->vert_unc; - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_UNC) - { - locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_SPEED_UNC; - locationExtended.speed_unc = location_report_ptr->speed_unc; - } - - LOC_LOGV("reportPosition: fire callback\n"); - enum loc_sess_status fixStatus = - (location_report_ptr->session_status - == RPC_LOC_SESS_STATUS_IN_PROGESS ? - LOC_SESS_INTERMEDIATE : LOC_SESS_SUCCESS); - LocApiBase::reportPosition(location, - locationExtended, - (void*)location_report_ptr, - fixStatus, - tech_Mask); - } - } - else - { - LocApiBase::reportPosition(location, - locationExtended, - NULL, - LOC_SESS_FAILURE); - LOC_LOGV("loc_eng_report_position: ignore position report " - "when session status = %d\n", - location_report_ptr->session_status); - } - } - else - { - LOC_LOGV("loc_eng_report_position: ignore position report " - "when session status is not set\n"); - } -} - -void LocApiRpc::reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr) -{ - QtiGnssSvStatus SvStatus = {0}; - GpsLocationExtended locationExtended = {0}; - locationExtended.size = sizeof(locationExtended); - int num_svs_max = 0; - const rpc_loc_sv_info_s_type *sv_info_ptr; - - if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT) - { - num_svs_max = gnss_report_ptr->sv_count; - if (num_svs_max > LOC_GPS_MAX_SVS) - { - num_svs_max = LOC_GPS_MAX_SVS; - } - } - - if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST) - { - SvStatus.num_svs = 0; - - for (int i = 0; i < num_svs_max; i++) - { - sv_info_ptr = &(gnss_report_ptr->sv_list.sv_list_val[i]); - if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SYSTEM) - { - if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GPS) - { - SvStatus.sv_list[SvStatus.num_svs].size = sizeof(LocGpsSvInfo); - SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn; - - // We only have the data field to report gps eph and alm mask - if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_EPH) && - (sv_info_ptr->has_eph == 1)) - { - SvStatus.ephemeris_mask |= (1 << (sv_info_ptr->prn-1)); - } - - if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_ALM) && - (sv_info_ptr->has_alm == 1)) - { - SvStatus.almanac_mask |= (1 << (sv_info_ptr->prn-1)); - } - - if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) && - (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK)) - { - SvStatus.gps_used_in_fix_mask |= (1 << (sv_info_ptr->prn-1)); - } - } - // SBAS: GPS RPN: 120-151, - // In exteneded measurement report, we follow nmea standard, which is from 33-64. - else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_SBAS) - { - SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + 33 - 120; - } - // Gloness: Slot id: 1-32 - // In extended measurement report, we follow nmea standard, which is 65-96 - else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GLONASS) - { - if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) && - (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK)) - { - SvStatus.glo_used_in_fix_mask |= (1 << (sv_info_ptr->prn-1)); - } - - SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + (65-1); - } - // Unsupported SV system - else - { - continue; - } - } - - if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SNR) - { - SvStatus.sv_list[SvStatus.num_svs].snr = sv_info_ptr->snr; - } - - if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_ELEVATION) - { - SvStatus.sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation; - } - - if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_AZIMUTH) - { - SvStatus.sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth; - } - - SvStatus.num_svs++; - } - } - - if ((gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP) && - (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP) && - (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP)) - { - locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_DOP; - locationExtended.pdop = gnss_report_ptr->position_dop; - locationExtended.hdop = gnss_report_ptr->horizontal_dop; - locationExtended.vdop = gnss_report_ptr->vertical_dop; - } - - if (SvStatus.num_svs >= 0) - { - LocApiBase::reportSv(SvStatus, - locationExtended, - (void*)gnss_report_ptr); - } -} - -void LocApiRpc::reportStatus(const rpc_loc_status_event_s_type *status_report_ptr) -{ - - if (status_report_ptr->event == RPC_LOC_STATUS_EVENT_ENGINE_STATE) { - if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_ON) - { - LocApiBase::reportStatus(LOC_GPS_STATUS_ENGINE_ON); - LocApiBase::reportStatus(LOC_GPS_STATUS_SESSION_BEGIN); - } - else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF) - { - LocApiBase::reportStatus(LOC_GPS_STATUS_SESSION_END); - LocApiBase::reportStatus(LOC_GPS_STATUS_ENGINE_OFF); - } - else - { - LocApiBase::reportStatus(LOC_GPS_STATUS_NONE); - } - } - -} - -void LocApiRpc::reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr) -{ - -#if (AMSS_VERSION==3200) - LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences.nmea_sentences_val, - nmea_report_ptr->nmea_sentences.nmea_sentences_len); -#else - LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences, - nmea_report_ptr->length); - LOC_LOGD("loc_eng_report_nmea: $%c%c%c\n", - nmea_report_ptr->nmea_sentences[3], - nmea_report_ptr->nmea_sentences[4], - nmea_report_ptr->nmea_sentences[5]); -#endif /* #if (AMSS_VERSION==3200) */ -} - -enum loc_api_adapter_err -LocApiRpc::setXtraData(char* data, int length) -{ - int rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE; - int total_parts; - uint8 part; - uint16 part_len; - uint16 len_injected; - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA; - rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr; - - LOC_LOGD("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%lx\n", length, (long) 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 - 1) / XTRA_BLOCK_SIZE + 1; - predicted_orbits_data_ptr->total_parts = total_parts; - - len_injected = 0; // O bytes injected - ioctl_data.disc = ioctl_type; - - // 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; - - LOC_LOGD("qct_loc_eng_inject_xtra_data, part %d/%d, len = %d, total = %d\n", - predicted_orbits_data_ptr->part, - total_parts, - predicted_orbits_data_ptr->part_len, - len_injected); - - if (part < total_parts) - { - // No callback in this case - rpc_ret_val = loc_ioctl (client_handle, - ioctl_type, - &ioctl_data); - - if (rpc_ret_val != RPC_LOC_API_SUCCESS) - { - LOC_LOGE("loc_ioctl for xtra error: %s\n", loc_get_ioctl_status_name(rpc_ret_val)); - break; - } - //Add a delay of 10 ms so that repeated RPC calls dont starve the modem processor - usleep(10 * 1000); - } - else // part == total_parts - { - // Last part injection, will need to wait for callback - if (!loc_eng_ioctl(client_handle, - ioctl_type, - &ioctl_data, - LOC_XTRA_INJECT_DEFAULT_TIMEOUT, - NULL)) - { - rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE; - } - break; // done with injection - } - - len_injected += predicted_orbits_data_ptr->part_len; - LOC_LOGD("loc_ioctl XTRA injected length: %d\n", len_injected); - } - - return convertErr(rpc_ret_val); -} - -/* Request the Xtra Server Url from the modem */ -enum loc_api_adapter_err -LocApiRpc::requestXtraServer() -{ - loc_api_adapter_err err; - rpc_loc_ioctl_data_u_type data; - rpc_loc_ioctl_callback_s_type callback_data; - - err = convertErr(loc_eng_ioctl(client_handle, - RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE, - &data, - LOC_IOCTL_DEFAULT_TIMEOUT, - &callback_data)); - - if (LOC_API_ADAPTER_ERR_SUCCESS != err) - { - LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: err=%d\n", err); - return err; - } - else if (RPC_LOC_SESS_STATUS_SUCCESS != callback_data.status) - { - LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: status=%ld\n", callback_data.status); - return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; - } - else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.type) - { - LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the type expected! type=%d\n", callback_data.type); - return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; - } - else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.data.disc) - { - LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the disc expected! disc=%d\n", callback_data.data.disc); - return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; - } - - reportXtraServer(callback_data.data.rpc_loc_ioctl_callback_data_u_type_u. - predicted_orbits_data_source.servers[0], - callback_data.data.rpc_loc_ioctl_callback_data_u_type_u. - predicted_orbits_data_source.servers[1], - callback_data.data.rpc_loc_ioctl_callback_data_u_type_u. - predicted_orbits_data_source.servers[2], - 255); - - return LOC_API_ADAPTER_ERR_SUCCESS; -} - -enum loc_api_adapter_err -LocApiRpc::atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, LocAGpsType agpsType) -{ - rpc_loc_server_open_status_e_type open_status = is_succ ? RPC_LOC_SERVER_OPEN_SUCCESS : RPC_LOC_SERVER_OPEN_FAIL; - rpc_loc_ioctl_data_u_type ioctl_data; - - if (LOC_AGPS_TYPE_INVALID == agpsType) { - rpc_loc_server_open_status_s_type *conn_open_status_ptr = - &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status; - - // Fill in data - ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS; - conn_open_status_ptr->conn_handle = handle; - conn_open_status_ptr->open_status = open_status; -#if (AMSS_VERSION==3200) - conn_open_status_ptr->apn_name = apn; /* requires APN */ -#else - if (is_succ) { - strlcpy(conn_open_status_ptr->apn_name, apn, - sizeof conn_open_status_ptr->apn_name); - } else { - conn_open_status_ptr->apn_name[0] = 0; - } -#endif /* #if (AMSS_VERSION==3200) */ - - LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS open %s, APN name = [%s]\n", - log_succ_fail_string(is_succ), - apn); - } else { - rpc_loc_server_multi_open_status_s_type *conn_multi_open_status_ptr = - &ioctl_data.rpc_loc_ioctl_data_u_type_u.multi_conn_open_status; - - // Fill in data - ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS; - conn_multi_open_status_ptr->conn_handle = handle; - conn_multi_open_status_ptr->open_status = open_status; - if (is_succ) { - strlcpy(conn_multi_open_status_ptr->apn_name, apn, - sizeof conn_multi_open_status_ptr->apn_name); - } else { - conn_multi_open_status_ptr->apn_name[0] = 0; - } - - switch(bearer) - { - case AGPS_APN_BEARER_IPV4: - conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IP; - break; - case AGPS_APN_BEARER_IPV6: - conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV6; - break; - case AGPS_APN_BEARER_IPV4V6: - conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV4V6; - break; - default: - conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_PPP; - } - - LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS open %s, APN name = [%s], pdp_type = %d\n", - log_succ_fail_string(is_succ), - apn, - conn_multi_open_status_ptr->pdp_type); - } - - // Make the IOCTL call - return convertErr( - loc_eng_ioctl(client_handle, - ioctl_data.disc, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); -} - -enum loc_api_adapter_err -LocApiRpc::atlCloseStatus(int handle, int is_succ) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS; - - rpc_loc_server_close_status_s_type *conn_close_status_ptr = - &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status; - conn_close_status_ptr->conn_handle = handle; - conn_close_status_ptr->close_status = is_succ ? RPC_LOC_SERVER_CLOSE_SUCCESS : RPC_LOC_SERVER_CLOSE_FAIL; - - // Make the IOCTL call - return convertErr( - loc_eng_ioctl(client_handle, - ioctl_data.disc, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); -} - -void LocApiRpc::ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr) -{ - int connHandle; - LocAGpsType agps_type; - - LOC_LOGV("RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST event %s)", - loc_get_event_atl_open_name(server_request_ptr->event)); - switch (server_request_ptr->event) - { - case RPC_LOC_SERVER_REQUEST_MULTI_OPEN: - connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.conn_handle; - if (server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.connection_type - == RPC_LOC_SERVER_CONNECTION_LBS) { - agps_type = LOC_AGPS_TYPE_SUPL; - LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - LOC_AGPS_TYPE_SUPL\n handle - %d", connHandle); - } else { - agps_type = LOC_AGPS_TYPE_WWAN_ANY; - LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - LOC_AGPS_TYPE_WWAN_ANY\n handle - %d", connHandle); - } - requestATL(connHandle, agps_type); - break; - case RPC_LOC_SERVER_REQUEST_OPEN: - connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle; - LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_OPEN\n handle - %d", connHandle); - requestATL(connHandle, LOC_AGPS_TYPE_INVALID); - break; - case RPC_LOC_SERVER_REQUEST_CLOSE: - connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle; - LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_CLOSE\n handle - %d", connHandle); - releaseATL(connHandle); - break; - default: - LOC_LOGE("ATLEvent: event type %d invalid", server_request_ptr->event); - } -} - -void LocApiRpc::NIEvent(const rpc_loc_ni_event_s_type *ni_req) -{ - LocGpsNiNotification notif = {0}; - - switch (ni_req->event) - { - case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ: - { - const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req = - &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req; - LOC_LOGI("VX Notification"); - notif.ni_type = LOC_GPS_NI_TYPE_VOICE; - // 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 = convertNiEncodingType(vx_req->encoding_scheme); - NIEventFillVerfiyType(notif, vx_req->notification_priv_type); - } - break; - - case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ: - { - const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req = - &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req; - LOC_LOGI("UMTS CP Notification\n"); - notif.ni_type= LOC_GPS_NI_TYPE_UMTS_CTRL_PLANE; // Stores notification text -#if (AMSS_VERSION==3200) - hexcode(notif.text, sizeof notif.text, - umts_cp_req->notification_text.notification_text_val, - umts_cp_req->notification_length); - hexcode(notif.requestor_id, sizeof notif.requestor_id, - umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val, - umts_cp_req->requestor_id.string_len); -#else - hexcode(notif.text, sizeof notif.text, - umts_cp_req->notification_text, - umts_cp_req->notification_length); - hexcode(notif.requestor_id, sizeof notif.requestor_id, - umts_cp_req->requestor_id.requestor_id_string, - umts_cp_req->requestor_id.string_len); -#endif - notif.text_encoding = convertNiEncodingType(umts_cp_req->datacoding_scheme); - notif.requestor_id_encoding = notif.text_encoding; - NIEventFillVerfiyType(notif, umts_cp_req->notification_priv_type); - - // LCS address (using extras field) - if (umts_cp_req->ext_client_address_data.ext_client_address_len != 0) - { - // Copy LCS Address into notif.extras in the format: Address = 012345 - strlcat(notif.extras, LOC_NI_NOTIF_KEY_ADDRESS, sizeof notif.extras); - strlcat(notif.extras, " = ", sizeof notif.extras); - int addr_len = 0; - const char *address_source = NULL; - -#if (AMSS_VERSION==3200) - address_source = umts_cp_req->ext_client_address_data.ext_client_address.ext_client_address_val; -#else - address_source = umts_cp_req->ext_client_address_data.ext_client_address; -#endif /* #if (AMSS_VERSION==3200) */ - - char lcs_addr[32]; // Decoded LCS address for UMTS CP NI - addr_len = decodeAddress(lcs_addr, sizeof lcs_addr, address_source, - umts_cp_req->ext_client_address_data.ext_client_address_len); - - // The address is ASCII string - if (addr_len) - { - strlcat(notif.extras, lcs_addr, sizeof notif.extras); - } - } - } - break; - - case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ: - { - const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req = - &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req; - LOC_LOGI("SUPL Notification\n"); - notif.ni_type = LOC_GPS_NI_TYPE_UMTS_SUPL; - - if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT) - { -#if (AMSS_VERSION==3200) - hexcode(notif.text, sizeof notif.text, - supl_req->client_name.client_name_string.client_name_string_val, /* buffer */ - supl_req->client_name.string_len /* length */ - ); -#else - hexcode(notif.text, sizeof notif.text, - supl_req->client_name.client_name_string, /* buffer */ - supl_req->client_name.string_len /* length */ - ); -#endif /* #if (AMSS_VERSION==3200) */ - LOC_LOGV("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len); - } - else { - LOC_LOGV("SUPL NI: client_name not present."); - } - - // Requestor ID - if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT) - { -#if (AMSS_VERSION==3200) - hexcode(notif.requestor_id, sizeof notif.requestor_id, - supl_req->requestor_id.requestor_id_string.requestor_id_string_val, /* buffer */ - supl_req->requestor_id.string_len /* length */ - ); -#else - hexcode(notif.requestor_id, sizeof notif.requestor_id, - supl_req->requestor_id.requestor_id_string, /* buffer */ - supl_req->requestor_id.string_len /* length */ - ); -#endif /* #if (AMSS_VERSION==3200) */ - LOC_LOGV("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len); - } - else { - LOC_LOGV("SUPL NI: requestor_id not present."); - } - - // Encoding type - if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT) - { - notif.text_encoding = convertNiEncodingType(supl_req->datacoding_scheme); - notif.requestor_id_encoding = notif.text_encoding; - } - else { - notif.text_encoding = notif.requestor_id_encoding = LOC_GPS_ENC_UNKNOWN; - } - - NIEventFillVerfiyType(notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type); - } - break; - - default: - LOC_LOGE("Unknown NI event: %x\n", (int) ni_req->event); - return; - } - - // this copy will get freed in loc_eng_ni when loc_ni_respond() is called - rpc_loc_ni_event_s_type *copy = (rpc_loc_ni_event_s_type *)malloc(sizeof(*copy)); - memcpy(copy, ni_req, sizeof(*copy)); - requestNiNotify(notif, (const void*)copy); -} - -int LocApiRpc::NIEventFillVerfiyType(LocGpsNiNotification ¬if, - rpc_loc_ni_notify_verify_e_type notif_priv) -{ - switch (notif_priv) - { - case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY: - notif.notify_flags = 0; - notif.default_response = LOC_GPS_NI_RESPONSE_NORESP; - return 1; - case RPC_LOC_NI_USER_NOTIFY_ONLY: - notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY; - notif.default_response = LOC_GPS_NI_RESPONSE_NORESP; - return 1; - case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP: - notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY | LOC_GPS_NI_NEED_VERIFY; - notif.default_response = LOC_GPS_NI_RESPONSE_ACCEPT; - return 1; - case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP: - notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY | LOC_GPS_NI_NEED_VERIFY; - notif.default_response = LOC_GPS_NI_RESPONSE_DENY; - return 1; - case RPC_LOC_NI_USER_PRIVACY_OVERRIDE: - notif.notify_flags = LOC_GPS_NI_PRIVACY_OVERRIDE; - notif.default_response = LOC_GPS_NI_RESPONSE_NORESP; - return 1; - default: - return 0; - } -} - -enum loc_api_adapter_err -LocApiRpc::setSUPLVersion(uint32_t version) -{ - rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_SUPL_VERSION, {0}}; - ioctl_data.rpc_loc_ioctl_data_u_type_u.supl_version = (int)version; - return convertErr( - loc_eng_ioctl (client_handle, - RPC_LOC_IOCTL_SET_SUPL_VERSION, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL) - ); -} - -LocGpsNiEncodingType LocApiRpc::convertNiEncodingType(int loc_encoding) -{ - switch (loc_encoding) - { - case RPC_LOC_NI_SUPL_UTF8: - return LOC_GPS_ENC_SUPL_UTF8; - case RPC_LOC_NI_SUPL_UCS2: - return LOC_GPS_ENC_SUPL_UCS2; - case RPC_LOC_NI_SUPL_GSM_DEFAULT: - return LOC_GPS_ENC_SUPL_GSM_DEFAULT; - case RPC_LOC_NI_SS_LANGUAGE_UNSPEC: - return LOC_GPS_ENC_SUPL_GSM_DEFAULT; // SS_LANGUAGE_UNSPEC = GSM - default: - return LOC_GPS_ENC_UNKNOWN; - } -} - -LocApiBase* getLocApi(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, - ContextBase *context) { - return new LocApiRpc(msgTask, exMask, context); -} - -/*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions -*/ -int LocApiRpc::setGpsLock(LOC_GPS_LOCK_MASK lockMask) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - boolean ret_val; - LOC_LOGD("%s:%d]: lock: %x\n", __func__, __LINE__, lockMask); - ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = convertGpsLockMask(lockMask); - ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK; - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_SET_ENGINE_LOCK, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - LOC_LOGD("%s:%d]: ret_val: %d\n", __func__, __LINE__, (int)ret_val); - return (ret_val == TRUE ? 0 : -1); -} - -/* - Returns - Current value of GPS lock on success - -1 on failure -*/ -int LocApiRpc :: getGpsLock() -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_ioctl_callback_s_type callback_payload; - boolean ret_val; - int ret=0; - LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__); - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_GET_ENGINE_LOCK, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - &callback_payload); - if(ret_val == TRUE) { - ret = (int)callback_payload.data.engine_lock; - LOC_LOGD("%s:%d]: Lock type: %d\n", __func__, __LINE__, ret); - } - else { - LOC_LOGE("%s:%d]: Ioctl failed", __func__, __LINE__); - ret = -1; - } - LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__); - return ret; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c deleted file mode 100644 index 837ef113..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c +++ /dev/null @@ -1,52 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include - -#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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c deleted file mode 100644 index eb685fdf..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c +++ /dev/null @@ -1,344 +0,0 @@ -/* Copyright (c) 2011, 2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_api_rpc_glue" - -#include "loc_api_log.h" -#include "loc_log.h" -#include "platform_lib_includes.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); -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c deleted file mode 100644 index 8c12426b..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c +++ /dev/null @@ -1,635 +0,0 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/*===================================================================== - - INCLUDE FILES FOR MODULE - -======================================================================*/ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -/* 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 -#ifndef USE_GLIB -#include -#endif /* USE_GLIB */ - -/* Logging Improvement */ -#include "platform_lib_includes.h" -/*Maximum number of Modem init*/ -#define RPC_TRY_NUM 10 - -/*Maximum number of Modem init*/ -#define RPC_TRY_NUM 10 - -/* Uncomment to force ALOGD messages */ -// #define ALOGD ALOGI - -/*===================================================================== - 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__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__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__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 -) -{ - int try_num = RPC_TRY_NUM; - 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, j = LOC_API_CB_MAX_CLIENTS; - for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++) - { - if (loc_glue_callback_table[i].user == userData) - { - LOC_LOGW("Client already opened service (callback=%p)...\n", - event_callback); - break; - } else if (j == LOC_API_CB_MAX_CLIENTS && - loc_glue_callback_table[i].user == NULL) { - j = i; - } - } - - if (i == LOC_API_CB_MAX_CLIENTS) - { - i = j; - } - - if (i == LOC_API_CB_MAX_CLIENTS) - { - LOC_LOGE("Too many clients opened at once...\n"); - return RPC_LOC_CLIENT_HANDLE_INVALID; - } - - 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; - - 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"); - - /*try more for rpc_loc_open_xx()*/ - - do - { - stat = RPC_FUNC_VERSION(rpc_loc_open_, RPC_LOC_OPEN_VERSION)(&args, &rets, loc_api_clnt); - ret_val = (rpc_loc_client_handle_type) rets.loc_open_result; - try_num--; - - }while( (RPC_SUCCESS != stat||0 > ret_val) && 0 != try_num ); - - 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; - - 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; - loc_glue_callback_table[i].user = NULL; - 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; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c deleted file mode 100644 index ae629d7c..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c +++ /dev/null @@ -1,565 +0,0 @@ -/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include -#include -#include -#include -#include - -#include -#include -#include "loc_api_sync_call.h" - -/* Logging */ -#define LOG_TAG "LocSvc_api_rpc_glue" -// #define LOG_NDDEBUG 0 -#ifndef USE_GLIB -#include -#endif /* USE_GLIB */ - -/*************************************************************************** - * 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; - - ALOGV("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; - - ALOGV("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) - { - ALOGV("trylock EBUSY : %d", i); - continue; - } - - if (!slot->in_use && !slot->not_available) - { - select_id = i; - /* Return from here and leave the mutex locked. - * will unlock it in loc_unlock_slot() - */ - break; - } - /* ALOGV("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 - Unlocks a buffer slot - -DEPENDENCIES - N/A - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_unlock_slot(int select_id) -{ - pthread_mutex_unlock(&loc_sync_data.slots[select_id].lock); -} - -/*=========================================================================== - -FUNCTION loc_lock_slot - -DESCRIPTION - Locks a specific slot that was previously locked from loc_lock_a_slot - -DEPENDENCIES - N/A - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_lock_slot(int select_id) -{ - pthread_mutex_lock(&loc_sync_data.slots[select_id].lock); -} - -/*=========================================================================== - -FUNCTION loc_set_slot_in_use - -DESCRIPTION - Sets the in_use flag of slot to true or false. - Should be called only after the slot is locked - -DEPENDENCIES - N/A - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_set_slot_in_use(int select_id, boolean in_use) -{ - loc_sync_data.slots[select_id].in_use = in_use; - if (in_use == 1) - loc_sync_data.slots[select_id].signal_sent = 0; -} - -/*=========================================================================== - -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 = 0; /* 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 */ - ALOGE("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) - { - ALOGE("slot not available ioctl_type = %s", - loc_get_ioctl_type_name(ioctl_type)); - return rc; - } - - loc_set_slot_in_use(select_id, 1); // set slot in use to true - - // Select the callback we are waiting for - loc_api_save_callback(select_id, handle, 0, ioctl_type); - - loc_unlock_slot(select_id); // slot is unlocked, but in_use is still true - - // we want to avoid keeping the slot locked during the loc_ioctl because the rpc - // framework will also lock a different mutex during this call, and typically - // locking two different mutexes at the same time can lead to deadlock. - rc = loc_ioctl(handle, ioctl_type, ioctl_data_ptr); - - loc_lock_slot(select_id); - - if (rc != RPC_LOC_API_SUCCESS) - { - ALOGE("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 { - ALOGV("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 - ALOGE("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; - ALOGE("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 { - ALOGV("callback status success select_id = %d, ioctl_type %d, returned %d", - select_id, ioctl_type, rc); - } - } /* wait callback */ - } /* loc_ioctl */ - - loc_set_slot_in_use(select_id, 0); // set slot in use to false - loc_unlock_slot(select_id); - - return rc; -} - - diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c deleted file mode 100644 index db5b291a..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c +++ /dev/null @@ -1,86 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "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; -} - diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk deleted file mode 100644 index c0987e6d..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk +++ /dev/null @@ -1,36 +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_MODULE_OWNER := qcom - -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) diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am deleted file mode 100644 index 4ac8c8a4..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am +++ /dev/null @@ -1,42 +0,0 @@ -AM_CFLAGS = \ - -I../../../utils \ - -I./inc \ - $(MSM7K_CFLAGS) - -requiredlibs = \ - ../../../utils/libgps_utils_so.la \ - $(MSM7K_LIBS) - -h_sources = \ - inc/loc_api_rpcgen_rpc.h \ - inc/loc_api_rpcgen_common_rpc.h \ - inc/loc_api_rpcgen_cb_rpc.h \ - inc/loc_apicb_appinit.h - -c_sources = \ - 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 - - - -library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-stub/inc -library_include_HEADERS = $(h_sources) -libloc_api_rpcgen_la_SOURCES = $(c_sources) $(h_sources) - -if USE_GLIB -libloc_api_rpcgen_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ -libloc_api_rpcgen_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_api_rpcgen_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_api_rpcgen_la_CFLAGS = $(AM_CFLAGS) -libloc_api_rpcgen_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 -libloc_api_rpcgen_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) -endif - -libloc_api_rpcgen_la_LIBADD = $(requiredlibs) -lstdc++ - -#Create and Install Libraries -lib_LTLIBRARIES = libloc_api_rpcgen.la diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h deleted file mode 100644 index 87f2c377..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h +++ /dev/null @@ -1,156 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * 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 - -#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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h deleted file mode 100644 index 8107de2a..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h +++ /dev/null @@ -1,1261 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _LOC_API_COMMON_RPC_H_RPCGEN -#define _LOC_API_COMMON_RPC_H_RPCGEN - -#include "librpc.h" -#include "commondefs_rpcgen_rpc.h" - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define LOC_API_TOOLVERS 0x00040030 -#define LOC_API_FEATURES 0x00000001 -#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 -#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 -#define RPC_LOC_EVENT_WPS_NEEDED_REQUEST 0x00000200 -#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 -#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 -#define RPC_LOC_EVENT_RESERVED 0x8000000000000000 -#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 -#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 -#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 -#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 -#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 -#define RPC_LOC_API_CB_NULL_VERSION 0x00050002 -#define RPC_LOC_EVENT_CB_F_TYPE_VERSION 0x00050001 -#define RPC_LOC_API_API_VERSIONS_VERSION 0x00050001 -#define RPC_LOC_STOP_FIX_VERSION 0x00050001 -#define RPC_LOC_START_FIX_VERSION 0x00050001 -#define RPC_LOC_IOCTL_VERSION 0x00050001 -#define RPC_LOC_CLOSE_VERSION 0x00050001 -#define RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION 0x00050001 -#define RPC_LOC_OPEN_VERSION 0x00050001 -#define RPC_LOC_API_NULL_VERSION 0x00050001 -#define RPC_LOC_API_API_MAJOR_NUM 0x0005 -#define RPC_LOC_APIAPI_VERSION_IS_HASHKEY 0 - -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, -}; -typedef enum rpc_loc_session_status_e_type rpc_loc_session_status_e_type; - -struct rpc_loc_calendar_time_s_type { - rpc_uint16 year; - u_char month; - u_char day_of_week; - u_char day; - u_char hour; - u_char minute; - u_char second; - rpc_uint16 millisecond; -}; -typedef struct rpc_loc_calendar_time_s_type rpc_loc_calendar_time_s_type; - -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; - u_char confidence_horizontal; - u_char confidence_vertical; - float magnetic_deviation; - rpc_loc_pos_technology_mask_type technology_mask; -}; -typedef struct rpc_loc_parsed_position_s_type rpc_loc_parsed_position_s_type; - -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, -}; -typedef enum rpc_loc_sv_system_e_type rpc_loc_sv_system_e_type; - -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 enum rpc_loc_sv_status_e_type rpc_loc_sv_status_e_type; - -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 struct rpc_loc_sv_info_s_type rpc_loc_sv_info_s_type; - -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; - struct { - u_int sv_list_len; - rpc_loc_sv_info_s_type *sv_list_val; - } sv_list; -}; -typedef struct rpc_loc_gnss_info_s_type rpc_loc_gnss_info_s_type; - -struct rpc_loc_nmea_report_s_type { - rpc_uint16 length; - char nmea_sentences[200]; -}; -typedef struct rpc_loc_nmea_report_s_type rpc_loc_nmea_report_s_type; - -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, -}; -typedef enum rpc_loc_status_event_e_type rpc_loc_status_event_e_type; - -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, -}; -typedef enum rpc_loc_engine_state_e_type rpc_loc_engine_state_e_type; - -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, -}; -typedef enum rpc_loc_fix_session_state_e_type rpc_loc_fix_session_state_e_type; - -struct rpc_loc_status_event_payload_u_type { - rpc_loc_status_event_e_type disc; - union { - rpc_loc_engine_state_e_type engine_state; - rpc_loc_fix_session_state_e_type fix_session_state; - } rpc_loc_status_event_payload_u_type_u; -}; -typedef struct rpc_loc_status_event_payload_u_type rpc_loc_status_event_payload_u_type; - -struct rpc_loc_status_event_s_type { - rpc_loc_status_event_e_type event; - rpc_loc_status_event_payload_u_type payload; -}; -typedef struct rpc_loc_status_event_s_type rpc_loc_status_event_s_type; - -enum rpc_loc_server_addr_e_type { - RPC_LOC_SERVER_ADDR_IPV4 = 1, - RPC_LOC_SERVER_ADDR_URL = 2, - RPC_LOC_SERVER_ADDR_IPV6 = 3, - RPC_LOC_SERVER_ADDR_MAX = 268435456, -}; -typedef enum rpc_loc_server_addr_e_type rpc_loc_server_addr_e_type; - -struct rpc_loc_server_addr_ipv4_type { - rpc_uint32 addr; - rpc_uint16 port; -}; -typedef struct rpc_loc_server_addr_ipv4_type rpc_loc_server_addr_ipv4_type; - -struct rpc_loc_server_addr_url_type { - rpc_uint16 length; - char addr[256]; -}; -typedef struct rpc_loc_server_addr_url_type rpc_loc_server_addr_url_type; - -struct rpc_loc_server_addr_ipv6_type { - rpc_uint16 addr[8]; - rpc_uint32 port; -}; -typedef struct rpc_loc_server_addr_ipv6_type rpc_loc_server_addr_ipv6_type; - -struct rpc_loc_server_addr_u_type { - rpc_loc_server_addr_e_type disc; - union { - rpc_loc_server_addr_ipv4_type ipv4; - rpc_loc_server_addr_url_type url; - rpc_loc_server_addr_ipv6_type ipv6; - } rpc_loc_server_addr_u_type_u; -}; -typedef struct rpc_loc_server_addr_u_type rpc_loc_server_addr_u_type; - -struct rpc_loc_server_info_s_type { - rpc_loc_server_addr_e_type addr_type; - rpc_loc_server_addr_u_type addr_info; -}; -typedef struct rpc_loc_server_info_s_type rpc_loc_server_info_s_type; - -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, -}; -typedef enum rpc_loc_ni_notify_verify_e_type rpc_loc_ni_notify_verify_e_type; - -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, -}; -typedef enum rpc_loc_ni_event_e_type rpc_loc_ni_event_e_type; - -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, -}; -typedef enum rpc_loc_ni_datacoding_scheme_e_type rpc_loc_ni_datacoding_scheme_e_type; - -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, -}; -typedef enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type rpc_loc_ni_vx_requester_id_encoding_scheme_e_type; - -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, -}; -typedef enum rpc_loc_ni_vx_pos_mode_e_type rpc_loc_ni_vx_pos_mode_e_type; - -struct rpc_loc_ni_vx_requester_id_s_type { - u_char requester_id_length; - char requester_id[200]; -}; -typedef struct rpc_loc_ni_vx_requester_id_s_type rpc_loc_ni_vx_requester_id_s_type; - -struct rpc_loc_ni_vx_notify_verify_req_s_type { - rpc_loc_ni_notify_verify_e_type notification_priv_type; - u_char pos_qos_incl; - u_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; -}; -typedef struct rpc_loc_ni_vx_notify_verify_req_s_type rpc_loc_ni_vx_notify_verify_req_s_type; - -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, -}; -typedef enum rpc_loc_ni_supl_pos_method_e_type rpc_loc_ni_supl_pos_method_e_type; - -struct rpc_loc_ni_supl_slp_session_id_s_type { - u_char presence; - char session_id[4]; - rpc_loc_server_info_s_type slp_address; -}; -typedef struct rpc_loc_ni_supl_slp_session_id_s_type rpc_loc_ni_supl_slp_session_id_s_type; - -struct rpc_loc_ni_requestor_id_s_type { - u_char data_coding_scheme; - char requestor_id_string[200]; - u_char string_len; -}; -typedef struct rpc_loc_ni_requestor_id_s_type rpc_loc_ni_requestor_id_s_type; - -struct rpc_loc_ni_supl_client_name_s_type { - u_char data_coding_scheme; - char client_name_string[64]; - u_char string_len; -}; -typedef struct rpc_loc_ni_supl_client_name_s_type rpc_loc_ni_supl_client_name_s_type; - -struct rpc_loc_ni_supl_qop_s_type { - u_char bit_mask; - u_char horacc; - u_char veracc; - rpc_uint16 maxLocAge; - u_char delay; -}; -typedef struct rpc_loc_ni_supl_qop_s_type rpc_loc_ni_supl_qop_s_type; - -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; - char 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; -}; -typedef struct rpc_loc_ni_supl_notify_verify_req_s_type rpc_loc_ni_supl_notify_verify_req_s_type; - -struct rpc_loc_ni_ext_client_address_s_type { - u_char ext_client_address_len; - char ext_client_address[20]; -}; -typedef struct rpc_loc_ni_ext_client_address_s_type rpc_loc_ni_ext_client_address_s_type; - -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, -}; -typedef enum rpc_loc_ni_location_type_e_type rpc_loc_ni_location_type_e_type; - -struct rpc_loc_ni_deferred_location_s_type { - u_char unused_bits; - u_char ms_available; -}; -typedef struct rpc_loc_ni_deferred_location_s_type rpc_loc_ni_deferred_location_s_type; - -struct rpc_loc_ni_codeword_string_s_type { - u_char data_coding_scheme; - char lcs_codeword_string[20]; - u_char string_len; -}; -typedef struct rpc_loc_ni_codeword_string_s_type rpc_loc_ni_codeword_string_s_type; - -struct rpc_loc_ni_service_type_id_s_type { - u_char lcs_service_type_id; -}; -typedef struct rpc_loc_ni_service_type_id_s_type rpc_loc_ni_service_type_id_s_type; - -struct rpc_loc_ni_umts_cp_notify_verify_req_s_type { - rpc_loc_ni_notify_verify_e_type notification_priv_type; - u_char invoke_id; - rpc_uint16 flags; - u_char notification_length; - char notification_text[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; -}; -typedef struct rpc_loc_ni_umts_cp_notify_verify_req_s_type rpc_loc_ni_umts_cp_notify_verify_req_s_type; - -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, -}; -typedef enum rpc_loc_ni_service_interaction_e_type rpc_loc_ni_service_interaction_e_type; - -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; -}; -typedef struct rpc_loc_ni_vx_service_interaction_req_s_type rpc_loc_ni_vx_service_interaction_req_s_type; - -struct rpc_loc_ni_event_payload_u_type { - rpc_loc_ni_event_e_type disc; - union { - rpc_loc_ni_vx_notify_verify_req_s_type vx_req; - rpc_loc_ni_supl_notify_verify_req_s_type supl_req; - rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req; - rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req; - } rpc_loc_ni_event_payload_u_type_u; -}; -typedef struct rpc_loc_ni_event_payload_u_type rpc_loc_ni_event_payload_u_type; - -struct rpc_loc_ni_event_s_type { - rpc_loc_ni_event_e_type event; - rpc_loc_ni_event_payload_u_type payload; -}; -typedef struct rpc_loc_ni_event_s_type rpc_loc_ni_event_s_type; - -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_POSITION_INJECTION_REQ = 3, - RPC_LOC_ASSIST_DATA_MAX = 268435456, -}; -typedef enum rpc_loc_assist_data_request_e_type rpc_loc_assist_data_request_e_type; - -typedef char *rpc_struct_loc_time_download_source_s_type_servers_ptr; - -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 struct rpc_loc_time_download_source_s_type rpc_loc_time_download_source_s_type; - -typedef char *rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr; - -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; -}; -typedef struct rpc_loc_predicted_orbits_data_source_s_type rpc_loc_predicted_orbits_data_source_s_type; - -struct rpc_loc_pos_inj_request_s_type { - rpc_uint32 flags; - double latitude; - double longitude; - rpc_uint32 position_uncertainty; - rpc_uint64 timestamp; -}; -typedef struct rpc_loc_pos_inj_request_s_type rpc_loc_pos_inj_request_s_type; - -struct rpc_loc_assist_data_request_payload_u_type { - rpc_loc_assist_data_request_e_type disc; - union { - rpc_loc_time_download_source_s_type time_download; - rpc_loc_predicted_orbits_data_source_s_type data_download; - rpc_loc_pos_inj_request_s_type pos_injection; - } rpc_loc_assist_data_request_payload_u_type_u; -}; -typedef struct rpc_loc_assist_data_request_payload_u_type rpc_loc_assist_data_request_payload_u_type; - -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 struct rpc_loc_assist_data_request_s_type rpc_loc_assist_data_request_s_type; - -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, -}; -typedef enum rpc_loc_server_protocol_e_type rpc_loc_server_protocol_e_type; - -enum rpc_loc_server_connection_e_type { - RPC_LOC_SERVER_CONNECTION_LBS = 0, - RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET = 0 + 1, - RPC_LOC_SERVER_CONNECTION_MAX = 16777216, -}; -typedef enum rpc_loc_server_connection_e_type rpc_loc_server_connection_e_type; - -enum rpc_loc_server_request_e_type { - RPC_LOC_SERVER_REQUEST_OPEN = 1, - RPC_LOC_SERVER_REQUEST_CLOSE = 2, - RPC_LOC_SERVER_REQUEST_MULTI_OPEN = 3, - RPC_LOC_SERVER_REQUEST_MAX = 268435456, -}; -typedef enum rpc_loc_server_request_e_type rpc_loc_server_request_e_type; - -struct rpc_loc_server_open_req_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_protocol_e_type protocol; -}; -typedef struct rpc_loc_server_open_req_s_type rpc_loc_server_open_req_s_type; - -struct rpc_loc_server_multi_open_req_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_protocol_e_type protocol; - rpc_loc_server_connection_e_type connection_type; -}; -typedef struct rpc_loc_server_multi_open_req_s_type rpc_loc_server_multi_open_req_s_type; - -struct rpc_loc_server_close_req_s_type { - rpc_loc_server_connection_handle conn_handle; -}; -typedef struct rpc_loc_server_close_req_s_type rpc_loc_server_close_req_s_type; - -struct rpc_loc_server_request_u_type { - rpc_loc_server_request_e_type disc; - union { - rpc_loc_server_open_req_s_type open_req; - rpc_loc_server_close_req_s_type close_req; - rpc_loc_server_multi_open_req_s_type multi_open_req; - } rpc_loc_server_request_u_type_u; -}; -typedef struct rpc_loc_server_request_u_type rpc_loc_server_request_u_type; - -struct rpc_loc_server_request_s_type { - rpc_loc_server_request_e_type event; - rpc_loc_server_request_u_type payload; -}; -typedef struct rpc_loc_server_request_s_type rpc_loc_server_request_s_type; - -enum rpc_loc_qwip_request_e_type { - RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0, - RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM = 0 + 1, - RPC_LOC_QWIP_STOP_PERIODIC_FIXES = 0 + 2, - RPC_LOC_QWIP_SUSPEND = 0 + 3, - RPC_LOC_QWIP_REQUEST_MAX = 268435456, -}; -typedef enum rpc_loc_qwip_request_e_type rpc_loc_qwip_request_e_type; - -struct rpc_loc_qwip_request_s_type { - rpc_loc_qwip_request_e_type request_type; - rpc_uint16 tbf_ms; -}; -typedef struct rpc_loc_qwip_request_s_type rpc_loc_qwip_request_s_type; - -struct rpc_loc_reserved_payload_s_type { - rpc_uint16 data_size; - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct rpc_loc_reserved_payload_s_type rpc_loc_reserved_payload_s_type; - -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_ERROR_ESTIMATE_CONFIG = 414, - RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415, - 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_SET_XTRA_T_SESSION_CONTROL = 814, - RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815, - RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816, - RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817, - RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818, - RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819, - RPC_LOC_IOCTL_SET_DATA_ENABLE = 820, - RPC_LOC_IOCTL_SET_SUPL_VERSION = 821, - RPC_LOC_IOCTL_GET_SUPL_VERSION = 822, - 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_RESERVED_CMD = 8000, - RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824, -}; -typedef enum rpc_loc_ioctl_e_type rpc_loc_ioctl_e_type; - -struct rpc_loc_api_version_s_type { - u_char major; - u_char minor; -}; -typedef struct rpc_loc_api_version_s_type rpc_loc_api_version_s_type; - -enum rpc_loc_fix_recurrence_e_type { - RPC_LOC_PERIODIC_FIX = 1, - RPC_LOC_SINGLE_FIX = 2, - RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456, -}; -typedef enum rpc_loc_fix_recurrence_e_type rpc_loc_fix_recurrence_e_type; - -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, -}; -typedef enum rpc_loc_operation_mode_e_type rpc_loc_operation_mode_e_type; - -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, -}; -typedef enum rpc_loc_notify_e_type rpc_loc_notify_e_type; - -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; -}; -typedef struct rpc_loc_fix_criteria_s_type rpc_loc_fix_criteria_s_type; - -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, -}; -typedef enum rpc_loc_ni_user_resp_e_type rpc_loc_ni_user_resp_e_type; - -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; -}; -typedef struct rpc_loc_user_verify_s_type rpc_loc_user_verify_s_type; - -enum rpc_loc_predicted_orbits_data_format_e_type { - RPC_LOC_PREDICTED_ORBITS_XTRA = 0, - RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456, -}; -typedef enum rpc_loc_predicted_orbits_data_format_e_type rpc_loc_predicted_orbits_data_format_e_type; - -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; - struct { - u_int data_ptr_len; - char *data_ptr_val; - } data_ptr; -}; -typedef struct rpc_loc_predicted_orbits_data_s_type rpc_loc_predicted_orbits_data_s_type; - -struct rpc_loc_predicted_orbits_data_validity_report_s_type { - rpc_uint64 start_time_utc; - rpc_uint16 valid_duration_hrs; -}; -typedef struct rpc_loc_predicted_orbits_data_validity_report_s_type rpc_loc_predicted_orbits_data_validity_report_s_type; - -struct rpc_loc_predicted_orbits_auto_download_config_s_type { - rpc_boolean enable; - u_char auto_check_every_hrs; -}; -typedef struct rpc_loc_predicted_orbits_auto_download_config_s_type rpc_loc_predicted_orbits_auto_download_config_s_type; - -struct rpc_loc_assist_data_time_s_type { - rpc_uint64 time_utc; - rpc_uint32 uncertainty; -}; -typedef struct rpc_loc_assist_data_time_s_type rpc_loc_assist_data_time_s_type; - -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; - u_char confidence_horizontal; - u_char confidence_vertical; - rpc_int32 timestamp_age; -}; -typedef struct rpc_loc_assist_data_pos_s_type rpc_loc_assist_data_pos_s_type; - -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, -}; -typedef enum rpc_loc_server_open_status_e_type rpc_loc_server_open_status_e_type; - -enum rpc_loc_server_pdp_type_e_type { - RPC_LOC_SERVER_PDP_IP = 0, - RPC_LOC_SERVER_PDP_PPP = 0 + 1, - RPC_LOC_SERVER_PDP_IPV6 = 0 + 2, - RPC_LOC_SERVER_PDP_IPV4V6 = 0 + 3, - RPC_LOC_SERVER_PDP_MAX = 268435456, -}; -typedef enum rpc_loc_server_pdp_type_e_type rpc_loc_server_pdp_type_e_type; - -struct rpc_loc_server_open_status_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_open_status_e_type open_status; - char apn_name[100]; -}; -typedef struct rpc_loc_server_open_status_s_type rpc_loc_server_open_status_s_type; - -struct rpc_loc_server_multi_open_status_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_open_status_e_type open_status; - rpc_loc_server_pdp_type_e_type pdp_type; - char apn_name[100]; -}; -typedef struct rpc_loc_server_multi_open_status_s_type rpc_loc_server_multi_open_status_s_type; - -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, -}; -typedef enum rpc_loc_server_close_status_e_type rpc_loc_server_close_status_e_type; - -struct rpc_loc_server_close_status_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_close_status_e_type close_status; -}; -typedef struct rpc_loc_server_close_status_s_type rpc_loc_server_close_status_s_type; - -struct rpc_loc_wiper_fix_time_s_type { - rpc_uint32 slow_clock_count; -}; -typedef struct rpc_loc_wiper_fix_time_s_type rpc_loc_wiper_fix_time_s_type; - -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; -}; -typedef struct rpc_loc_wiper_fix_pos_s_type rpc_loc_wiper_fix_pos_s_type; - -struct rpc_loc_wiper_ap_info_s_type { - char mac_addr[6]; - rpc_int32 rssi; - rpc_uint16 channel; - rpc_uint8 ap_qualifier; -}; -typedef struct rpc_loc_wiper_ap_info_s_type rpc_loc_wiper_ap_info_s_type; - -struct rpc_loc_wiper_ap_set_s_type { - rpc_uint8 num_of_aps; - rpc_loc_wiper_ap_info_s_type ap_info[50]; -}; -typedef struct rpc_loc_wiper_ap_set_s_type rpc_loc_wiper_ap_set_s_type; - -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; -}; -typedef struct rpc_loc_wiper_position_report_s_type rpc_loc_wiper_position_report_s_type; - -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, -}; -typedef enum rpc_loc_wiper_status_e_type rpc_loc_wiper_status_e_type; - -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, -}; -typedef enum rpc_loc_fs_operation_e_type rpc_loc_fs_operation_e_type; - -struct rpc_loc_efs_data_s_type { - char filename[64]; - rpc_loc_fs_operation_e_type operation; - rpc_uint32 total_size; - struct { - u_int data_ptr_len; - char *data_ptr_val; - } data_ptr; - rpc_uint32 part_len; - rpc_uint8 part; - rpc_uint8 total_parts; - rpc_uint32 reserved; -}; -typedef struct rpc_loc_efs_data_s_type rpc_loc_efs_data_s_type; - -enum rpc_loc_error_estimate_config_e_type { - RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1, - RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2, - RPC_LOC_ERROR_ESTIMATE_MAX = 268435456, -}; -typedef enum rpc_loc_error_estimate_config_e_type rpc_loc_error_estimate_config_e_type; - -struct rpc_loc_apn_profiles_type { - rpc_uint32 srv_system_type; - rpc_uint32 pdp_type; - rpc_uint32 reserved; - char apn_name[100]; -}; -typedef struct rpc_loc_apn_profiles_type rpc_loc_apn_profiles_type; - -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 enum rpc_loc_lock_e_type rpc_loc_lock_e_type; - -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]; -}; -typedef struct rpc_loc_assist_data_delete_s_type rpc_loc_assist_data_delete_s_type; - -struct rpc_loc_ioctl_data_u_type { - rpc_loc_ioctl_e_type disc; - union { - rpc_loc_fix_criteria_s_type fix_criteria; - rpc_loc_user_verify_s_type user_verify_resp; - rpc_loc_predicted_orbits_data_s_type predicted_orbits_data; - rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download; - rpc_loc_assist_data_time_s_type assistance_data_time; - rpc_loc_assist_data_pos_s_type assistance_data_position; - rpc_loc_server_open_status_s_type conn_open_status; - rpc_loc_server_close_status_s_type conn_close_status; - rpc_loc_wiper_position_report_s_type wiper_pos; - rpc_loc_wiper_status_e_type wiper_status; - rpc_loc_lock_e_type engine_lock; - rpc_boolean sbas_mode; - rpc_loc_nmea_sentence_type nmea_types; - rpc_boolean on_demand_lpm; - rpc_loc_server_info_s_type server_addr; - rpc_loc_assist_data_delete_s_type assist_data_delete; - rpc_loc_efs_data_s_type efs_data; - rpc_loc_error_estimate_config_e_type error_estimate_config; - rpc_uint8 xtra_t_session_control; - rpc_loc_apn_profiles_type apn_profiles[6]; - rpc_boolean data_enable; - rpc_uint32 supl_version; - rpc_loc_server_multi_open_status_s_type multi_conn_open_status; - rpc_loc_reserved_payload_s_type reserved; - } rpc_loc_ioctl_data_u_type_u; -}; -typedef struct rpc_loc_ioctl_data_u_type rpc_loc_ioctl_data_u_type; - -struct rpc_loc_ioctl_callback_data_u_type { - rpc_loc_ioctl_e_type disc; - union { - rpc_loc_api_version_s_type api_version; - rpc_loc_fix_criteria_s_type fix_criteria; - rpc_loc_lock_e_type engine_lock; - rpc_boolean sbas_mode; - rpc_loc_nmea_sentence_type nmea_types; - rpc_boolean on_demand_lpm; - rpc_loc_server_info_s_type server_addr; - rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source; - rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity; - rpc_uint8 xtra_t_session_control; - rpc_loc_apn_profiles_type apn_profiles[6]; - rpc_uint32 supl_version; - } rpc_loc_ioctl_callback_data_u_type_u; -}; -typedef struct rpc_loc_ioctl_callback_data_u_type rpc_loc_ioctl_callback_data_u_type; - -struct rpc_loc_ioctl_callback_s_type { - rpc_loc_ioctl_e_type type; - rpc_int32 status; - rpc_loc_ioctl_callback_data_u_type data; -}; -typedef struct rpc_loc_ioctl_callback_s_type rpc_loc_ioctl_callback_s_type; - -struct rpc_loc_event_payload_u_type { - u_quad_t disc; - union { - rpc_loc_parsed_position_s_type parsed_location_report; - rpc_loc_gnss_info_s_type gnss_report; - rpc_loc_nmea_report_s_type nmea_report; - rpc_loc_ni_event_s_type ni_request; - rpc_loc_assist_data_request_s_type assist_data_request; - rpc_loc_server_request_s_type loc_server_request; - rpc_loc_ioctl_callback_s_type ioctl_report; - rpc_loc_status_event_s_type status_report; - rpc_loc_qwip_request_s_type qwip_request; - rpc_loc_reserved_payload_s_type reserved; - } rpc_loc_event_payload_u_type_u; -}; -typedef struct rpc_loc_event_payload_u_type rpc_loc_event_payload_u_type; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_rpc_loc_client_handle_type (XDR *, rpc_loc_client_handle_type*); -extern bool_t xdr_rpc_loc_event_mask_type (XDR *, rpc_loc_event_mask_type*); -extern bool_t xdr_rpc_loc_position_valid_mask_type (XDR *, rpc_loc_position_valid_mask_type*); -extern bool_t xdr_rpc_loc_pos_technology_mask_type (XDR *, rpc_loc_pos_technology_mask_type*); -extern bool_t xdr_rpc_loc_session_status_e_type (XDR *, rpc_loc_session_status_e_type*); -extern bool_t xdr_rpc_loc_calendar_time_s_type (XDR *, rpc_loc_calendar_time_s_type*); -extern bool_t xdr_rpc_loc_parsed_position_s_type (XDR *, rpc_loc_parsed_position_s_type*); -extern bool_t xdr_rpc_loc_sv_system_e_type (XDR *, rpc_loc_sv_system_e_type*); -extern bool_t xdr_rpc_loc_sv_status_e_type (XDR *, rpc_loc_sv_status_e_type*); -extern bool_t xdr_rpc_loc_sv_info_valid_mask_type (XDR *, rpc_loc_sv_info_valid_mask_type*); -extern bool_t xdr_rpc_loc_sv_info_s_type (XDR *, rpc_loc_sv_info_s_type*); -extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type (XDR *, rpc_loc_gnss_info_valid_mask_type*); -extern bool_t xdr_rpc_loc_gnss_info_s_type (XDR *, rpc_loc_gnss_info_s_type*); -extern bool_t xdr_rpc_loc_nmea_report_s_type (XDR *, rpc_loc_nmea_report_s_type*); -extern bool_t xdr_rpc_loc_status_event_e_type (XDR *, rpc_loc_status_event_e_type*); -extern bool_t xdr_rpc_loc_engine_state_e_type (XDR *, rpc_loc_engine_state_e_type*); -extern bool_t xdr_rpc_loc_fix_session_state_e_type (XDR *, rpc_loc_fix_session_state_e_type*); -extern bool_t xdr_rpc_loc_status_event_payload_u_type (XDR *, rpc_loc_status_event_payload_u_type*); -extern bool_t xdr_rpc_loc_status_event_s_type (XDR *, rpc_loc_status_event_s_type*); -extern bool_t xdr_rpc_loc_server_addr_e_type (XDR *, rpc_loc_server_addr_e_type*); -extern bool_t xdr_rpc_loc_server_addr_ipv4_type (XDR *, rpc_loc_server_addr_ipv4_type*); -extern bool_t xdr_rpc_loc_server_addr_url_type (XDR *, rpc_loc_server_addr_url_type*); -extern bool_t xdr_rpc_loc_server_addr_ipv6_type (XDR *, rpc_loc_server_addr_ipv6_type*); -extern bool_t xdr_rpc_loc_server_addr_u_type (XDR *, rpc_loc_server_addr_u_type*); -extern bool_t xdr_rpc_loc_server_info_s_type (XDR *, rpc_loc_server_info_s_type*); -extern bool_t xdr_rpc_loc_ni_notify_verify_e_type (XDR *, rpc_loc_ni_notify_verify_e_type*); -extern bool_t xdr_rpc_loc_ni_event_e_type (XDR *, rpc_loc_ni_event_e_type*); -extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *, rpc_loc_ni_datacoding_scheme_e_type*); -extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type*); -extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *, rpc_loc_ni_vx_pos_mode_e_type*); -extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *, rpc_loc_ni_vx_requester_id_s_type*); -extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *, rpc_loc_ni_vx_notify_verify_req_s_type*); -extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *, rpc_loc_ni_supl_pos_method_e_type*); -extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *, rpc_loc_ni_supl_slp_session_id_s_type*); -extern bool_t xdr_rpc_loc_ni_requestor_id_s_type (XDR *, rpc_loc_ni_requestor_id_s_type*); -extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type (XDR *, rpc_loc_ni_supl_client_name_s_type*); -extern bool_t xdr_rpc_loc_ni_supl_qop_s_type (XDR *, rpc_loc_ni_supl_qop_s_type*); -extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *, rpc_loc_ni_supl_notify_verify_req_s_type*); -extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type (XDR *, rpc_loc_ni_ext_client_address_s_type*); -extern bool_t xdr_rpc_loc_ni_location_type_e_type (XDR *, rpc_loc_ni_location_type_e_type*); -extern bool_t xdr_rpc_loc_ni_deferred_location_s_type (XDR *, rpc_loc_ni_deferred_location_s_type*); -extern bool_t xdr_rpc_loc_ni_codeword_string_s_type (XDR *, rpc_loc_ni_codeword_string_s_type*); -extern bool_t xdr_rpc_loc_ni_service_type_id_s_type (XDR *, rpc_loc_ni_service_type_id_s_type*); -extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *, rpc_loc_ni_umts_cp_notify_verify_req_s_type*); -extern bool_t xdr_rpc_loc_ni_service_interaction_e_type (XDR *, rpc_loc_ni_service_interaction_e_type*); -extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *, rpc_loc_ni_vx_service_interaction_req_s_type*); -extern bool_t xdr_rpc_loc_ni_event_payload_u_type (XDR *, rpc_loc_ni_event_payload_u_type*); -extern bool_t xdr_rpc_loc_ni_event_s_type (XDR *, rpc_loc_ni_event_s_type*); -extern bool_t xdr_rpc_loc_assist_data_request_e_type (XDR *, rpc_loc_assist_data_request_e_type*); -extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *, rpc_struct_loc_time_download_source_s_type_servers_ptr*); -extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *, rpc_struct_loc_time_download_source_s_type_servers); -extern bool_t xdr_rpc_loc_time_download_source_s_type (XDR *, rpc_loc_time_download_source_s_type*); -extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr*); -extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers); -extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *, rpc_loc_predicted_orbits_data_source_s_type*); -extern bool_t xdr_rpc_loc_pos_inj_request_s_type (XDR *, rpc_loc_pos_inj_request_s_type*); -extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type (XDR *, rpc_loc_assist_data_request_payload_u_type*); -extern bool_t xdr_rpc_loc_assist_data_request_s_type (XDR *, rpc_loc_assist_data_request_s_type*); -extern bool_t xdr_rpc_loc_server_connection_handle (XDR *, rpc_loc_server_connection_handle*); -extern bool_t xdr_rpc_loc_server_protocol_e_type (XDR *, rpc_loc_server_protocol_e_type*); -extern bool_t xdr_rpc_loc_server_connection_e_type (XDR *, rpc_loc_server_connection_e_type*); -extern bool_t xdr_rpc_loc_server_request_e_type (XDR *, rpc_loc_server_request_e_type*); -extern bool_t xdr_rpc_loc_server_open_req_s_type (XDR *, rpc_loc_server_open_req_s_type*); -extern bool_t xdr_rpc_loc_server_multi_open_req_s_type (XDR *, rpc_loc_server_multi_open_req_s_type*); -extern bool_t xdr_rpc_loc_server_close_req_s_type (XDR *, rpc_loc_server_close_req_s_type*); -extern bool_t xdr_rpc_loc_server_request_u_type (XDR *, rpc_loc_server_request_u_type*); -extern bool_t xdr_rpc_loc_server_request_s_type (XDR *, rpc_loc_server_request_s_type*); -extern bool_t xdr_rpc_loc_qwip_request_e_type (XDR *, rpc_loc_qwip_request_e_type*); -extern bool_t xdr_rpc_loc_qwip_request_s_type (XDR *, rpc_loc_qwip_request_s_type*); -extern bool_t xdr_rpc_loc_reserved_payload_s_type (XDR *, rpc_loc_reserved_payload_s_type*); -extern bool_t xdr_rpc_loc_ioctl_e_type (XDR *, rpc_loc_ioctl_e_type*); -extern bool_t xdr_rpc_loc_api_version_s_type (XDR *, rpc_loc_api_version_s_type*); -extern bool_t xdr_rpc_loc_fix_recurrence_e_type (XDR *, rpc_loc_fix_recurrence_e_type*); -extern bool_t xdr_rpc_loc_operation_mode_e_type (XDR *, rpc_loc_operation_mode_e_type*); -extern bool_t xdr_rpc_loc_notify_e_type (XDR *, rpc_loc_notify_e_type*); -extern bool_t xdr_rpc_loc_fix_criteria_s_type (XDR *, rpc_loc_fix_criteria_s_type*); -extern bool_t xdr_rpc_loc_ni_user_resp_e_type (XDR *, rpc_loc_ni_user_resp_e_type*); -extern bool_t xdr_rpc_loc_user_verify_s_type (XDR *, rpc_loc_user_verify_s_type*); -extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *, rpc_loc_predicted_orbits_data_format_e_type*); -extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type (XDR *, rpc_loc_predicted_orbits_data_s_type*); -extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *, rpc_loc_predicted_orbits_data_validity_report_s_type*); -extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *, rpc_loc_predicted_orbits_auto_download_config_s_type*); -extern bool_t xdr_rpc_loc_assist_data_time_s_type (XDR *, rpc_loc_assist_data_time_s_type*); -extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type (XDR *, rpc_loc_assist_pos_valid_mask_type*); -extern bool_t xdr_rpc_loc_assist_data_pos_s_type (XDR *, rpc_loc_assist_data_pos_s_type*); -extern bool_t xdr_rpc_loc_server_open_status_e_type (XDR *, rpc_loc_server_open_status_e_type*); -extern bool_t xdr_rpc_loc_server_pdp_type_e_type (XDR *, rpc_loc_server_pdp_type_e_type*); -extern bool_t xdr_rpc_loc_server_open_status_s_type (XDR *, rpc_loc_server_open_status_s_type*); -extern bool_t xdr_rpc_loc_server_multi_open_status_s_type (XDR *, rpc_loc_server_multi_open_status_s_type*); -extern bool_t xdr_rpc_loc_server_close_status_e_type (XDR *, rpc_loc_server_close_status_e_type*); -extern bool_t xdr_rpc_loc_server_close_status_s_type (XDR *, rpc_loc_server_close_status_s_type*); -extern bool_t xdr_rpc_loc_wiper_fix_time_s_type (XDR *, rpc_loc_wiper_fix_time_s_type*); -extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type (XDR *, rpc_loc_wiper_fix_pos_s_type*); -extern bool_t xdr_rpc_loc_wiper_ap_info_s_type (XDR *, rpc_loc_wiper_ap_info_s_type*); -extern bool_t xdr_rpc_loc_wiper_ap_set_s_type (XDR *, rpc_loc_wiper_ap_set_s_type*); -extern bool_t xdr_rpc_loc_wiper_position_report_s_type (XDR *, rpc_loc_wiper_position_report_s_type*); -extern bool_t xdr_rpc_loc_wiper_status_e_type (XDR *, rpc_loc_wiper_status_e_type*); -extern bool_t xdr_rpc_loc_fs_operation_e_type (XDR *, rpc_loc_fs_operation_e_type*); -extern bool_t xdr_rpc_loc_efs_data_s_type (XDR *, rpc_loc_efs_data_s_type*); -extern bool_t xdr_rpc_loc_error_estimate_config_e_type (XDR *, rpc_loc_error_estimate_config_e_type*); -extern bool_t xdr_rpc_loc_apn_profiles_type (XDR *, rpc_loc_apn_profiles_type*); -extern bool_t xdr_rpc_loc_lock_e_type (XDR *, rpc_loc_lock_e_type*); -extern bool_t xdr_rpc_loc_nmea_sentence_type (XDR *, rpc_loc_nmea_sentence_type*); -extern bool_t xdr_rpc_loc_assist_data_type (XDR *, rpc_loc_assist_data_type*); -extern bool_t xdr_rpc_loc_assist_data_delete_s_type (XDR *, rpc_loc_assist_data_delete_s_type*); -extern bool_t xdr_rpc_loc_ioctl_data_u_type (XDR *, rpc_loc_ioctl_data_u_type*); -extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type (XDR *, rpc_loc_ioctl_callback_data_u_type*); -extern bool_t xdr_rpc_loc_ioctl_callback_s_type (XDR *, rpc_loc_ioctl_callback_s_type*); -extern bool_t xdr_rpc_loc_event_payload_u_type (XDR *, rpc_loc_event_payload_u_type*); - -#else /* K&R C */ -extern bool_t xdr_rpc_loc_client_handle_type (); -extern bool_t xdr_rpc_loc_event_mask_type (); -extern bool_t xdr_rpc_loc_position_valid_mask_type (); -extern bool_t xdr_rpc_loc_pos_technology_mask_type (); -extern bool_t xdr_rpc_loc_session_status_e_type (); -extern bool_t xdr_rpc_loc_calendar_time_s_type (); -extern bool_t xdr_rpc_loc_parsed_position_s_type (); -extern bool_t xdr_rpc_loc_sv_system_e_type (); -extern bool_t xdr_rpc_loc_sv_status_e_type (); -extern bool_t xdr_rpc_loc_sv_info_valid_mask_type (); -extern bool_t xdr_rpc_loc_sv_info_s_type (); -extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type (); -extern bool_t xdr_rpc_loc_gnss_info_s_type (); -extern bool_t xdr_rpc_loc_nmea_report_s_type (); -extern bool_t xdr_rpc_loc_status_event_e_type (); -extern bool_t xdr_rpc_loc_engine_state_e_type (); -extern bool_t xdr_rpc_loc_fix_session_state_e_type (); -extern bool_t xdr_rpc_loc_status_event_payload_u_type (); -extern bool_t xdr_rpc_loc_status_event_s_type (); -extern bool_t xdr_rpc_loc_server_addr_e_type (); -extern bool_t xdr_rpc_loc_server_addr_ipv4_type (); -extern bool_t xdr_rpc_loc_server_addr_url_type (); -extern bool_t xdr_rpc_loc_server_addr_ipv6_type (); -extern bool_t xdr_rpc_loc_server_addr_u_type (); -extern bool_t xdr_rpc_loc_server_info_s_type (); -extern bool_t xdr_rpc_loc_ni_notify_verify_e_type (); -extern bool_t xdr_rpc_loc_ni_event_e_type (); -extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type (); -extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (); -extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type (); -extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type (); -extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type (); -extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type (); -extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type (); -extern bool_t xdr_rpc_loc_ni_requestor_id_s_type (); -extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type (); -extern bool_t xdr_rpc_loc_ni_supl_qop_s_type (); -extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type (); -extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type (); -extern bool_t xdr_rpc_loc_ni_location_type_e_type (); -extern bool_t xdr_rpc_loc_ni_deferred_location_s_type (); -extern bool_t xdr_rpc_loc_ni_codeword_string_s_type (); -extern bool_t xdr_rpc_loc_ni_service_type_id_s_type (); -extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (); -extern bool_t xdr_rpc_loc_ni_service_interaction_e_type (); -extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type (); -extern bool_t xdr_rpc_loc_ni_event_payload_u_type (); -extern bool_t xdr_rpc_loc_ni_event_s_type (); -extern bool_t xdr_rpc_loc_assist_data_request_e_type (); -extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (); -extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers (); -extern bool_t xdr_rpc_loc_time_download_source_s_type (); -extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (); -extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (); -extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type (); -extern bool_t xdr_rpc_loc_pos_inj_request_s_type (); -extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type (); -extern bool_t xdr_rpc_loc_assist_data_request_s_type (); -extern bool_t xdr_rpc_loc_server_connection_handle (); -extern bool_t xdr_rpc_loc_server_protocol_e_type (); -extern bool_t xdr_rpc_loc_server_connection_e_type (); -extern bool_t xdr_rpc_loc_server_request_e_type (); -extern bool_t xdr_rpc_loc_server_open_req_s_type (); -extern bool_t xdr_rpc_loc_server_multi_open_req_s_type (); -extern bool_t xdr_rpc_loc_server_close_req_s_type (); -extern bool_t xdr_rpc_loc_server_request_u_type (); -extern bool_t xdr_rpc_loc_server_request_s_type (); -extern bool_t xdr_rpc_loc_qwip_request_e_type (); -extern bool_t xdr_rpc_loc_qwip_request_s_type (); -extern bool_t xdr_rpc_loc_reserved_payload_s_type (); -extern bool_t xdr_rpc_loc_ioctl_e_type (); -extern bool_t xdr_rpc_loc_api_version_s_type (); -extern bool_t xdr_rpc_loc_fix_recurrence_e_type (); -extern bool_t xdr_rpc_loc_operation_mode_e_type (); -extern bool_t xdr_rpc_loc_notify_e_type (); -extern bool_t xdr_rpc_loc_fix_criteria_s_type (); -extern bool_t xdr_rpc_loc_ni_user_resp_e_type (); -extern bool_t xdr_rpc_loc_user_verify_s_type (); -extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type (); -extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type (); -extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (); -extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (); -extern bool_t xdr_rpc_loc_assist_data_time_s_type (); -extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type (); -extern bool_t xdr_rpc_loc_assist_data_pos_s_type (); -extern bool_t xdr_rpc_loc_server_open_status_e_type (); -extern bool_t xdr_rpc_loc_server_pdp_type_e_type (); -extern bool_t xdr_rpc_loc_server_open_status_s_type (); -extern bool_t xdr_rpc_loc_server_multi_open_status_s_type (); -extern bool_t xdr_rpc_loc_server_close_status_e_type (); -extern bool_t xdr_rpc_loc_server_close_status_s_type (); -extern bool_t xdr_rpc_loc_wiper_fix_time_s_type (); -extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type (); -extern bool_t xdr_rpc_loc_wiper_ap_info_s_type (); -extern bool_t xdr_rpc_loc_wiper_ap_set_s_type (); -extern bool_t xdr_rpc_loc_wiper_position_report_s_type (); -extern bool_t xdr_rpc_loc_wiper_status_e_type (); -extern bool_t xdr_rpc_loc_fs_operation_e_type (); -extern bool_t xdr_rpc_loc_efs_data_s_type (); -extern bool_t xdr_rpc_loc_error_estimate_config_e_type (); -extern bool_t xdr_rpc_loc_apn_profiles_type (); -extern bool_t xdr_rpc_loc_lock_e_type (); -extern bool_t xdr_rpc_loc_nmea_sentence_type (); -extern bool_t xdr_rpc_loc_assist_data_type (); -extern bool_t xdr_rpc_loc_assist_data_delete_s_type (); -extern bool_t xdr_rpc_loc_ioctl_data_u_type (); -extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type (); -extern bool_t xdr_rpc_loc_ioctl_callback_s_type (); -extern bool_t xdr_rpc_loc_event_payload_u_type (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_LOC_API_COMMON_RPC_H_RPCGEN */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h deleted file mode 100644 index 6138432e..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h +++ /dev/null @@ -1,288 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * 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 - -#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 */ diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h deleted file mode 100644 index 875c4f08..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h +++ /dev/null @@ -1,34 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -/* Initialization function for callbacks */ -int loc_apicb_app_init(); - -void loc_apicb_app_deinit(); - diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c deleted file mode 100644 index 2ef5852e..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c +++ /dev/null @@ -1,327 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "loc_api_rpcgen_cb_rpc.h" -#include -#include -#include -#include -#include -#include -#include - -#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; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c deleted file mode 100644 index ad171dc4..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c +++ /dev/null @@ -1,60 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * 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; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c deleted file mode 100644 index 3e39576b..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c +++ /dev/null @@ -1,155 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include /* 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)); -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c deleted file mode 100644 index 21be8f43..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c +++ /dev/null @@ -1,1775 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "loc_api_rpcgen_common_rpc.h" - -bool_t -xdr_rpc_loc_client_handle_type (XDR *xdrs, rpc_loc_client_handle_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_int32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_event_mask_type (XDR *xdrs, rpc_loc_event_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_position_valid_mask_type (XDR *xdrs, rpc_loc_position_valid_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_pos_technology_mask_type (XDR *xdrs, rpc_loc_pos_technology_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_session_status_e_type (XDR *xdrs, rpc_loc_session_status_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_calendar_time_s_type (XDR *xdrs, rpc_loc_calendar_time_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint16 (xdrs, &objp->year)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->month)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->day_of_week)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->day)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->hour)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->minute)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->second)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->millisecond)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_parsed_position_s_type (XDR *xdrs, rpc_loc_parsed_position_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_position_valid_mask_type (xdrs, &objp->valid_mask)) - return FALSE; - if (!xdr_rpc_loc_session_status_e_type (xdrs, &objp->session_status)) - return FALSE; - if (!xdr_rpc_loc_calendar_time_s_type (xdrs, &objp->timestamp_calendar)) - return FALSE; - if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->leap_seconds)) - return FALSE; - if (!xdr_float (xdrs, &objp->time_unc)) - return FALSE; - if (!xdr_double (xdrs, &objp->latitude)) - return FALSE; - if (!xdr_double (xdrs, &objp->longitude)) - return FALSE; - if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid)) - return FALSE; - if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level)) - return FALSE; - if (!xdr_float (xdrs, &objp->speed_horizontal)) - return FALSE; - if (!xdr_float (xdrs, &objp->speed_vertical)) - return FALSE; - if (!xdr_float (xdrs, &objp->heading)) - return FALSE; - if (!xdr_float (xdrs, &objp->hor_unc_circular)) - return FALSE; - if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_major)) - return FALSE; - if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_minor)) - return FALSE; - if (!xdr_float (xdrs, &objp->hor_unc_ellipse_orient_azimuth)) - return FALSE; - if (!xdr_float (xdrs, &objp->vert_unc)) - return FALSE; - if (!xdr_float (xdrs, &objp->speed_unc)) - return FALSE; - if (!xdr_float (xdrs, &objp->heading_unc)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->confidence_horizontal)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->confidence_vertical)) - return FALSE; - if (!xdr_float (xdrs, &objp->magnetic_deviation)) - return FALSE; - if (!xdr_rpc_loc_pos_technology_mask_type (xdrs, &objp->technology_mask)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_sv_system_e_type (XDR *xdrs, rpc_loc_sv_system_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_sv_status_e_type (XDR *xdrs, rpc_loc_sv_status_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_sv_info_valid_mask_type (XDR *xdrs, rpc_loc_sv_info_valid_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_sv_info_s_type (XDR *xdrs, rpc_loc_sv_info_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_sv_info_valid_mask_type (xdrs, &objp->valid_mask)) - return FALSE; - if (!xdr_rpc_loc_sv_system_e_type (xdrs, &objp->system)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->prn)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->health_status)) - return FALSE; - if (!xdr_rpc_loc_sv_status_e_type (xdrs, &objp->process_status)) - return FALSE; - if (!xdr_rpc_boolean (xdrs, &objp->has_eph)) - return FALSE; - if (!xdr_rpc_boolean (xdrs, &objp->has_alm)) - return FALSE; - if (!xdr_float (xdrs, &objp->elevation)) - return FALSE; - if (!xdr_float (xdrs, &objp->azimuth)) - return FALSE; - if (!xdr_float (xdrs, &objp->snr)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_gnss_info_valid_mask_type (XDR *xdrs, rpc_loc_gnss_info_valid_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_gnss_info_s_type (XDR *xdrs, rpc_loc_gnss_info_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_gnss_info_valid_mask_type (xdrs, &objp->valid_mask)) - return FALSE; - if (!xdr_float (xdrs, &objp->position_dop)) - return FALSE; - if (!xdr_float (xdrs, &objp->horizontal_dop)) - return FALSE; - if (!xdr_float (xdrs, &objp->vertical_dop)) - return FALSE; - if (!xdr_rpc_boolean (xdrs, &objp->altitude_assumed)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->sv_count)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->sv_list.sv_list_val, (u_int *) &objp->sv_list.sv_list_len, 80, - sizeof (rpc_loc_sv_info_s_type), (xdrproc_t) xdr_rpc_loc_sv_info_s_type)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_nmea_report_s_type (XDR *xdrs, rpc_loc_nmea_report_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_uint16 (xdrs, &objp->length)) - return FALSE; - if (!xdr_opaque (xdrs, objp->nmea_sentences, 200)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_status_event_e_type (XDR *xdrs, rpc_loc_status_event_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_engine_state_e_type (XDR *xdrs, rpc_loc_engine_state_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_fix_session_state_e_type (XDR *xdrs, rpc_loc_fix_session_state_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_status_event_payload_u_type (XDR *xdrs, rpc_loc_status_event_payload_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_STATUS_EVENT_ENGINE_STATE: - if (!xdr_rpc_loc_engine_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.engine_state)) - return FALSE; - break; - case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE: - if (!xdr_rpc_loc_fix_session_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.fix_session_state)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_status_event_s_type (XDR *xdrs, rpc_loc_status_event_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->event)) - return FALSE; - if (!xdr_rpc_loc_status_event_payload_u_type (xdrs, &objp->payload)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_addr_e_type (XDR *xdrs, rpc_loc_server_addr_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_addr_ipv4_type (XDR *xdrs, rpc_loc_server_addr_ipv4_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->addr)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_addr_url_type (XDR *xdrs, rpc_loc_server_addr_url_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_uint16 (xdrs, &objp->length)) - return FALSE; - if (!xdr_opaque (xdrs, objp->addr, 256)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_addr_ipv6_type (XDR *xdrs, rpc_loc_server_addr_ipv6_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_vector (xdrs, (char *)objp->addr, 8, - sizeof (rpc_uint16), (xdrproc_t) xdr_rpc_uint16)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_addr_u_type (XDR *xdrs, rpc_loc_server_addr_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_SERVER_ADDR_IPV4: - if (!xdr_rpc_loc_server_addr_ipv4_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv4)) - return FALSE; - break; - case RPC_LOC_SERVER_ADDR_URL: - if (!xdr_rpc_loc_server_addr_url_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.url)) - return FALSE; - break; - case RPC_LOC_SERVER_ADDR_IPV6: - if (!xdr_rpc_loc_server_addr_ipv6_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv6)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_server_info_s_type (XDR *xdrs, rpc_loc_server_info_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->addr_type)) - return FALSE; - if (!xdr_rpc_loc_server_addr_u_type (xdrs, &objp->addr_info)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_notify_verify_e_type (XDR *xdrs, rpc_loc_ni_notify_verify_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_event_e_type (XDR *xdrs, rpc_loc_ni_event_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_datacoding_scheme_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *xdrs, rpc_loc_ni_vx_pos_mode_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->requester_id_length)) - return FALSE; - if (!xdr_opaque (xdrs, objp->requester_id, 200)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_vx_notify_verify_req_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->pos_qos_incl)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->pos_qos)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->num_fixes)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->tbf)) - return FALSE; - if (!xdr_rpc_loc_ni_vx_pos_mode_e_type (xdrs, &objp->pos_mode)) - return FALSE; - if (!xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (xdrs, &objp->encoding_scheme)) - return FALSE; - if (!xdr_rpc_loc_ni_vx_requester_id_s_type (xdrs, &objp->requester_id)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->user_resp_timer_val)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *xdrs, rpc_loc_ni_supl_pos_method_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *xdrs, rpc_loc_ni_supl_slp_session_id_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->presence)) - return FALSE; - if (!xdr_opaque (xdrs, objp->session_id, 4)) - return FALSE; - if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->slp_address)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_requestor_id_s_type (XDR *xdrs, rpc_loc_ni_requestor_id_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->data_coding_scheme)) - return FALSE; - if (!xdr_opaque (xdrs, objp->requestor_id_string, 200)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->string_len)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_supl_client_name_s_type (XDR *xdrs, rpc_loc_ni_supl_client_name_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->data_coding_scheme)) - return FALSE; - if (!xdr_opaque (xdrs, objp->client_name_string, 64)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->string_len)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_supl_qop_s_type (XDR *xdrs, rpc_loc_ni_supl_qop_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_u_char (xdrs, &objp->bit_mask)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->horacc)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->veracc)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->maxLocAge)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->delay)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_supl_notify_verify_req_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->flags)) - return FALSE; - if (!xdr_rpc_loc_ni_supl_slp_session_id_s_type (xdrs, &objp->supl_slp_session_id)) - return FALSE; - if (!xdr_opaque (xdrs, objp->supl_hash, 8)) - return FALSE; - if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme)) - return FALSE; - if (!xdr_rpc_loc_ni_supl_pos_method_e_type (xdrs, &objp->pos_method)) - return FALSE; - if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id)) - return FALSE; - if (!xdr_rpc_loc_ni_supl_client_name_s_type (xdrs, &objp->client_name)) - return FALSE; - if (!xdr_rpc_loc_ni_supl_qop_s_type (xdrs, &objp->supl_qop)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_ext_client_address_s_type (XDR *xdrs, rpc_loc_ni_ext_client_address_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->ext_client_address_len)) - return FALSE; - if (!xdr_opaque (xdrs, objp->ext_client_address, 20)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_location_type_e_type (XDR *xdrs, rpc_loc_ni_location_type_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_deferred_location_s_type (XDR *xdrs, rpc_loc_ni_deferred_location_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_u_char (xdrs, &objp->unused_bits)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->ms_available)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_codeword_string_s_type (XDR *xdrs, rpc_loc_ni_codeword_string_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_u_char (xdrs, &objp->data_coding_scheme)) - return FALSE; - if (!xdr_opaque (xdrs, objp->lcs_codeword_string, 20)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->string_len)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_service_type_id_s_type (XDR *xdrs, rpc_loc_ni_service_type_id_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_u_char (xdrs, &objp->lcs_service_type_id)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_umts_cp_notify_verify_req_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->invoke_id)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->flags)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->notification_length)) - return FALSE; - if (!xdr_opaque (xdrs, objp->notification_text, 64)) - return FALSE; - if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme)) - return FALSE; - if (!xdr_rpc_loc_ni_ext_client_address_s_type (xdrs, &objp->ext_client_address_data)) - return FALSE; - if (!xdr_rpc_loc_ni_location_type_e_type (xdrs, &objp->location_type)) - return FALSE; - if (!xdr_rpc_loc_ni_deferred_location_s_type (xdrs, &objp->deferred_location)) - return FALSE; - if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id)) - return FALSE; - if (!xdr_rpc_loc_ni_codeword_string_s_type (xdrs, &objp->codeword_string)) - return FALSE; - if (!xdr_rpc_loc_ni_service_type_id_s_type (xdrs, &objp->service_type_id)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_service_interaction_e_type (XDR *xdrs, rpc_loc_ni_service_interaction_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *xdrs, rpc_loc_ni_vx_service_interaction_req_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->ni_vx_req)) - return FALSE; - if (!xdr_rpc_loc_ni_service_interaction_e_type (xdrs, &objp->service_interation_type)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_event_payload_u_type (XDR *xdrs, rpc_loc_ni_event_payload_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ: - if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.vx_req)) - return FALSE; - break; - case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ: - if (!xdr_rpc_loc_ni_supl_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.supl_req)) - return FALSE; - break; - case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ: - if (!xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.umts_cp_req)) - return FALSE; - break; - case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ: - if (!xdr_rpc_loc_ni_vx_service_interaction_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.service_interaction_req)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_event_s_type (XDR *xdrs, rpc_loc_ni_event_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->event)) - return FALSE; - if (!xdr_rpc_loc_ni_event_payload_u_type (xdrs, &objp->payload)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_request_e_type (XDR *xdrs, rpc_loc_assist_data_request_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers_ptr *objp) -{ - register int32_t *buf; - - if (!xdr_string (xdrs, objp, 256)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers objp) -{ - register int32_t *buf; - - if (!xdr_vector (xdrs, (char *)objp, 3, - sizeof (rpc_struct_loc_time_download_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_time_download_source_s_type (XDR *xdrs, rpc_loc_time_download_source_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->delay_threshold)) - return FALSE; - if (!xdr_rpc_struct_loc_time_download_source_s_type_servers (xdrs, objp->servers)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr *objp) -{ - register int32_t *buf; - - if (!xdr_string (xdrs, objp, 256)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers objp) -{ - register int32_t *buf; - - if (!xdr_vector (xdrs, (char *)objp, 3, - sizeof (rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_source_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->max_file_size)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->max_part_size)) - return FALSE; - if (!xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (xdrs, objp->servers)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_pos_inj_request_s_type (XDR *xdrs, rpc_loc_pos_inj_request_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->flags)) - return FALSE; - if (!xdr_double (xdrs, &objp->latitude)) - return FALSE; - if (!xdr_double (xdrs, &objp->longitude)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->position_uncertainty)) - return FALSE; - if (!xdr_rpc_uint64 (xdrs, &objp->timestamp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_request_payload_u_type (XDR *xdrs, rpc_loc_assist_data_request_payload_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_ASSIST_DATA_TIME_REQ: - if (!xdr_rpc_loc_time_download_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.time_download)) - return FALSE; - break; - case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ: - if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.data_download)) - return FALSE; - break; - case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ: - if (!xdr_rpc_loc_pos_inj_request_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.pos_injection)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_request_s_type (XDR *xdrs, rpc_loc_assist_data_request_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->event)) - return FALSE; - if (!xdr_rpc_loc_assist_data_request_payload_u_type (xdrs, &objp->payload)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_connection_handle (XDR *xdrs, rpc_loc_server_connection_handle *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_protocol_e_type (XDR *xdrs, rpc_loc_server_protocol_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_connection_e_type (XDR *xdrs, rpc_loc_server_connection_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_request_e_type (XDR *xdrs, rpc_loc_server_request_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_open_req_s_type (XDR *xdrs, rpc_loc_server_open_req_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_multi_open_req_s_type (XDR *xdrs, rpc_loc_server_multi_open_req_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol)) - return FALSE; - if (!xdr_rpc_loc_server_connection_e_type (xdrs, &objp->connection_type)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_close_req_s_type (XDR *xdrs, rpc_loc_server_close_req_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_request_u_type (XDR *xdrs, rpc_loc_server_request_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_SERVER_REQUEST_OPEN: - if (!xdr_rpc_loc_server_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.open_req)) - return FALSE; - break; - case RPC_LOC_SERVER_REQUEST_CLOSE: - if (!xdr_rpc_loc_server_close_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.close_req)) - return FALSE; - break; - case RPC_LOC_SERVER_REQUEST_MULTI_OPEN: - if (!xdr_rpc_loc_server_multi_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.multi_open_req)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_server_request_s_type (XDR *xdrs, rpc_loc_server_request_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->event)) - return FALSE; - if (!xdr_rpc_loc_server_request_u_type (xdrs, &objp->payload)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_qwip_request_e_type (XDR *xdrs, rpc_loc_qwip_request_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_qwip_request_s_type (XDR *xdrs, rpc_loc_qwip_request_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_qwip_request_e_type (xdrs, &objp->request_type)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->tbf_ms)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_reserved_payload_s_type (XDR *xdrs, rpc_loc_reserved_payload_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint16 (xdrs, &objp->data_size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ioctl_e_type (XDR *xdrs, rpc_loc_ioctl_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_api_version_s_type (XDR *xdrs, rpc_loc_api_version_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_u_char (xdrs, &objp->major)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->minor)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_fix_recurrence_e_type (XDR *xdrs, rpc_loc_fix_recurrence_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_operation_mode_e_type (XDR *xdrs, rpc_loc_operation_mode_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_notify_e_type (XDR *xdrs, rpc_loc_notify_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_fix_criteria_s_type (XDR *xdrs, rpc_loc_fix_criteria_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->valid_mask)) - return FALSE; - if (!xdr_rpc_loc_fix_recurrence_e_type (xdrs, &objp->recurrence_type)) - return FALSE; - if (!xdr_rpc_loc_operation_mode_e_type (xdrs, &objp->preferred_operation_mode)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->preferred_accuracy)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->preferred_response_time)) - return FALSE; - if (!xdr_rpc_boolean (xdrs, &objp->intermediate_pos_report_enabled)) - return FALSE; - if (!xdr_rpc_loc_notify_e_type (xdrs, &objp->notify_type)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->min_interval)) - return FALSE; - if (!xdr_float (xdrs, &objp->min_distance)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->min_dist_sample_interval)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ni_user_resp_e_type (XDR *xdrs, rpc_loc_ni_user_resp_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_user_verify_s_type (XDR *xdrs, rpc_loc_user_verify_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ni_user_resp_e_type (xdrs, &objp->user_resp)) - return FALSE; - if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->ni_event_pass_back)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *xdrs, rpc_loc_predicted_orbits_data_format_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_predicted_orbits_data_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_predicted_orbits_data_format_e_type (xdrs, &objp->format_type)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->total_size)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->total_parts)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->part)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->part_len)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_validity_report_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint64 (xdrs, &objp->start_time_utc)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->valid_duration_hrs)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *xdrs, rpc_loc_predicted_orbits_auto_download_config_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_boolean (xdrs, &objp->enable)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->auto_check_every_hrs)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_time_s_type (XDR *xdrs, rpc_loc_assist_data_time_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint64 (xdrs, &objp->time_utc)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->uncertainty)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_pos_valid_mask_type (XDR *xdrs, rpc_loc_assist_pos_valid_mask_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_pos_s_type (XDR *xdrs, rpc_loc_assist_data_pos_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_assist_pos_valid_mask_type (xdrs, &objp->valid_mask)) - return FALSE; - if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc)) - return FALSE; - if (!xdr_double (xdrs, &objp->latitude)) - return FALSE; - if (!xdr_double (xdrs, &objp->longitude)) - return FALSE; - if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid)) - return FALSE; - if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level)) - return FALSE; - if (!xdr_float (xdrs, &objp->hor_unc_circular)) - return FALSE; - if (!xdr_float (xdrs, &objp->vert_unc)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->confidence_horizontal)) - return FALSE; - if (!xdr_u_char (xdrs, &objp->confidence_vertical)) - return FALSE; - if (!xdr_rpc_int32 (xdrs, &objp->timestamp_age)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_open_status_e_type (XDR *xdrs, rpc_loc_server_open_status_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_pdp_type_e_type (XDR *xdrs, rpc_loc_server_pdp_type_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_open_status_s_type (XDR *xdrs, rpc_loc_server_open_status_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status)) - return FALSE; - if (!xdr_opaque (xdrs, objp->apn_name, 100)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_multi_open_status_s_type (XDR *xdrs, rpc_loc_server_multi_open_status_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status)) - return FALSE; - if (!xdr_rpc_loc_server_pdp_type_e_type (xdrs, &objp->pdp_type)) - return FALSE; - if (!xdr_opaque (xdrs, objp->apn_name, 100)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_close_status_e_type (XDR *xdrs, rpc_loc_server_close_status_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_server_close_status_s_type (XDR *xdrs, rpc_loc_server_close_status_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle)) - return FALSE; - if (!xdr_rpc_loc_server_close_status_e_type (xdrs, &objp->close_status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_fix_time_s_type (XDR *xdrs, rpc_loc_wiper_fix_time_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, &objp->slow_clock_count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_fix_pos_s_type (XDR *xdrs, rpc_loc_wiper_fix_pos_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_int32 (xdrs, &objp->lat)) - return FALSE; - if (!xdr_rpc_int32 (xdrs, &objp->lon)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->HEPE)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps_used)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->fix_error_code)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_ap_info_s_type (XDR *xdrs, rpc_loc_wiper_ap_info_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_opaque (xdrs, objp->mac_addr, 6)) - return FALSE; - if (!xdr_rpc_int32 (xdrs, &objp->rssi)) - return FALSE; - if (!xdr_rpc_uint16 (xdrs, &objp->channel)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->ap_qualifier)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_ap_set_s_type (XDR *xdrs, rpc_loc_wiper_ap_set_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->ap_info, 50, - sizeof (rpc_loc_wiper_ap_info_s_type), (xdrproc_t) xdr_rpc_loc_wiper_ap_info_s_type)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_position_report_s_type (XDR *xdrs, rpc_loc_wiper_position_report_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint8 (xdrs, &objp->wiper_valid_info_flag)) - return FALSE; - if (!xdr_rpc_loc_wiper_fix_time_s_type (xdrs, &objp->wiper_fix_time)) - return FALSE; - if (!xdr_rpc_loc_wiper_fix_pos_s_type (xdrs, &objp->wiper_fix_position)) - return FALSE; - if (!xdr_rpc_loc_wiper_ap_set_s_type (xdrs, &objp->wiper_ap_set)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_wiper_status_e_type (XDR *xdrs, rpc_loc_wiper_status_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_fs_operation_e_type (XDR *xdrs, rpc_loc_fs_operation_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_efs_data_s_type (XDR *xdrs, rpc_loc_efs_data_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_opaque (xdrs, objp->filename, 64)) - return FALSE; - if (!xdr_rpc_loc_fs_operation_e_type (xdrs, &objp->operation)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->total_size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->part_len)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->part)) - return FALSE; - if (!xdr_rpc_uint8 (xdrs, &objp->total_parts)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->reserved)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_error_estimate_config_e_type (XDR *xdrs, rpc_loc_error_estimate_config_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_apn_profiles_type (XDR *xdrs, rpc_loc_apn_profiles_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_uint32 (xdrs, &objp->srv_system_type)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->pdp_type)) - return FALSE; - if (!xdr_rpc_uint32 (xdrs, &objp->reserved)) - return FALSE; - if (!xdr_opaque (xdrs, objp->apn_name, 100)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_lock_e_type (XDR *xdrs, rpc_loc_lock_e_type *objp) -{ - register int32_t *buf; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_nmea_sentence_type (XDR *xdrs, rpc_loc_nmea_sentence_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_type (XDR *xdrs, rpc_loc_assist_data_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_assist_data_delete_s_type (XDR *xdrs, rpc_loc_assist_data_delete_s_type *objp) -{ - register int32_t *buf; - - int i; - if (!xdr_rpc_loc_assist_data_type (xdrs, &objp->type)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->reserved, 8, - sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_ioctl_data_u_type (XDR *xdrs, rpc_loc_ioctl_data_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_IOCTL_SET_FIX_CRITERIA: - if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.fix_criteria)) - return FALSE; - break; - case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE: - if (!xdr_rpc_loc_user_verify_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.user_verify_resp)) - return FALSE; - break; - case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA: - if (!xdr_rpc_loc_predicted_orbits_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_data)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD: - if (!xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_auto_download)) - return FALSE; - break; - case RPC_LOC_IOCTL_INJECT_UTC_TIME: - if (!xdr_rpc_loc_assist_data_time_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_time)) - return FALSE; - break; - case RPC_LOC_IOCTL_INJECT_POSITION: - if (!xdr_rpc_loc_assist_data_pos_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_position)) - return FALSE; - break; - case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS: - if (!xdr_rpc_loc_server_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_open_status)) - return FALSE; - break; - case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS: - if (!xdr_rpc_loc_server_close_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_close_status)) - return FALSE; - break; - case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT: - if (!xdr_rpc_loc_wiper_position_report_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_pos)) - return FALSE; - break; - case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS: - if (!xdr_rpc_loc_wiper_status_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_status)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_ENGINE_LOCK: - if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.engine_lock)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_SBAS_CONFIG: - if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.sbas_mode)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_NMEA_TYPES: - if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.nmea_types)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM: - if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.on_demand_lpm)) - return FALSE; - 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: - if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.server_addr)) - return FALSE; - break; - case RPC_LOC_IOCTL_DELETE_ASSIST_DATA: - if (!xdr_rpc_loc_assist_data_delete_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assist_data_delete)) - return FALSE; - break; - case RPC_LOC_IOCTL_ACCESS_EFS_DATA: - if (!xdr_rpc_loc_efs_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.efs_data)) - return FALSE; - break; - case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG: - if (!xdr_rpc_loc_error_estimate_config_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.error_estimate_config)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL: - if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.xtra_t_session_control)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE: - case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE: - if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_data_u_type_u.apn_profiles, 6, - sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_DATA_ENABLE: - if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.data_enable)) - return FALSE; - break; - case RPC_LOC_IOCTL_SET_SUPL_VERSION: - if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.supl_version)) - return FALSE; - break; - case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS: - if (!xdr_rpc_loc_server_multi_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.multi_conn_open_status)) - return FALSE; - break; - case RPC_LOC_IOCTL_RESERVED_CMD: - if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.reserved)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_ioctl_callback_data_u_type (XDR *xdrs, rpc_loc_ioctl_callback_data_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_IOCTL_GET_API_VERSION: - if (!xdr_rpc_loc_api_version_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.api_version)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_FIX_CRITERIA: - if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.fix_criteria)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_ENGINE_LOCK: - if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.engine_lock)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_SBAS_CONFIG: - if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.sbas_mode)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_NMEA_TYPES: - if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.nmea_types)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM: - if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.on_demand_lpm)) - return FALSE; - 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: - if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.server_addr)) - return FALSE; - break; - case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE: - if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_source)) - return FALSE; - break; - case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY: - if (!xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_validity)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL: - if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.xtra_t_session_control)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE: - case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE: - if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_callback_data_u_type_u.apn_profiles, 6, - sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type)) - return FALSE; - break; - case RPC_LOC_IOCTL_GET_SUPL_VERSION: - if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.supl_version)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_rpc_loc_ioctl_callback_s_type (XDR *xdrs, rpc_loc_ioctl_callback_s_type *objp) -{ - register int32_t *buf; - - if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->type)) - return FALSE; - if (!xdr_rpc_int32 (xdrs, &objp->status)) - return FALSE; - if (!xdr_rpc_loc_ioctl_callback_data_u_type (xdrs, &objp->data)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_loc_event_payload_u_type (XDR *xdrs, rpc_loc_event_payload_u_type *objp) -{ - register int32_t *buf; - - if (!xdr_u_quad_t (xdrs, &objp->disc)) - return FALSE; - switch (objp->disc) { - case RPC_LOC_EVENT_PARSED_POSITION_REPORT: - if (!xdr_rpc_loc_parsed_position_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.parsed_location_report)) - return FALSE; - break; - case RPC_LOC_EVENT_SATELLITE_REPORT: - if (!xdr_rpc_loc_gnss_info_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.gnss_report)) - return FALSE; - break; - case RPC_LOC_EVENT_NMEA_POSITION_REPORT: - case RPC_LOC_EVENT_NMEA_1HZ_REPORT: - if (!xdr_rpc_loc_nmea_report_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.nmea_report)) - return FALSE; - break; - case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST: - if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ni_request)) - return FALSE; - break; - case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST: - if (!xdr_rpc_loc_assist_data_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.assist_data_request)) - return FALSE; - break; - case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST: - if (!xdr_rpc_loc_server_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.loc_server_request)) - return FALSE; - break; - case RPC_LOC_EVENT_IOCTL_REPORT: - if (!xdr_rpc_loc_ioctl_callback_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ioctl_report)) - return FALSE; - break; - case RPC_LOC_EVENT_STATUS_REPORT: - if (!xdr_rpc_loc_status_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.status_report)) - return FALSE; - break; - case RPC_LOC_EVENT_WPS_NEEDED_REQUEST: - if (!xdr_rpc_loc_qwip_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.qwip_request)) - return FALSE; - break; - case RPC_LOC_EVENT_RESERVED: - if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.reserved)) - return FALSE; - break; - default: - break; - } - return TRUE; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c deleted file mode 100644 index a0fdcabe..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c +++ /dev/null @@ -1,199 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* - * 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; -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c deleted file mode 100644 index b469eb0a..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c +++ /dev/null @@ -1,74 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#include "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); -} diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr deleted file mode 100644 index 82dca569..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr +++ /dev/null @@ -1,261 +0,0 @@ -/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* 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; diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr deleted file mode 100644 index 4756c6c5..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr +++ /dev/null @@ -1,187 +0,0 @@ -/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* 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; diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr deleted file mode 100644 index e059c661..00000000 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr +++ /dev/null @@ -1,1021 +0,0 @@ -/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -/* LOC_API TOOL VERSION: 4.48 */ -/* GENERATED: TUE JUN 14 2011 */ -/*============================================================================= - 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. - - --------------------------------------------------------------------------- - - - --------------------------------------------------------------------------- -=============================================================================*/ - -/*============================================================================= - - 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$ -=============================================================================*/ - - - -const LOC_API_TOOLVERS = 0x00040030; -const LOC_API_FEATURES = 0x00000001; - -const RPC_LOC_EVENT_STATUS_REPORT = 0x00000100; - -const RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST = 0x00000020; - -const RPC_LOC_EVENT_WPS_NEEDED_REQUEST = 0x00000200; - -const RPC_LOC_EVENT_SATELLITE_REPORT = 0x00000002; - -const RPC_LOC_EVENT_PARSED_POSITION_REPORT = 0x00000001; - -const RPC_LOC_EVENT_RESERVED = 0x8000000000000000; - -const RPC_LOC_EVENT_LOCATION_SERVER_REQUEST = 0x00000040; - -const RPC_LOC_EVENT_NMEA_POSITION_REPORT = 0x00000008; - -const RPC_LOC_EVENT_IOCTL_REPORT = 0x00000080; - -const RPC_LOC_EVENT_NMEA_1HZ_REPORT = 0x00000004; - -const RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST = 0x00000010; - -const RPC_LOC_API_CB_NULL_VERSION = 0x00050002; -const RPC_LOC_EVENT_CB_F_TYPE_VERSION = 0x00050001; -const RPC_LOC_API_API_VERSIONS_VERSION = 0x00050001; -const RPC_LOC_STOP_FIX_VERSION = 0x00050001; -const RPC_LOC_START_FIX_VERSION = 0x00050001; -const RPC_LOC_IOCTL_VERSION = 0x00050001; -const RPC_LOC_CLOSE_VERSION = 0x00050001; -const RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION = 0x00050001; -const RPC_LOC_OPEN_VERSION = 0x00050001; -const RPC_LOC_API_NULL_VERSION = 0x00050001; -const RPC_LOC_API_API_MAJOR_NUM = 0x0005; -const RPC_LOC_APIAPI_VERSION_IS_HASHKEY = 0; - -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[200]; -}; - -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_IPV6 = 3, - 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]; -}; - -struct rpc_loc_server_addr_ipv6_type { - rpc_uint16 addr[8]; - rpc_uint32 port; -}; - -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; - case RPC_LOC_SERVER_ADDR_IPV6: - rpc_loc_server_addr_ipv6_type ipv6; - 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]; -}; - -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[200]; - unsigned char string_len; -}; - -struct rpc_loc_ni_supl_client_name_s_type { - unsigned char data_coding_scheme; - opaque client_name_string[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]; - 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]; -}; - -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]; - 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]; - 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_POSITION_INJECTION_REQ = 3, - 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]; - -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; - -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; -}; - -struct rpc_loc_pos_inj_request_s_type { - rpc_uint32 flags; - double latitude; - double longitude; - rpc_uint32 position_uncertainty; - rpc_uint64 timestamp; -}; - -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; - case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ: - rpc_loc_pos_inj_request_s_type pos_injection; - 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_connection_e_type { - RPC_LOC_SERVER_CONNECTION_LBS = 0, - RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET, - RPC_LOC_SERVER_CONNECTION_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_MULTI_OPEN = 3, - 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_multi_open_req_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_protocol_e_type protocol; - rpc_loc_server_connection_e_type connection_type; -}; - -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; - case RPC_LOC_SERVER_REQUEST_MULTI_OPEN: - rpc_loc_server_multi_open_req_s_type multi_open_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_ERROR_ESTIMATE_CONFIG = 414, - RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415, - 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_SET_XTRA_T_SESSION_CONTROL = 814, - RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815, - RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816, - RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817, - RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818, - RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819, - RPC_LOC_IOCTL_SET_DATA_ENABLE = 820, - RPC_LOC_IOCTL_SET_SUPL_VERSION = 821, - RPC_LOC_IOCTL_GET_SUPL_VERSION = 822, - 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_RESERVED_CMD = 8000, - 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 -}; - -enum rpc_loc_server_pdp_type_e_type { - RPC_LOC_SERVER_PDP_IP = 0, - RPC_LOC_SERVER_PDP_PPP, - RPC_LOC_SERVER_PDP_IPV6, - RPC_LOC_SERVER_PDP_IPV4V6, - RPC_LOC_SERVER_PDP_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]; -}; - -struct rpc_loc_server_multi_open_status_s_type { - rpc_loc_server_connection_handle conn_handle; - rpc_loc_server_open_status_e_type open_status; - rpc_loc_server_pdp_type_e_type pdp_type; - opaque apn_name[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]; - 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]; -}; - -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]; - 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_error_estimate_config_e_type { - RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1, - RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2, - RPC_LOC_ERROR_ESTIMATE_MAX = 268435456 -}; - -struct rpc_loc_apn_profiles_type { - rpc_uint32 srv_system_type; - rpc_uint32 pdp_type; - rpc_uint32 reserved; - opaque apn_name[100]; -}; - -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_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; - case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG: - rpc_loc_error_estimate_config_e_type error_estimate_config; - case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL: - rpc_uint8 xtra_t_session_control; - case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE: - case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE: - rpc_loc_apn_profiles_type apn_profiles[6]; - case RPC_LOC_IOCTL_SET_DATA_ENABLE: - rpc_boolean data_enable; - case RPC_LOC_IOCTL_SET_SUPL_VERSION: - rpc_uint32 supl_version; - case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS: - rpc_loc_server_multi_open_status_s_type multi_conn_open_status; - case RPC_LOC_IOCTL_RESERVED_CMD: - rpc_loc_reserved_payload_s_type reserved; - 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; - case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL: - rpc_uint8 xtra_t_session_control; - case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE: - case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE: - rpc_loc_apn_profiles_type apn_profiles[6]; - case RPC_LOC_IOCTL_GET_SUPL_VERSION: - rpc_uint32 supl_version; - 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: - case RPC_LOC_EVENT_NMEA_1HZ_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; -}; - diff --git a/loc_api/libloc_api_50001/Android.mk b/loc_api/libloc_api_50001/Android.mk deleted file mode 100644 index c33bc915..00000000 --- a/loc_api/libloc_api_50001/Android.mk +++ /dev/null @@ -1,116 +0,0 @@ -ifneq ($(BUILD_TINY_ANDROID),true) -#Compile this library only for builds with the latest modem image - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libloc_eng -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -LOCAL_SHARED_LIBRARIES := \ - libutils \ - libcutils \ - libdl \ - liblog \ - libloc_core \ - libgps.utils \ - libloc_pla - -LOCAL_SRC_FILES += \ - loc.cpp \ - loc_eng.cpp \ - loc_eng_agps.cpp \ - loc_eng_xtra.cpp \ - loc_eng_ni.cpp \ - loc_eng_log.cpp \ - loc_eng_nmea.cpp \ - LocEngAdapter.cpp - -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 \ - $(TARGET_OUT_HEADERS)/libloc_core \ - hardware/qcom/gps/loc_api/libloc_api_50001 \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla - -LOCAL_COPY_HEADERS_TO:= libloc_eng/ -LOCAL_COPY_HEADERS:= \ - LocEngAdapter.h \ - loc.h \ - loc_eng.h \ - loc_eng_xtra.h \ - loc_eng_ni.h \ - loc_eng_agps.h \ - loc_eng_msg.h \ - loc_eng_log.h - -LOCAL_PRELINK_MODULE := false - -include $(BUILD_SHARED_LIBRARY) - -include $(CLEAR_VARS) - -LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE) -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -## Libs - -LOCAL_SHARED_LIBRARIES := \ - libutils \ - libcutils \ - liblog \ - libloc_eng \ - libloc_core \ - libgps.utils \ - libdl \ - libloc_pla - -ifneq ($(filter $(TARGET_DEVICE), apq8084 msm8960), false) -endif - -LOCAL_SRC_FILES += \ - gps_interface.cpp \ - gps_converter.cpp \ - gps.c - -LOCAL_CFLAGS += \ - -fno-short-enums \ - -D_ANDROID_ \ - -ifeq ($(TARGET_BUILD_VARIANT),user) - LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER -endif - -ifeq ($(TARGET_USES_QCOM_BSP), true) -LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP -endif - -## Includes -LOCAL_C_INCLUDES:= \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libloc_core \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla - -LOCAL_PRELINK_MODULE := false -LOCAL_MODULE_RELATIVE_PATH := hw - -include $(BUILD_SHARED_LIBRARY) - -endif # not BUILD_TINY_ANDROID diff --git a/loc_api/libloc_api_50001/LocEngAdapter.cpp b/loc_api/libloc_api_50001/LocEngAdapter.cpp deleted file mode 100644 index c312a24e..00000000 --- a/loc_api/libloc_api_50001/LocEngAdapter.cpp +++ /dev/null @@ -1,606 +0,0 @@ -/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_EngAdapter" - -#include -#include -#include -#include -#include -#include "loc_eng_msg.h" -#include "loc_log.h" - -#define CHIPSET_SERIAL_NUMBER_MAX_LEN 16 -#define USER_AGENT_MAX_LEN 512 - -using namespace loc_core; - -LocInternalAdapter::LocInternalAdapter(LocEngAdapter* adapter) : - LocAdapterBase(adapter->getMsgTask()), - mLocEngAdapter(adapter) -{ -} -void LocInternalAdapter::setPositionModeInt(LocPosMode& posMode) { - sendMsg(new LocEngPositionMode(mLocEngAdapter, posMode)); -} -void LocInternalAdapter::startFixInt() { - sendMsg(new LocEngStartFix(mLocEngAdapter)); -} -void LocInternalAdapter::stopFixInt() { - sendMsg(new LocEngStopFix(mLocEngAdapter)); -} -void LocInternalAdapter::getZppInt() { - sendMsg(new LocEngGetZpp(mLocEngAdapter)); -} - -LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, - void* owner, ContextBase* context, - LocThread::tCreate tCreator) : - LocAdapterBase(mask, - //Get the AFW context if VzW context has not already been intialized in - //loc_ext - context == NULL? - LocDualContext::getLocFgContext(tCreator, - NULL, - LocDualContext::mLocationHalName, - false) - :context), - mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)), - mUlp(new UlpProxyBase()), mNavigating(false), - mSupportsAgpsRequests(false), - mSupportsPositionInjection(false), - mSupportsTimeInjection(false), - mPowerVote(0) -{ - memset(&mFixCriteria, 0, sizeof(mFixCriteria)); - mFixCriteria.mode = LOC_POSITION_MODE_INVALID; - clearGnssSvUsedListData(); - LOC_LOGD("LocEngAdapter created"); -} - -inline -LocEngAdapter::~LocEngAdapter() -{ - delete mInternalAdapter; - LOC_LOGV("LocEngAdapter deleted"); -} - -void LocEngAdapter::setXtraUserAgent() { - struct LocSetXtraUserAgent : public LocMsg { - const ContextBase* const mContext; - inline LocSetXtraUserAgent(ContextBase* context) : - LocMsg(), mContext(context) { - } - virtual void proc() const { - char release[PROPERTY_VALUE_MAX]; - char manufacture[PROPERTY_VALUE_MAX]; - char model[PROPERTY_VALUE_MAX]; - char board[PROPERTY_VALUE_MAX]; - char brand[PROPERTY_VALUE_MAX]; - char chipsetsn[CHIPSET_SERIAL_NUMBER_MAX_LEN]; - char userAgent[USER_AGENT_MAX_LEN]; - const char defVal[] = "-"; - - property_get("ro.build.version.release", release, defVal); - property_get("ro.product.manufacturer", manufacture, defVal); - property_get("ro.product.model", model, defVal); - property_get("ro.product.board", board, defVal); - property_get("ro.product.brand", brand, defVal); - getChipsetSerialNo(chipsetsn, sizeof(chipsetsn), defVal); - - encodeInPlace(release, PROPERTY_VALUE_MAX); - encodeInPlace(manufacture, PROPERTY_VALUE_MAX); - encodeInPlace(model, PROPERTY_VALUE_MAX); - encodeInPlace(board, PROPERTY_VALUE_MAX); - encodeInPlace(brand, PROPERTY_VALUE_MAX); - - snprintf(userAgent, sizeof(userAgent), "A/%s/%s/%s/%s/-/QCX3/s%u/-/%s/-/%s/-/-/-", - release, manufacture, model, board, - mContext->getIzatDevId(), chipsetsn, brand); - - for (int i = 0; i < sizeof(userAgent) && userAgent[i]; i++) { - if (' ' == userAgent[i]) userAgent[i] = '#'; - } - - saveUserAgentString(userAgent, strlen(userAgent)); - LOC_LOGV("%s] UserAgent %s", __func__, userAgent); - } - - void saveUserAgentString(const char* data, const int len) const { - const char XTRA_FOLDER[] = "/data/misc/location/xtra"; - const char USER_AGENT_FILE[] = "/data/misc/location/xtra/useragent.txt"; - - if (data == NULL || len < 1) { - LOC_LOGE("%s:%d]: invalid input data = %p len = %d", __func__, __LINE__, data, len); - return; - } - - struct stat s; - int err = stat(XTRA_FOLDER, &s); - if (err < 0) { - if (ENOENT == errno) { - if (mkdir(XTRA_FOLDER, 0700) < 0) { - LOC_LOGE("%s:%d]: make XTRA_FOLDER failed", __func__, __LINE__); - return; - } - } else { - LOC_LOGE("%s:%d]: XTRA_FOLDER invalid", __func__, __LINE__); - return; - } - } - - FILE* file = fopen(USER_AGENT_FILE, "wt"); - if (file == NULL) { - LOC_LOGE("%s:%d]: open USER_AGENT_FILE failed", __func__, __LINE__); - return; - } - - size_t written = fwrite(data, 1, len, file); - fclose(file); - file = NULL; - - // set file permission - chmod(USER_AGENT_FILE, 0600); - - if (written != len) { - LOC_LOGE("%s:%d]: write USER_AGENT_FILE failed", __func__, __LINE__); - } - } - - void getChipsetSerialNo(char buf[], int buflen, const char def[]) const { - const char SOC_SERIAL_NUMBER[] = "/sys/devices/soc0/serial_number"; - - FILE* file = fopen(SOC_SERIAL_NUMBER, "rt"); - if (file == NULL) { - // use default upon unreadable file - strlcpy(buf, def, buflen); - - } else { - size_t size = fread(buf, 1, buflen - 1, file); - if (size == 0) { - // use default upon empty file - strlcpy(buf, def, buflen); - - } else { - buf[size] = '\0'; - } - - fclose(file); - - // remove trailing spaces - size_t len = strlen(buf); - while (--len >= 0 && isspace(buf[len])) { - buf[len] = '\0'; - } - } - - return; - } - - /** - * encode the given string value such that all separator characters ('/','+','|','%') - * in the string are repaced by their corresponding encodings (%2F","%2B","%7C", "%25") - */ - static void encodeInPlace(char value[], const int size) { - char buffer[size]; - - struct ENCODE { - const char ch; - const char *code; - }; - - const ENCODE encodings[] = { {'/', "%2F"}, {'+', "%2B"}, {'|', "%7C",}, {'%', "%25"} }; - const int nencodings = (int)sizeof(encodings) / sizeof(encodings[0]); - - int inpos = 0, outpos = 0; - while(value[inpos] != '\0' && outpos < size - 1) { - // check if escaped character - int escchar = 0; - while(escchar < nencodings && encodings[escchar].ch != value[inpos]) { - escchar++; - } - - if (escchar == nencodings) { - // non escaped character - buffer[outpos++] = value[inpos++]; - continue; - } - - // escaped character - int codepos = 0; - #define NUM_CHARS_IN_CODE 3 - - if (outpos + NUM_CHARS_IN_CODE >= size) { - // skip last character if there is insufficient space - break; - } - - while(outpos < size - 1 && codepos < NUM_CHARS_IN_CODE) { - buffer[outpos++] = encodings[escchar].code[codepos++]; - } - inpos++; - } - - // copy to ouput - value[outpos] = '\0'; - while(--outpos >= 0) { - value[outpos] = buffer[outpos]; - } - } - }; - - sendMsg(new LocSetXtraUserAgent(mContext)); -} - -void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) { - struct LocSetUlpProxy : public LocMsg { - LocAdapterBase* mAdapter; - UlpProxyBase* mUlp; - inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) : - LocMsg(), mAdapter(adapter), mUlp(ulp) { - } - virtual void proc() const { - LOC_LOGV("%s] ulp %p adapter %p", __func__, - mUlp, mAdapter); - mAdapter->setUlpProxy(mUlp); - } - }; - - sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp)); -} - -void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp) -{ - if (ulp == mUlp) { - //This takes care of the case when double initalization happens - //and we get the same object back for UlpProxyBase . Do nothing - return; - } - - LOC_LOGV("%s] %p", __func__, ulp); - if (NULL == ulp) { - LOC_LOGE("%s:%d]: ulp pointer is NULL", __func__, __LINE__); - ulp = new UlpProxyBase(); - } - - if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) { - // need to send this mode and start msg to ULP - ulp->sendFixMode(mUlp->mPosMode); - } - - if(mUlp->mFixSet) { - ulp->sendStartFix(); - } - - delete mUlp; - mUlp = ulp; -} - -int LocEngAdapter::setGpsLockMsg(LOC_GPS_LOCK_MASK lockMask) -{ - struct LocEngAdapterGpsLock : public LocMsg { - LocEngAdapter* mAdapter; - LOC_GPS_LOCK_MASK mLockMask; - inline LocEngAdapterGpsLock(LocEngAdapter* adapter, LOC_GPS_LOCK_MASK lockMask) : - LocMsg(), mAdapter(adapter), mLockMask(lockMask) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setGpsLock(mLockMask); - } - inline void locallog() const { - LOC_LOGV("LocEngAdapterGpsLock - mLockMask: %x", mLockMask); - } - inline virtual void log() const { - locallog(); - } - }; - sendMsg(new LocEngAdapterGpsLock(this, lockMask)); - return 0; -} - -void LocEngAdapter::requestPowerVote() -{ - if (getPowerVoteRight()) { - /* Power voting without engine lock: - * 101: vote down, 102-104 - vote up - * These codes are used not to confuse with actual engine lock - * functionality, that can't be used in SSR scenario, as it - * conflicts with initialization sequence. - */ - bool powerUp = getPowerVote(); - LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d", (int)powerUp); - setGpsLock(powerUp ? 103 : 101); - } -} - -void LocInternalAdapter::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) -{ - sendMsg(new LocEngReportPosition(mLocEngAdapter, - location, - locationExtended, - locationExt, - status, - loc_technology_mask)); -} - - -void LocEngAdapter::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) -{ - if (! mUlp->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask )) { - mInternalAdapter->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask); - } -} - -void LocInternalAdapter::reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt){ - sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus, - locationExtended, svExt)); -} - -void LocEngAdapter::reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) -{ - - // We want to send SV info to ULP to help it in determining GNSS - // signal strength ULP will forward the SV reports to HAL without - // any modifications - if (! mUlp->reportSv(svStatus, locationExtended, svExt)) { - mInternalAdapter->reportSv(svStatus, locationExtended, svExt); - } -} - - -void LocEngAdapter::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) -{ - // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. - if (! mUlp->reportSvMeasurement(svMeasurementSet)) { - //Send to Internal Adapter later if needed by LA - } -} - -void LocEngAdapter::reportSvPolynomial(GnssSvPolynomial &svPolynomial) -{ - // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. - if (! mUlp->reportSvPolynomial(svPolynomial)) { - //Send to Internal Adapter later if needed by LA - } -} - -void LocEngAdapter::setInSession(bool inSession) -{ - mNavigating = inSession; - mLocApi->setInSession(inSession); - if (!mNavigating) { - mFixCriteria.mode = LOC_POSITION_MODE_INVALID; - } -} - -void LocInternalAdapter::reportStatus(LocGpsStatusValue status) -{ - sendMsg(new LocEngReportStatus(mLocEngAdapter, status)); -} - -void LocEngAdapter::reportStatus(LocGpsStatusValue status) -{ - if (!mUlp->reportStatus(status)) { - mInternalAdapter->reportStatus(status); - } -} - -void LocInternalAdapter::reportNmea(const char* nmea, int length) -{ - sendMsg(new LocEngReportNmea(mLocEngAdapter->getOwner(), nmea, length)); -} - -inline void LocEngAdapter::reportNmea(const char* nmea, int length) -{ - if (!mUlp->reportNmea(nmea, length)) { - //Report it to HAL - mInternalAdapter->reportNmea(nmea, length); - } -} - -inline -bool LocEngAdapter::reportXtraServer(const char* url1, - const char* url2, - const char* url3, - const int maxlength) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngReportXtraServer(mOwner, url1, - url2, url3, maxlength)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestATL(int connHandle, LocAGpsType agps_type) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestATL(mOwner, - connHandle, agps_type)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::releaseATL(int connHandle) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngReleaseATL(mOwner, connHandle)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestXtraData() -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestXtra(mOwner)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestTime() -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestTime(mOwner)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestNiNotify(LocGpsNiNotification ¬if, const void* data) -{ - if (mSupportsAgpsRequests) { - notif.size = sizeof(notif); - notif.timeout = LOC_NI_NO_RESPONSE_TIME; - - sendMsg(new LocEngRequestNi(mOwner, notif, data)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestSuplES(int connHandle) -{ - if (mSupportsAgpsRequests) - sendMsg(new LocEngRequestSuplEs(mOwner, connHandle)); - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::reportDataCallOpened() -{ - if(mSupportsAgpsRequests) - sendMsg(new LocEngSuplEsOpened(mOwner)); - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::reportDataCallClosed() -{ - if(mSupportsAgpsRequests) - sendMsg(new LocEngSuplEsClosed(mOwner)); - return mSupportsAgpsRequests; -} - -inline -void LocEngAdapter::handleEngineDownEvent() -{ - sendMsg(new LocEngDown(mOwner)); -} - -inline -void LocEngAdapter::handleEngineUpEvent() -{ - sendMsg(new LocEngUp(mOwner)); -} - -enum loc_api_adapter_err LocEngAdapter::setTime(LocGpsUtcTime time, - int64_t timeReference, - int uncertainty) -{ - loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS; - - LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d", - __func__, __LINE__, mSupportsTimeInjection); - - if (mSupportsTimeInjection) { - LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__); - result = mLocApi->setTime(time, timeReference, uncertainty); - } - - return result; -} - -enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check) -{ - enum loc_api_adapter_err ret; - ENTRY_LOG(); - enum xtra_version_check eCheck; - switch (check) { - case 0: - eCheck = DISABLED; - break; - case 1: - eCheck = AUTO; - break; - case 2: - eCheck = XTRA2; - break; - case 3: - eCheck = XTRA3; - break; - default: - eCheck = DISABLED; - } - ret = mLocApi->setXtraVersionCheck(eCheck); - EXIT_LOG(%d, ret); - return ret; -} - -void LocEngAdapter::reportGnssMeasurementData(LocGnssData &gnssMeasurementData) -{ - sendMsg(new LocEngReportGnssMeasurement(mOwner, - gnssMeasurementData)); -} - -/* - Set Gnss Constellation Config - */ -bool LocEngAdapter::gnssConstellationConfig() -{ - LOC_LOGD("entering %s", __func__); - bool result = false; - result = mLocApi->gnssConstellationConfig(); - return result; -} diff --git a/loc_api/libloc_api_50001/LocEngAdapter.h b/loc_api/libloc_api_50001/LocEngAdapter.h deleted file mode 100644 index e341651d..00000000 --- a/loc_api/libloc_api_50001/LocEngAdapter.h +++ /dev/null @@ -1,380 +0,0 @@ -/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_API_ENG_ADAPTER_H -#define LOC_API_ENG_ADAPTER_H - -#include -#include -#include -#include -#include -#include -#include - -#define MAX_URL_LEN 256 - -using namespace loc_core; - -class LocEngAdapter; - -class LocInternalAdapter : public LocAdapterBase { - LocEngAdapter* mLocEngAdapter; -public: - LocInternalAdapter(LocEngAdapter* adapter); - - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportStatus(LocGpsStatusValue status); - virtual void setPositionModeInt(LocPosMode& posMode); - virtual void startFixInt(); - virtual void stopFixInt(); - virtual void getZppInt(); - virtual void setUlpProxy(UlpProxyBase* ulp); - virtual void reportNmea(const char* nmea, int length); -}; - -typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp); - -class LocEngAdapter : public LocAdapterBase { - void* mOwner; - LocInternalAdapter* mInternalAdapter; - UlpProxyBase* mUlp; - LocPosMode mFixCriteria; - bool mNavigating; - // mPowerVote is encoded as - // mPowerVote & 0x20 -- powerVoteRight - // mPowerVote & 0x10 -- power On / Off - unsigned int mPowerVote; - static const unsigned int POWER_VOTE_RIGHT = 0x20; - static const unsigned int POWER_VOTE_VALUE = 0x10; - /** Gnss sv used in position data */ - GnssSvUsedInPosition mGnssSvIdUsedInPosition; - bool mGnssSvIdUsedInPosAvail; -public: - bool mSupportsAgpsRequests; - bool mSupportsPositionInjection; - bool mSupportsTimeInjection; - LocGnssSystemInfo mGnssInfo; - - LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, - void* owner, ContextBase* context, - LocThread::tCreate tCreator); - virtual ~LocEngAdapter(); - - virtual void setUlpProxy(UlpProxyBase* ulp); - void setXtraUserAgent(); - inline void requestUlp(unsigned long capabilities) { - mContext->requestUlp(mInternalAdapter, capabilities); - } - inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; } - inline UlpProxyBase* getUlpProxy() { return mUlp; } - inline void* getOwner() { return mOwner; } - inline bool hasAgpsExtendedCapabilities() { - return mContext->hasAgpsExtendedCapabilities(); - } - inline bool hasCPIExtendedCapabilities() { - return mContext->hasCPIExtendedCapabilities(); - } - inline bool hasNativeXtraClient() { - return mContext->hasNativeXtraClient(); - } - inline const MsgTask* getMsgTask() { return mMsgTask; } - - inline void clearGnssSvUsedListData() { - mGnssSvIdUsedInPosAvail = false; - memset(&mGnssSvIdUsedInPosition, 0, sizeof (GnssSvUsedInPosition)); - } - - inline void setGnssSvUsedListData(GnssSvUsedInPosition gnssSvUsedIds) { - mGnssSvIdUsedInPosAvail = true; - memcpy(&mGnssSvIdUsedInPosition, &gnssSvUsedIds, - sizeof(GnssSvUsedInPosition)); - } - - inline GnssSvUsedInPosition getGnssSvUsedListData() { - return mGnssSvIdUsedInPosition; - } - - inline bool isGnssSvIdUsedInPosAvail() { - return mGnssSvIdUsedInPosAvail; - } - - inline enum loc_api_adapter_err - startFix() - { - return mLocApi->startFix(mFixCriteria); - } - inline enum loc_api_adapter_err - stopFix() - { - return mLocApi->stopFix(); - } - inline enum loc_api_adapter_err - deleteAidingData(LocGpsAidingData f) - { - return mLocApi->deleteAidingData(f); - } - inline enum loc_api_adapter_err - enableData(int enable) - { - return mLocApi->enableData(enable); - } - inline enum loc_api_adapter_err - setAPN(char* apn, int len) - { - return mLocApi->setAPN(apn, len); - } - inline enum loc_api_adapter_err - injectPosition(double latitude, double longitude, float accuracy) - { - return mLocApi->injectPosition(latitude, longitude, accuracy); - } - inline enum loc_api_adapter_err - setXtraData(char* data, int length) - { - return mLocApi->setXtraData(data, length); - } - inline enum loc_api_adapter_err - requestXtraServer() - { - return mLocApi->requestXtraServer(); - } - inline enum loc_api_adapter_err - atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, LocAGpsType agpsType) - { - return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType); - } - inline enum loc_api_adapter_err - atlCloseStatus(int handle, int is_succ) - { - return mLocApi->atlCloseStatus(handle, is_succ); - } - inline enum loc_api_adapter_err - setPositionMode(const LocPosMode *posMode) - { - if (NULL != posMode) { - mFixCriteria = *posMode; - } - return mLocApi->setPositionMode(mFixCriteria); - } - inline enum loc_api_adapter_err - setServer(const char* url, int len) - { - return mLocApi->setServer(url, len); - } - inline enum loc_api_adapter_err - setServer(unsigned int ip, int port, - LocServerType type) - { - return mLocApi->setServer(ip, port, type); - } - inline enum loc_api_adapter_err - informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData) - { - return mLocApi->informNiResponse(userResponse, passThroughData); - } - inline enum loc_api_adapter_err - setSUPLVersion(uint32_t version) - { - return mLocApi->setSUPLVersion(version); - } - inline enum loc_api_adapter_err - setNMEATypes (uint32_t typesMask) - { - return mLocApi->setNMEATypes(typesMask); - } - inline enum loc_api_adapter_err - setLPPConfig(uint32_t profile) - { - return mLocApi->setLPPConfig(profile); - } - inline enum loc_api_adapter_err - setSensorControlConfig(int sensorUsage, int sensorProvider) - { - return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider); - } - inline enum loc_api_adapter_err - setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, - bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, - bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk, - bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk, - bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk) - { - return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk, - accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk, - angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk, - rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk, - velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk); - } - inline virtual enum loc_api_adapter_err - setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, - int gyroSamplesPerBatch, int gyroBatchesPerSec, - int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh, - int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig) - { - return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec, - gyroSamplesPerBatch, gyroBatchesPerSec, - accelSamplesPerBatchHigh, accelBatchesPerSecHigh, - gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh, - algorithmConfig); - } - inline virtual enum loc_api_adapter_err - setAGLONASSProtocol(unsigned long aGlonassProtocol) - { - return mLocApi->setAGLONASSProtocol(aGlonassProtocol); - } - inline virtual enum loc_api_adapter_err - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) - { - return mLocApi->setLPPeProtocol(lppeCP, lppeUP); - } - inline virtual int initDataServiceClient(bool isDueToSsr) - { - return mLocApi->initDataServiceClient(isDueToSsr); - } - inline virtual int openAndStartDataCall() - { - return mLocApi->openAndStartDataCall(); - } - inline virtual void stopDataCall() - { - mLocApi->stopDataCall(); - } - inline virtual void closeDataCall() - { - mLocApi->closeDataCall(); - } - inline virtual void releaseDataServiceClient() - { - mLocApi->releaseDataServiceClient(); - } - inline enum loc_api_adapter_err - getZpp(LocGpsLocation &zppLoc, LocPosTechMask &tech_mask) - { - return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask); - } - enum loc_api_adapter_err setTime(LocGpsUtcTime time, - int64_t timeReference, - int uncertainty); - enum loc_api_adapter_err setXtraVersionCheck(int check); - inline virtual void installAGpsCert(const LocDerEncodedCertificate* pData, - size_t length, - uint32_t slotBitMask) - { - mLocApi->installAGpsCert(pData, length, slotBitMask); - } - virtual void handleEngineDownEvent(); - virtual void handleEngineUpEvent(); - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(LocGnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); - virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial); - virtual void reportStatus(LocGpsStatusValue status); - virtual void reportNmea(const char* nmea, int length); - virtual bool reportXtraServer(const char* url1, const char* url2, - const char* url3, const int maxlength); - virtual bool requestXtraData(); - virtual bool requestTime(); - virtual bool requestATL(int connHandle, LocAGpsType agps_type); - virtual bool releaseATL(int connHandle); - virtual bool requestNiNotify(LocGpsNiNotification ¬ify, const void* data); - virtual bool requestSuplES(int connHandle); - virtual bool reportDataCallOpened(); - virtual bool reportDataCallClosed(); - virtual void reportGnssMeasurementData(LocGnssData &gnssMeasurementData); - - inline const LocPosMode& getPositionMode() const - {return mFixCriteria;} - inline virtual bool isInSession() - { return mNavigating; } - void setInSession(bool inSession); - - // Permit/prohibit power voting - inline void setPowerVoteRight(bool powerVoteRight) { - mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) : - (mPowerVote & ~POWER_VOTE_RIGHT); - } - inline bool getPowerVoteRight() const { - return (mPowerVote & POWER_VOTE_RIGHT) != 0 ; - } - // Set the power voting up/down and do actual operation if permitted - inline void setPowerVote(bool powerOn) { - mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) : - (mPowerVote & ~POWER_VOTE_VALUE); - requestPowerVote(); - mContext->modemPowerVote(powerOn); - } - inline bool getPowerVote() const { - return (mPowerVote & POWER_VOTE_VALUE) != 0 ; - } - // Do power voting according to last settings if permitted - void requestPowerVote(); - - /*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions - */ - inline int setGpsLock(LOC_GPS_LOCK_MASK lock) - { - return mLocApi->setGpsLock(lock); - } - - int setGpsLockMsg(LOC_GPS_LOCK_MASK lock); - - /* - Returns - Current value of GPS lock on success - -1 on failure - */ - inline int getGpsLock() - { - return mLocApi->getGpsLock(); - } - - /* - Set Gnss Constellation Config - */ - bool gnssConstellationConfig(); -}; - -#endif //LOC_API_ENG_ADAPTER_H diff --git a/loc_api/libloc_api_50001/Makefile.am b/loc_api/libloc_api_50001/Makefile.am deleted file mode 100644 index 4c1ccf7d..00000000 --- a/loc_api/libloc_api_50001/Makefile.am +++ /dev/null @@ -1,62 +0,0 @@ -AM_CFLAGS = \ - -I../../utils \ - -I../../platform_lib_abstractions \ - -I$(WORKSPACE)/gps-noship/flp \ - -fno-short-enums \ - -D__func__=__PRETTY_FUNCTION__ \ - -DFEATURE_GNSS_BIT_API - -libloc_adapter_so_la_SOURCES = loc_eng_log.cpp LocEngAdapter.cpp - -if USE_GLIB -libloc_adapter_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ -libloc_adapter_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_adapter_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_adapter_so_la_CFLAGS = $(AM_CFLAGS) -libloc_adapter_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 -libloc_adapter_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) -endif -libloc_adapter_so_la_LIBADD = -lstdc++ -lcutils ../../utils/libgps_utils_so.la - - -libloc_eng_so_la_SOURCES = \ - loc.cpp \ - loc_eng.cpp \ - loc_eng_agps.cpp \ - loc_eng_xtra.cpp \ - loc_eng_ni.cpp \ - loc_eng_log.cpp \ - 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 - - -if USE_GLIB -libloc_eng_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ -libloc_eng_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 -libloc_eng_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ -else -libloc_eng_so_la_CFLAGS = $(AM_CFLAGS) -libloc_eng_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 -libloc_eng_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) -endif - -libloc_eng_so_la_LIBADD = -lstdc++ -lcutils -ldl ../../utils/libgps_utils_so.la libloc_adapter_so.la - -library_include_HEADERS = \ - LocEngAdapter.h \ - loc.h \ - loc_eng.h \ - loc_eng_xtra.h \ - loc_eng_ni.h \ - loc_eng_agps.h \ - loc_eng_msg.h \ - loc_eng_log.h - -library_includedir = $(pkgincludedir)/libloc_api_50001 - -#Create and Install libraries -lib_LTLIBRARIES = libloc_adapter_so.la libloc_eng_so.la diff --git a/loc_api/libloc_api_50001/gps_converter.cpp b/loc_api/libloc_api_50001/gps_converter.cpp deleted file mode 100644 index 1ca23cf0..00000000 --- a/loc_api/libloc_api_50001/gps_converter.cpp +++ /dev/null @@ -1,255 +0,0 @@ -/* Copyright (c) 2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include - -void A2Q_DerEncodedCertificate(const DerEncodedCertificate& in, LocDerEncodedCertificate& out) { - memset(&out, 0, sizeof(LocDerEncodedCertificate)); - out.length = in.length; - out.data = in.data; -} - -void Q2A_GpsLocation(const LocGpsLocation& in, GpsLocation& out) { - memset(&out, 0, sizeof(GpsLocation)); - out.size = sizeof(GpsLocation); - out.flags = (LocGpsLocationFlags)in.flags; - out.latitude = in.latitude; - out.longitude = in.longitude; - out.altitude = in.altitude; - out.speed = in.speed; - out.bearing = in.bearing; - out.accuracy = in.accuracy; - out.timestamp = Q2A_GpsUtcTime(in.timestamp); -} - -void Q2A_GpsSvInfo(const LocGpsSvInfo& in, GpsSvInfo& out) { - memset(&out, 0, sizeof(GpsSvInfo)); - out.size = sizeof(GpsSvInfo); - out.prn = in.prn; - out.snr = in.snr; - out.elevation = in.elevation; - out.azimuth = in.azimuth; -} - -void Q2A_GpsSvStatus(const LocGpsSvStatus& in, GpsSvStatus& out) { - memset(&out, 0, sizeof(GpsSvStatus)); - out.size = sizeof(GpsSvStatus); - out.num_svs = in.num_svs; - int len = LOC_GPS_MAX_SVS < GPS_MAX_SVS ? LOC_GPS_MAX_SVS : GPS_MAX_SVS; - for (int i = 0; i < len; i++) { - Q2A_GpsSvInfo(in.sv_list[i], out.sv_list[i]); - } - out.ephemeris_mask = in.ephemeris_mask; - out.almanac_mask = in.almanac_mask; - out.used_in_fix_mask = in.used_in_fix_mask; -} - -void Q2A_GnssSvInfo(const LocGnssSvInfo& in, GnssSvInfo& out) { - memset(&out, 0, sizeof(GnssSvInfo)); - out.size = sizeof(GnssSvInfo); - out.svid = in.svid; - out.constellation = (GnssConstellationType)in.constellation; - out.c_n0_dbhz = in.c_n0_dbhz; - out.elevation = in.elevation; - out.azimuth = in.azimuth; - out.flags = (GnssSvFlags)in.flags; -} - -void Q2A_GnssSvStatus(const LocGnssSvStatus& in, GnssSvStatus& out) { - memset(&out, 0, sizeof(GnssSvStatus)); - out.size = sizeof(GnssSvStatus); - out.num_svs = in.num_svs; - int len = LOC_GNSS_MAX_SVS < GNSS_MAX_SVS ? LOC_GNSS_MAX_SVS : GNSS_MAX_SVS; - for (int i = 0; i < len; i++) { - Q2A_GnssSvInfo(in.gnss_sv_list[i], out.gnss_sv_list[i]); - } -} - -void Q2A_GpsNiNotification(const LocGpsNiNotification& in, GpsNiNotification& out) { - memset(&out, 0, sizeof(GpsNiNotification)); - out.size = sizeof(GpsNiNotification); - out.notification_id = in.notification_id; - out.ni_type = (GpsNiType)in.ni_type; - out.notify_flags = (GpsNiNotifyFlags)in.notify_flags; - out.timeout = in.timeout; - out.default_response = (GpsUserResponseType)in.default_response; - int len = LOC_GPS_NI_SHORT_STRING_MAXLEN < GPS_NI_SHORT_STRING_MAXLEN - ? LOC_GPS_NI_SHORT_STRING_MAXLEN : GPS_NI_SHORT_STRING_MAXLEN; - for (int i = 0; i < len; i++) { - out.requestor_id[i] = in.requestor_id[i]; - } - len = LOC_GPS_NI_LONG_STRING_MAXLEN < GPS_NI_LONG_STRING_MAXLEN - ? LOC_GPS_NI_LONG_STRING_MAXLEN : GPS_NI_LONG_STRING_MAXLEN; - for (int i = 0; i < len; i++) { - out.text[i] = in.text[i]; - } - out.requestor_id_encoding = (GpsNiEncodingType)in.requestor_id_encoding; - out.text_encoding = (GpsNiEncodingType)in.text_encoding; - len = LOC_GPS_NI_LONG_STRING_MAXLEN < GPS_NI_LONG_STRING_MAXLEN - ? LOC_GPS_NI_LONG_STRING_MAXLEN : GPS_NI_LONG_STRING_MAXLEN; - for (int i = 0; i < len; i++) { - out.extras[i] = in.extras[i]; - } -} - -void Q2A_GpsStatus(const LocGpsStatus& in, GpsStatus& out) { - memset(&out, 0, sizeof(GpsStatus)); - out.size = sizeof(GpsStatus); - out.status = (GpsStatusValue)in.status; -} - -void Q2A_GnssSystemInfo(const LocGnssSystemInfo& in, GnssSystemInfo& out) { - memset(&out, 0, sizeof(GnssSystemInfo)); - out.size = sizeof(GnssSystemInfo); - out.year_of_hw = in.year_of_hw; -} - -void Q2A_AGpsStatus(const LocAGpsStatus& in, AGpsStatus& out) { - memset(&out, 0, sizeof(AGpsStatus)); - out.size = sizeof(AGpsStatus); - out.type = (AGpsType)in.type; - out.status = (AGpsStatusValue)in.status; - out.ipaddr = in.ipaddr; - memcpy(&out.addr, &in.addr, sizeof(sockaddr_storage)); -} - -void Q2A_GpsMeasurement(const LocGpsMeasurement& in, GpsMeasurement& out) { - memset(&out, 0, sizeof(GpsMeasurement)); - out.size = sizeof(GpsMeasurement); - out.flags = (GpsMeasurementFlags)in.flags; - out.prn = in.prn; - out.time_offset_ns = in.time_offset_ns; - out.state = (GpsMeasurementState)in.state; - out.received_gps_tow_ns = in.received_gps_tow_ns; - out.received_gps_tow_uncertainty_ns = in.received_gps_tow_uncertainty_ns; - out.c_n0_dbhz = in.c_n0_dbhz; - out.pseudorange_rate_mps = in.pseudorange_rate_mps; - out.pseudorange_rate_uncertainty_mps = in.pseudorange_rate_uncertainty_mps; - out.accumulated_delta_range_state = (GpsAccumulatedDeltaRangeState)in.accumulated_delta_range_state; - out.accumulated_delta_range_m = in.accumulated_delta_range_m; - out.accumulated_delta_range_uncertainty_m = in.accumulated_delta_range_uncertainty_m; - out.pseudorange_m = in.pseudorange_m; - out.pseudorange_uncertainty_m = in.pseudorange_uncertainty_m; - out.code_phase_chips = in.code_phase_chips; - out.code_phase_uncertainty_chips = in.code_phase_uncertainty_chips; - out.carrier_frequency_hz = in.carrier_frequency_hz; - out.carrier_cycles = in.carrier_cycles; - out.carrier_phase = in.carrier_phase; - out.carrier_phase_uncertainty = in.carrier_phase_uncertainty; - out.loss_of_lock = (GpsLossOfLock)in.loss_of_lock; - out.bit_number = in.bit_number; - out.time_from_last_bit_ms = in.time_from_last_bit_ms; - out.doppler_shift_hz = in.doppler_shift_hz; - out.doppler_shift_uncertainty_hz = in.doppler_shift_uncertainty_hz; - out.multipath_indicator = (GpsMultipathIndicator)in.multipath_indicator; - out.snr_db = in.snr_db; - out.elevation_deg = in.elevation_deg; - out.elevation_uncertainty_deg = in.elevation_uncertainty_deg; - out.azimuth_deg = in.azimuth_deg; - out.azimuth_uncertainty_deg = in.azimuth_uncertainty_deg; - out.used_in_fix = in.used_in_fix; -} - -void Q2A_GpsClock(const LocGpsClock& in, GpsClock& out) { - memset(&out, 0, sizeof(GpsClock)); - out.size = sizeof(GpsClock); - out.flags = (GpsClockFlags)in.flags; - out.leap_second = in.leap_second; - out.type = (GpsClockType)in.type; - out.time_ns = in.time_ns; - out.time_uncertainty_ns = in.time_uncertainty_ns; - out.full_bias_ns = in.full_bias_ns; - out.bias_ns = in.bias_ns; - out.bias_uncertainty_ns = in.bias_uncertainty_ns; - out.drift_nsps = in.drift_nsps; - out.drift_uncertainty_nsps = in.drift_uncertainty_nsps; -} - -void Q2A_GpsData(const LocGpsData& in, GpsData& out) { - memset(&out, 0, sizeof(GpsData)); - out.size = sizeof(GpsData); - out.measurement_count = in.measurement_count; - int len = LOC_GPS_MAX_MEASUREMENT < GPS_MAX_MEASUREMENT - ? LOC_GPS_MAX_MEASUREMENT : GPS_MAX_MEASUREMENT; - for (int i = 0; i < len; i++) { - Q2A_GpsMeasurement(in.measurements[i], out.measurements[i]); - } - Q2A_GpsClock(in.clock, out.clock); -} - -void Q2A_GnssMeasurement(const LocGnssMeasurement& in, GnssMeasurement& out) { - memset(&out, 0, sizeof(GnssMeasurement)); - out.size = sizeof(GnssMeasurement); - out.flags = (GpsMeasurementFlags)in.flags; - out.svid = in.svid; - out.constellation = (GnssConstellationType)in.constellation; - out.time_offset_ns = in.time_offset_ns; - out.state = (GnssMeasurementState)in.state; - out.received_sv_time_in_ns = in.received_sv_time_in_ns; - out.received_sv_time_uncertainty_in_ns = in.received_sv_time_uncertainty_in_ns; - out.c_n0_dbhz = in.c_n0_dbhz; - out.pseudorange_rate_mps = in.pseudorange_rate_mps; - out.pseudorange_rate_uncertainty_mps = in.pseudorange_rate_uncertainty_mps; - out.accumulated_delta_range_state = (GnssAccumulatedDeltaRangeState)in.accumulated_delta_range_state; - out.accumulated_delta_range_m = in.accumulated_delta_range_m; - out.accumulated_delta_range_uncertainty_m = in.accumulated_delta_range_uncertainty_m; - out.carrier_frequency_hz = in.carrier_frequency_hz; - out.carrier_cycles = in.carrier_cycles; - out.carrier_phase = in.carrier_phase; - out.carrier_phase_uncertainty = in.carrier_phase_uncertainty; - out.multipath_indicator = (GnssMultipathIndicator)in.multipath_indicator; - out.snr_db = in.snr_db; -} - -void Q2A_GnssClock(const LocGnssClock& in, GnssClock& out) { - memset(&out, 0, sizeof(GnssClock)); - out.size = sizeof(GnssClock); - out.flags = (GnssClockFlags)in.flags; - out.leap_second = in.leap_second; - out.time_ns = in.time_ns; - out.time_uncertainty_ns = in.time_uncertainty_ns; - out.full_bias_ns = in.full_bias_ns; - out.bias_ns = in.bias_ns; - out.bias_uncertainty_ns = in.bias_uncertainty_ns; - out.drift_nsps = in.drift_nsps; - out.drift_uncertainty_nsps = in.drift_uncertainty_nsps; - out.hw_clock_discontinuity_count = in.hw_clock_discontinuity_count; -} - -void Q2A_GnssData(const LocGnssData& in, GnssData& out) { - memset(&out, 0, sizeof(GnssData)); - out.size = sizeof(GnssData); - out.measurement_count = in.measurement_count; - int len = LOC_GNSS_MAX_MEASUREMENT < GNSS_MAX_MEASUREMENT - ? LOC_GNSS_MAX_MEASUREMENT : GNSS_MAX_MEASUREMENT; - for (int i = 0; i < len; i++) { - Q2A_GnssMeasurement(in.measurements[i], out.measurements[i]); - } - Q2A_GnssClock(in.clock, out.clock); -} diff --git a/loc_api/libloc_api_50001/gps_converter.h b/loc_api/libloc_api_50001/gps_converter.h deleted file mode 100644 index fa7c68a3..00000000 --- a/loc_api/libloc_api_50001/gps_converter.h +++ /dev/null @@ -1,69 +0,0 @@ -/* Copyright (c) 2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef __GPS_CONVERTER_H__ -#define __GPS_CONVERTER_H__ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include -#include -#include - -#define A2Q_GpsAidingData(in) (LocGpsAidingData)in -#define A2Q_GpsUserResponseType(in) (LocGpsUserResponseType)in -#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in -#define A2Q_GpsUtcTime(in) (LocGpsUtcTime)in -#define A2Q_GpsPositionMode(in) (LocGpsPositionMode)in -#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in -#define A2Q_ApnIpType(in) (LocApnIpType)in -#define A2Q_AGpsType(in) (LocAGpsType)in -#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in - -#define Q2A_GpsUtcTime(in) (GpsUtcTime)in - -void A2Q_DerEncodedCertificate(const DerEncodedCertificate& in, LocDerEncodedCertificate& out); - -void Q2A_GpsLocation(const LocGpsLocation& in, GpsLocation& out); -void Q2A_GpsSvStatus(const LocGpsSvStatus& in, GpsSvStatus& out); -void Q2A_GnssSvStatus(const LocGnssSvStatus& in, GnssSvStatus& out); -void Q2A_GpsNiNotification(const LocGpsNiNotification& in, GpsNiNotification& out); -void Q2A_GpsStatus(const LocGpsStatus& in, GpsStatus& out); -void Q2A_GnssSystemInfo(const LocGnssSystemInfo& in, GnssSystemInfo& out); -void Q2A_AGpsStatus(const LocAGpsStatus& in, AGpsStatus& out); -void Q2A_GpsData(const LocGpsData& in, GpsData& out); -void Q2A_GnssData(const LocGnssData& in, GnssData& out); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif //__GPS_CONVERTER_H__ diff --git a/loc_api/libloc_api_50001/gps_interface.cpp b/loc_api/libloc_api_50001/gps_interface.cpp deleted file mode 100644 index 993874f7..00000000 --- a/loc_api/libloc_api_50001/gps_interface.cpp +++ /dev/null @@ -1,1196 +0,0 @@ -/* Copyright (c) 2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "GpsInterface" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace loc_core; - -// All functions and variables should be static -// except gps_get_hardware_interface() and get_gps_interface() - -extern "C" const LocGpsInterface* loc_eng_gps_get_hardware_interface (); -extern "C" const LocGpsInterface* loc_eng_get_gps_interface(); - -/*=========================================================================== - Functions and variables for sGpsInterface -===========================================================================*/ -static const LocGpsInterface* pLocGpsInterface = NULL; - -static GpsCallbacks sGpsCallbacks; -static GpsCallbacks* pGpsCallbacks = NULL; - -static void local_gps_location_callback(LocGpsLocation* location); -static void local_gps_sv_status_callback(LocGpsSvStatus* sv_status); -static void local_gps_status_callback(LocGpsStatus* status); -static void local_gps_nmea_callback(LocGpsUtcTime timestamp, const char* nmea, int length); -static void local_gps_set_capabilities(uint32_t capabilities); -static void local_gps_acquire_wakelock(); -static void local_gps_release_wakelock(); -static pthread_t local_gps_create_thread(const char* name, void (*start)(void *), void* arg); -static void local_gps_request_utc_time(); -static void local_gnss_set_system_info(const LocGnssSystemInfo* info); -static void local_gnss_sv_status_callback(LocGnssSvStatus* sv_info); - -static LocGpsCallbacks sLocGpsCallbacks = { - sizeof(LocGpsCallbacks), - local_gps_location_callback, - local_gps_status_callback, - local_gps_sv_status_callback, - local_gps_nmea_callback, - local_gps_set_capabilities, - local_gps_acquire_wakelock, - local_gps_release_wakelock, - local_gps_create_thread, - local_gps_request_utc_time, - local_gnss_set_system_info, - local_gnss_sv_status_callback, -}; - -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); - -static const GpsInterface sGpsInterface = { - 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 -}; - -/*=========================================================================== - Functions and variables for sGpsXtraInterface -===========================================================================*/ -static const LocGpsXtraInterface* pLocGpsXtraInterface = NULL; - -static GpsXtraCallbacks sGpsXtraCallbacks; -static GpsXtraCallbacks* pGpsXtraCallbacks = NULL; - -static void local_gps_xtra_download_request(); -static pthread_t local_gps_xtra_create_thread(const char* name, void (*start)(void *), void* arg); - -static LocGpsXtraCallbacks sLocGpsXtraCallbacks = { - local_gps_xtra_download_request, - local_gps_xtra_create_thread -}; - -static int loc_xtra_init(GpsXtraCallbacks* callbacks); -static int loc_xtra_inject_data(char* data, int length); - -static const GpsXtraInterface sGpsXtraInterface = { - sizeof(GpsXtraInterface), - loc_xtra_init, - loc_xtra_inject_data -}; - -/*=========================================================================== - Functions and variables for sAGpsInterface -===========================================================================*/ -static const LocAGpsInterface* pLocAGpsInterface = NULL; - -static AGpsCallbacks sAGpsCallbacks; -static AGpsCallbacks* pAGpsCallbacks = NULL; - -static void local_agps_status_callback(LocAGpsStatus* status); -static pthread_t local_agps_create_thread(const char* name, void (*start)(void *), void* arg); - -static LocAGpsCallbacks sLocAGpsCallbacks = { - local_agps_status_callback, - local_agps_create_thread -}; - -static void loc_agps_init(AGpsCallbacks* callbacks); -static int loc_agps_open(const char* apn); -static int loc_agps_closed(); -static int loc_agps_open_failed(); -static int loc_agps_set_server(AGpsType type, const char *hostname, int port); -static int loc_agps_open_with_apniptype( const char* apn, ApnIpType apnIpType); - -static const AGpsInterface sAGpsInterface = { - sizeof(AGpsInterface), - loc_agps_init, - loc_agps_open, - loc_agps_closed, - loc_agps_open_failed, - loc_agps_set_server, - loc_agps_open_with_apniptype -}; - -/*=========================================================================== - Functions and variables for SUPL sSuplCertificateInterface -===========================================================================*/ -static const LocSuplCertificateInterface* pLocSuplCertificateInterface = NULL; - -static int loc_agps_install_certificates(const DerEncodedCertificate* certificates, - size_t length); -static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints, - size_t length); - -static const SuplCertificateInterface sSuplCertificateInterface = -{ - sizeof(SuplCertificateInterface), - loc_agps_install_certificates, - loc_agps_revoke_certificates -}; - -/*=========================================================================== - Functions and variables for sGpsNiInterface -===========================================================================*/ -static const LocGpsNiInterface* pLocGpsNiInterface = NULL; - -static GpsNiCallbacks sGpsNiCallbacks; -static GpsNiCallbacks* pGpsNiCallbacks = NULL; - -static void local_gps_ni_notify_callback(LocGpsNiNotification *notification); -static pthread_t local_gps_ni_create_thread(const char* name, void (*start)(void *), void* arg); - -static LocGpsNiCallbacks sLocGpsNiCallbacks = { - local_gps_ni_notify_callback, - local_gps_ni_create_thread -}; - -static void loc_ni_init(GpsNiCallbacks *callbacks); -static void loc_ni_respond(int notif_id, GpsUserResponseType user_response); - -static const GpsNiInterface sGpsNiInterface = -{ - sizeof(GpsNiInterface), - loc_ni_init, - loc_ni_respond, -}; - -/*=========================================================================== - Functions and variables for sAGpsRilInterface -===========================================================================*/ -static const LocAGpsRilInterface* pLocAGpsRilInterface = NULL; - -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 sAGpsRilInterface = -{ - 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 -}; - -/*=========================================================================== - Functions and variables for sGpsGeofencingInterface -===========================================================================*/ -static const LocGpsGeofencingInterface* pLocGpsGeofencingInterface = NULL; - -static GpsGeofenceCallbacks sGpsGeofenceCallbacks; -static GpsGeofenceCallbacks* pGpsGeofenceCallbacks = NULL; - -static void local_gps_geofence_transition_callback(int32_t geofence_id, LocGpsLocation* location, - int32_t transition, LocGpsUtcTime timestamp); -static void local_gps_geofence_status_callback(int32_t status, LocGpsLocation* last_location); -static void local_gps_geofence_add_callback(int32_t geofence_id, int32_t status); -static void local_gps_geofence_remove_callback(int32_t geofence_id, int32_t status); -static void local_gps_geofence_pause_callback(int32_t geofence_id, int32_t status); -static void local_gps_geofence_resume_callback(int32_t geofence_id, int32_t status); -static pthread_t local_geofence_create_thread(const char* name, void (*start)(void *), void* arg); - -static LocGpsGeofenceCallbacks sLocGpsGeofenceCallbacks = -{ - local_gps_geofence_transition_callback, - local_gps_geofence_status_callback, - local_gps_geofence_add_callback, - local_gps_geofence_remove_callback, - local_gps_geofence_pause_callback, - local_gps_geofence_resume_callback, - local_geofence_create_thread -}; - -static void loc_geofence_init(GpsGeofenceCallbacks* callbacks); -static void loc_add_geofence_area(int32_t geofence_id, double latitude, double longitude, - double radius_meters, int last_transition, int monitor_transitions, - int notification_responsiveness_ms, int unknown_timer_ms); -static void loc_pause_geofence(int32_t geofence_id); -static void loc_resume_geofence(int32_t geofence_id, int monitor_transitions); -static void loc_remove_geofence_area(int32_t geofence_id); - -static const GpsGeofencingInterface sGpsGeofencingInterface = -{ - sizeof(GpsGeofencingInterface), - loc_geofence_init, - loc_add_geofence_area, - loc_pause_geofence, - loc_resume_geofence, - loc_remove_geofence_area -}; - -/*=========================================================================== - Functions and variables for sGpsMeasurementInterface -===========================================================================*/ -static const LocGpsMeasurementInterface* pLocGpsMeasurementInterface = NULL; - -static GpsMeasurementCallbacks sGpsMeasurementCallbacks; -static GpsMeasurementCallbacks* pGpsMeasurementCallbacks = NULL; - -static void local_gps_measurement_callback(LocGpsData* data); -static void local_gnss_measurement_callback(LocGnssData* data); - -static LocGpsMeasurementCallbacks sLocGpsMeasurementCallbacks = -{ - sizeof(LocGpsMeasurementCallbacks), - local_gps_measurement_callback, - local_gnss_measurement_callback -}; - -static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks); -static void loc_gps_measurement_close(); - -static const GpsMeasurementInterface sGpsMeasurementInterface = -{ - sizeof(GpsMeasurementInterface), - loc_gps_measurement_init, - loc_gps_measurement_close -}; - -/*=========================================================================== - Functions and variables for sGnssConfigurationInterface -===========================================================================*/ -static const LocGnssConfigurationInterface* pLocGnssConfigurationInterface = NULL; - -static void loc_configuration_update(const char* config_data, int32_t length); - -static const GnssConfigurationInterface sGnssConfigurationInterface = -{ - sizeof(GnssConfigurationInterface), - loc_configuration_update -}; - - -/*=========================================================================== -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 - -===========================================================================*/ -extern "C" const GpsInterface* gps_get_hardware_interface () -{ - ENTRY_LOG_CALLFLOW(); - const GpsInterface* retVal; - pLocGpsInterface = loc_eng_gps_get_hardware_interface(); - if (NULL != pLocGpsInterface) { - retVal = &sGpsInterface; - } else { - retVal = NULL; - } - EXIT_LOG(%p, retVal); - return retVal; -} - -// for gps.c -extern "C" const GpsInterface* get_gps_interface() -{ - pLocGpsInterface = loc_eng_get_gps_interface(); - return &sGpsInterface; -} - -/*=========================================================================== - Implementation of functions for sGpsInterface -===========================================================================*/ -static void local_gps_location_callback(LocGpsLocation* location) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->location_cb) { - GpsLocation loc; - GpsLocation* p_loc = NULL; - if (NULL != location) { - Q2A_GpsLocation(*location, loc); - p_loc = &loc; - } - // We are not sure whether NULL pointer is a legal - // parameter to the original callback functions or not. - // So we should forward NULL pointer at this layer. - pGpsCallbacks->location_cb(p_loc); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_sv_status_callback(LocGpsSvStatus* sv_status) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->sv_status_cb) { - CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs); - GpsSvStatus st; - GpsSvStatus* p_st = NULL; - if (NULL != sv_status) { - Q2A_GpsSvStatus(*sv_status, st); - p_st = &st; - } - pGpsCallbacks->sv_status_cb(p_st); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_status_callback(LocGpsStatus* status) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->status_cb) { - GpsStatus st; - GpsStatus* p_st = NULL; - if (NULL != status) { - Q2A_GpsStatus(*status, st); - p_st = &st; - } - pGpsCallbacks->status_cb(p_st); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_nmea_callback(LocGpsUtcTime timestamp, const char* nmea, int length) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->nmea_cb) { - pGpsCallbacks->nmea_cb(A2Q_GpsUtcTime(timestamp), nmea, length); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_set_capabilities(uint32_t capabilities) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->set_capabilities_cb) { - pGpsCallbacks->set_capabilities_cb(capabilities); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_acquire_wakelock() -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->acquire_wakelock_cb) { - pGpsCallbacks->acquire_wakelock_cb(); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_release_wakelock() -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->release_wakelock_cb) { - pGpsCallbacks->release_wakelock_cb(); - } - EXIT_LOG(%s, VOID_RET); -} - -static pthread_t local_gps_create_thread(const char* name, void (*start)(void *), void* arg) -{ - ENTRY_LOG(); - pthread_t retVal = -1; - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->create_thread_cb) { - retVal = pGpsCallbacks->create_thread_cb(name, start, arg); - } - EXIT_LOG(%d, (int)retVal); - return retVal; -} - -static void local_gps_request_utc_time() -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->request_utc_time_cb) { - pGpsCallbacks->request_utc_time_cb(); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gnss_set_system_info(const LocGnssSystemInfo* info) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->set_system_info_cb) { - GnssSystemInfo sysinfo; - GnssSystemInfo* p_sysinfo = NULL; - if (NULL != info) { - Q2A_GnssSystemInfo(*info, sysinfo); - p_sysinfo = &sysinfo; - } - pGpsCallbacks->set_system_info_cb(p_sysinfo); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gnss_sv_status_callback(LocGnssSvStatus* sv_info) -{ - ENTRY_LOG(); - if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->gnss_sv_status_cb) { - GnssSvStatus info; - GnssSvStatus* p_info = NULL; - if (NULL != sv_info) { - Q2A_GnssSvStatus(*sv_info, info); - p_info - &info; - } - pGpsCallbacks->gnss_sv_status_cb(p_info); - } - EXIT_LOG(%s, VOID_RET); -} - -static int loc_init(GpsCallbacks* callbacks) -{ - ENTRY_LOG(); - - int retVal = -1; - LocGpsCallbacks* cbs = NULL; - if (NULL != callbacks) { - memcpy(&sGpsCallbacks, callbacks, sizeof(GpsCallbacks)); - pGpsCallbacks = &sGpsCallbacks; - cbs = &sLocGpsCallbacks; - } - - if(NULL != pLocGpsInterface && NULL != pLocGpsInterface->init) { - retVal = pLocGpsInterface->init(cbs); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_start() -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->start) { - retVal = pLocGpsInterface->start(); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_stop() -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->stop) { - retVal = pLocGpsInterface->stop(); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -static void loc_cleanup() -{ - ENTRY_LOG(); - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->cleanup) { - pLocGpsInterface->cleanup(); - } - pLocGpsInterface = NULL; - pGpsCallbacks = NULL; - EXIT_LOG(%s, VOID_RET); -} - -static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty) -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->inject_time) { - retVal = pLocGpsInterface->inject_time(A2Q_GpsUtcTime(time), - timeReference, uncertainty); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_inject_location(double latitude, double longitude, float accuracy) -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->inject_location) { - retVal = pLocGpsInterface->inject_location(latitude, longitude, accuracy); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -static void loc_delete_aiding_data(GpsAidingData f) -{ - ENTRY_LOG(); - -#ifndef TARGET_BUILD_VARIANT_USER - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->delete_aiding_data) { - pLocGpsInterface->delete_aiding_data(A2Q_GpsAidingData(f)); - } -#endif - - EXIT_LOG(%s, VOID_RET); -} - -static int loc_set_position_mode(GpsPositionMode mode, - GpsPositionRecurrence recurrence, - uint32_t min_interval, - uint32_t preferred_accuracy, - uint32_t preferred_time) -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->set_position_mode) { - retVal = pLocGpsInterface->set_position_mode(A2Q_GpsPositionMode(mode), - A2Q_GpsPositionRecurrence(recurrence), - min_interval, preferred_accuracy, preferred_time); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -const void* loc_get_extension(const char* name) -{ - ENTRY_LOG(); - const void* retVal = NULL; - - LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name); - if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->get_extension) { - if (strcmp(name, GPS_XTRA_INTERFACE) == 0) - { - pLocGpsXtraInterface = (const LocGpsXtraInterface*)pLocGpsInterface-> - get_extension(LOC_GPS_XTRA_INTERFACE); - if (NULL != pLocGpsXtraInterface) { - retVal = &sGpsXtraInterface; - } - } - else if (strcmp(name, AGPS_INTERFACE) == 0) - { - pLocAGpsInterface = (const LocAGpsInterface*)pLocGpsInterface-> - get_extension(LOC_AGPS_INTERFACE); - if (NULL != pLocAGpsInterface) { - retVal = &sAGpsInterface; - } - } - else if (strcmp(name, SUPL_CERTIFICATE_INTERFACE) == 0) - { - pLocSuplCertificateInterface = (const LocSuplCertificateInterface*)pLocGpsInterface-> - get_extension(LOC_SUPL_CERTIFICATE_INTERFACE); - if (NULL != pLocAGpsInterface) { - retVal = &sSuplCertificateInterface; - } - } - else if (strcmp(name, GPS_NI_INTERFACE) == 0) - { - pLocGpsNiInterface = (const LocGpsNiInterface*)pLocGpsInterface-> - get_extension(LOC_GPS_NI_INTERFACE); - if (NULL != pLocGpsNiInterface) { - retVal = &sGpsNiInterface; - } - } - else if (strcmp(name, AGPS_RIL_INTERFACE) == 0) - { - pLocAGpsRilInterface = (const LocAGpsRilInterface*)pLocGpsInterface-> - get_extension(LOC_AGPS_RIL_INTERFACE); - if (NULL != pLocAGpsRilInterface) { - retVal = &sAGpsRilInterface; - } - } - else if (strcmp(name, GPS_GEOFENCING_INTERFACE) == 0) - { - pLocGpsGeofencingInterface = (const LocGpsGeofencingInterface*)pLocGpsInterface-> - get_extension(LOC_GPS_GEOFENCING_INTERFACE); - if (NULL != pLocGpsGeofencingInterface) { - retVal = &sGpsGeofencingInterface; - } - } - else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0) - { - pLocGpsMeasurementInterface = (const LocGpsMeasurementInterface*)pLocGpsInterface-> - get_extension(LOC_GPS_MEASUREMENT_INTERFACE); - if (NULL != pLocGpsMeasurementInterface) { - retVal = &sGpsMeasurementInterface; - } - } - else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0) - { - pLocGnssConfigurationInterface = (const LocGnssConfigurationInterface*)pLocGpsInterface-> - get_extension(LOC_GNSS_CONFIGURATION_INTERFACE); - if (NULL != pLocGnssConfigurationInterface) { - retVal = &sGnssConfigurationInterface; - } - } - else - { - LOC_LOGE ("get_extension: Invalid interface passed in\n"); - } - } - EXIT_LOG(%p, retVal); - return retVal; -} - -/*=========================================================================== - Implementation of functions for sGpsXtraInterface -===========================================================================*/ -static void local_gps_xtra_download_request() -{ - ENTRY_LOG(); - if (NULL != pGpsXtraCallbacks && NULL != pGpsXtraCallbacks->download_request_cb) { - pGpsXtraCallbacks->download_request_cb(); - } - EXIT_LOG(%s, VOID_RET); -} - -static pthread_t local_gps_xtra_create_thread(const char* name, void (*start)(void *), void* arg) -{ - ENTRY_LOG(); - pthread_t retVal = -1; - if (NULL != pGpsXtraCallbacks && NULL != pGpsXtraCallbacks->create_thread_cb) { - retVal = pGpsXtraCallbacks->create_thread_cb(name, start, arg); - } - EXIT_LOG(%d, (int)retVal); - return retVal; -} - -static int loc_xtra_init(GpsXtraCallbacks* callbacks) -{ - ENTRY_LOG(); - - int retVal = -1; - LocGpsXtraCallbacks* cbs = NULL; - if (NULL != callbacks) - { - memcpy(&sGpsXtraCallbacks, callbacks, sizeof(GpsXtraCallbacks)); - pGpsXtraCallbacks = &sGpsXtraCallbacks; - cbs = &sLocGpsXtraCallbacks; - } - - if (NULL != pLocGpsXtraInterface && NULL != pLocGpsXtraInterface->init) { - retVal = pLocGpsXtraInterface->init(cbs); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - - -static int loc_xtra_inject_data(char* data, int length) -{ - ENTRY_LOG(); - int retVal = -1; - if (NULL != pLocGpsXtraInterface && NULL != pLocGpsXtraInterface->inject_xtra_data) { - retVal = pLocGpsXtraInterface->inject_xtra_data(data, length); - } - EXIT_LOG(%d, retVal); - return retVal; -} - -/*=========================================================================== - Implementation of functions for sAGpsInterface -===========================================================================*/ -static void local_agps_status_callback(LocAGpsStatus* status) -{ - ENTRY_LOG(); - if (NULL != pAGpsCallbacks && NULL != pAGpsCallbacks->status_cb) { - AGpsStatus st; - AGpsStatus* p_st = NULL; - if (NULL != status) - { - Q2A_AGpsStatus(*status, st); - p_st = &st; - } - pAGpsCallbacks->status_cb(p_st); - } - EXIT_LOG(%s, VOID_RET); -} - -static pthread_t local_agps_create_thread(const char* name, void (*start)(void *), void* arg) -{ - ENTRY_LOG(); - pthread_t retVal = -1; - if (NULL != pAGpsCallbacks && NULL != pAGpsCallbacks->create_thread_cb) { - retVal = pAGpsCallbacks->create_thread_cb(name, start, arg); - } - EXIT_LOG(%d, (int)retVal); - return retVal; -} - -static void loc_agps_init(AGpsCallbacks* callbacks) -{ - ENTRY_LOG(); - - LocAGpsCallbacks* cbs = NULL; - if (NULL != callbacks) - { - memcpy(&sAGpsCallbacks, callbacks, sizeof(AGpsCallbacks)); - pAGpsCallbacks = &sAGpsCallbacks; - cbs = &sLocAGpsCallbacks; - } - - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->init) { - pLocAGpsInterface->init(cbs); - } - - EXIT_LOG(%s, VOID_RET); -} - -static int loc_agps_open(const char* apn) -{ - ENTRY_LOG(); - - int retVal = -1; - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_open) { - retVal = pLocAGpsInterface->data_conn_open(apn); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_agps_closed() -{ - ENTRY_LOG(); - - int retVal = -1; - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_closed) { - retVal = pLocAGpsInterface->data_conn_closed(); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -int loc_agps_open_failed() -{ - ENTRY_LOG(); - - int retVal = -1; - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_failed) { - retVal = pLocAGpsInterface->data_conn_failed(); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_agps_set_server(AGpsType type, const char* hostname, int port) -{ - ENTRY_LOG(); - - int retVal = -1; - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->set_server) { - retVal = pLocAGpsInterface->set_server(A2Q_AGpsType(type), hostname, port); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType) -{ - ENTRY_LOG(); - - int retVal = -1; - if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_open_with_apn_ip_type) { - retVal = pLocAGpsInterface->data_conn_open_with_apn_ip_type(apn, A2Q_ApnIpType(apnIpType)); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -/*=========================================================================== - Implementation of functions for sSuplCertificateInterface -===========================================================================*/ -static int loc_agps_install_certificates(const DerEncodedCertificate* certificates, - size_t length) -{ - ENTRY_LOG(); - - int retVal = -1; - LocDerEncodedCertificate cert; - LocDerEncodedCertificate* p_cert = NULL; - if (NULL != certificates) { - A2Q_DerEncodedCertificate(*certificates, cert); - p_cert = &cert; - } - - if (NULL != pLocSuplCertificateInterface && - NULL != pLocSuplCertificateInterface->install_certificates) { - retVal = pLocSuplCertificateInterface->install_certificates(p_cert, length); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints, - size_t length) -{ - ENTRY_LOG(); - LOC_LOGE("%s:%d] agps_revoke_certificates not supported", __func__, __LINE__); - int retVal = AGPS_CERTIFICATE_ERROR_GENERIC; - EXIT_LOG(%d, retVal); - return retVal; -} - -/*=========================================================================== - Implementation of functions for sGpsNiInterface -===========================================================================*/ -static void local_gps_ni_notify_callback(LocGpsNiNotification *notification) -{ - ENTRY_LOG(); - if (NULL != pGpsNiCallbacks && NULL != pGpsNiCallbacks->notify_cb) { - GpsNiNotification notify; - GpsNiNotification* p_notify = NULL; - if (NULL != notification) { - Q2A_GpsNiNotification(*notification, notify); - p_notify = ¬ify; - } - pGpsNiCallbacks->notify_cb(p_notify); - } - EXIT_LOG(%s, VOID_RET); -} - -static pthread_t local_gps_ni_create_thread(const char* name, void (*start)(void *), void* arg) -{ - ENTRY_LOG(); - pthread_t retVal = -1; - if (NULL != pGpsNiCallbacks && NULL != pGpsNiCallbacks->create_thread_cb) { - retVal = pGpsNiCallbacks->create_thread_cb(name, start, arg); - } - EXIT_LOG(%d, (int)retVal); - return retVal; -} - -void loc_ni_init(GpsNiCallbacks *callbacks) -{ - ENTRY_LOG(); - - LocGpsNiCallbacks* cbs = NULL; - if (NULL != callbacks) { - memcpy(&sGpsNiCallbacks, callbacks, sizeof(GpsNiCallbacks)); - pGpsNiCallbacks = &sGpsNiCallbacks; - cbs = &sLocGpsNiCallbacks; - } - - if(NULL != pLocGpsNiInterface && NULL != pLocGpsNiInterface->init) { - pLocGpsNiInterface->init(cbs); - } - - EXIT_LOG(%s, VOID_RET); -} - -void loc_ni_respond(int notif_id, GpsUserResponseType user_response) -{ - ENTRY_LOG(); - - if(NULL != pLocGpsNiInterface && NULL != pLocGpsNiInterface->respond) { - pLocGpsNiInterface->respond(notif_id, A2Q_GpsUserResponseType(user_response)); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - Implementation of functions for sAGpsRilInterface -===========================================================================*/ -// Below stub functions are members of sAGpsRilInterface -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 available, const char* apn) -{ - ENTRY_LOG(); - - if (NULL != pLocAGpsRilInterface && - NULL != pLocAGpsRilInterface->update_network_availability) { - pLocAGpsRilInterface->update_network_availability(available, apn); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - Implementation of functions for sGpsGeofencingInterface -===========================================================================*/ -static void local_gps_geofence_transition_callback(int32_t geofence_id, LocGpsLocation* location, - int32_t transition, LocGpsUtcTime timestamp) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_transition_callback) { - GpsLocation loc; - GpsLocation* p_loc = NULL; - if (NULL != location) - { - Q2A_GpsLocation(*location, loc); - p_loc = &loc; - } - pGpsGeofenceCallbacks->geofence_transition_callback(geofence_id, p_loc, transition, Q2A_GpsUtcTime(timestamp)); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_geofence_status_callback(int32_t status, LocGpsLocation* last_location) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_status_callback) { - GpsLocation loc; - GpsLocation* p_loc = NULL; - if (NULL != last_location) - { - Q2A_GpsLocation(*last_location, loc); - p_loc = &loc; - } - pGpsGeofenceCallbacks->geofence_status_callback(status, p_loc); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_geofence_add_callback(int32_t geofence_id, int32_t status) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_add_callback) { - pGpsGeofenceCallbacks->geofence_add_callback(geofence_id, status); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_geofence_remove_callback(int32_t geofence_id, int32_t status) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_remove_callback) { - pGpsGeofenceCallbacks->geofence_remove_callback(geofence_id, status); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_geofence_pause_callback(int32_t geofence_id, int32_t status) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_pause_callback) { - pGpsGeofenceCallbacks->geofence_pause_callback(geofence_id, status); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gps_geofence_resume_callback(int32_t geofence_id, int32_t status) -{ - ENTRY_LOG(); - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_resume_callback) { - pGpsGeofenceCallbacks->geofence_resume_callback(geofence_id, status); - } - EXIT_LOG(%s, VOID_RET); -} - -static pthread_t local_geofence_create_thread(const char* name, void (*start)(void *), void* arg) -{ - ENTRY_LOG(); - pthread_t retVal = -1; - if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->create_thread_cb) { - retVal = pGpsGeofenceCallbacks->create_thread_cb(name, start, arg); - } - EXIT_LOG(%d, (int)retVal); - return retVal; -} - -static void loc_geofence_init(GpsGeofenceCallbacks* callbacks) -{ - ENTRY_LOG(); - if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->init) { - LocGpsGeofenceCallbacks* cbs = NULL; - if (NULL != callbacks) { - memcpy(&sGpsGeofenceCallbacks, callbacks, sizeof(GpsGeofenceCallbacks)); - pGpsGeofenceCallbacks = &sGpsGeofenceCallbacks; - cbs = &sLocGpsGeofenceCallbacks; - } - pLocGpsGeofencingInterface->init(cbs); - } - EXIT_LOG(%s, VOID_RET); -} - -static void loc_add_geofence_area(int32_t geofence_id, double latitude, double longitude, - double radius_meters, int last_transition, int monitor_transitions, - int notification_responsiveness_ms, int unknown_timer_ms) -{ - ENTRY_LOG(); - if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->add_geofence_area) { - pLocGpsGeofencingInterface->add_geofence_area(geofence_id, latitude, longitude, - radius_meters, last_transition, monitor_transitions, - notification_responsiveness_ms, unknown_timer_ms); - } - EXIT_LOG(%s, VOID_RET); -} - -static void loc_pause_geofence(int32_t geofence_id) -{ - ENTRY_LOG(); - if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->pause_geofence) { - pLocGpsGeofencingInterface->pause_geofence(geofence_id); - } - EXIT_LOG(%s, VOID_RET); -} - -static void loc_resume_geofence(int32_t geofence_id, int monitor_transitions) -{ - ENTRY_LOG(); - if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->resume_geofence) { - pLocGpsGeofencingInterface->resume_geofence(geofence_id, monitor_transitions); - } - EXIT_LOG(%s, VOID_RET); -} - -static void loc_remove_geofence_area(int32_t geofence_id) -{ - ENTRY_LOG(); - if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->remove_geofence_area) { - pLocGpsGeofencingInterface->remove_geofence_area(geofence_id); - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - Implementation of functions for sGpsMeasurementInterface -===========================================================================*/ -static void local_gps_measurement_callback(LocGpsData* data) -{ - ENTRY_LOG(); - if (NULL != pGpsMeasurementCallbacks && NULL != pGpsMeasurementCallbacks->measurement_callback) { - GpsData gps_data; - GpsData* p_gps_data = NULL; - if (NULL != data) - { - Q2A_GpsData(*data, gps_data); - p_gps_data = &gps_data; - } - pGpsMeasurementCallbacks->measurement_callback(p_gps_data); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_gnss_measurement_callback(LocGnssData* data) -{ - ENTRY_LOG(); - if (NULL != pGpsMeasurementCallbacks && NULL != pGpsMeasurementCallbacks->gnss_measurement_callback) { - GnssData gnss_data; - GnssData* p_gnss_data = NULL; - if (NULL != data) - { - Q2A_GnssData(*data, gnss_data); - p_gnss_data = &gnss_data; - } - pGpsMeasurementCallbacks->gnss_measurement_callback(p_gnss_data); - } - EXIT_LOG(%s, VOID_RET); -} - -static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks) -{ - ENTRY_LOG(); - - int retVal = -1; - LocGpsMeasurementCallbacks* cbs = NULL; - if (NULL != callbacks) - { - memcpy(&sGpsMeasurementCallbacks, callbacks, sizeof(GpsMeasurementCallbacks)); - pGpsMeasurementCallbacks = &sGpsMeasurementCallbacks; - cbs = &sLocGpsMeasurementCallbacks; - } - - if (NULL != pLocGpsMeasurementInterface && NULL != pLocGpsMeasurementInterface->init) { - pLocGpsMeasurementInterface->init(cbs); - } - - EXIT_LOG(%d, retVal); - return retVal; -} - -static void loc_gps_measurement_close() -{ - ENTRY_LOG(); - - if (NULL != pLocGpsMeasurementInterface && NULL != pLocGpsMeasurementInterface->close) { - pLocGpsMeasurementInterface->close(); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - Implementation of functions for sGnssConfigurationInterface -===========================================================================*/ -static void loc_configuration_update(const char* config_data, int32_t length) -{ - ENTRY_LOG(); - - if (NULL != pLocGnssConfigurationInterface && - NULL != pLocGnssConfigurationInterface->configuration_update) { - pLocGnssConfigurationInterface->configuration_update(config_data, length); - } - - EXIT_LOG(%s, VOID_RET); -} - diff --git a/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp deleted file mode 100644 index 8c021b39..00000000 --- a/loc_api/libloc_api_50001/loc.cpp +++ /dev/null @@ -1,1119 +0,0 @@ -/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_afw" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace loc_core; - -// All functions and variables should be static -// except loc_eng_gps_get_hardware_interface() and loc_eng_get_gps_interface() - -//Globals defns -static loc_gps_location_callback gps_loc_cb = NULL; -static loc_gps_sv_status_callback gps_sv_cb = NULL; - -static void local_loc_cb(UlpLocation* location, void* locExt); -static void local_sv_cb(LocGpsSvStatus* sv_status, void* svExt); - -static const LocGpsGeofencingInterface* get_geofence_interface(void); - -// Function declarations for sLocEngInterface -static int loc_init(LocGpsCallbacks* callbacks); -static int loc_start(); -static int loc_stop(); -static void loc_cleanup(); -static int loc_inject_time(LocGpsUtcTime time, int64_t timeReference, int uncertainty); -static int loc_inject_location(double latitude, double longitude, float accuracy); -static void loc_delete_aiding_data(LocGpsAidingData f); -static int loc_set_position_mode(LocGpsPositionMode mode, LocGpsPositionRecurrence recurrence, - uint32_t min_interval, uint32_t preferred_accuracy, - uint32_t preferred_time); -static const void* loc_get_extension(const char* name); -static const LocGpsInterface sLocEngInterface = -{ - sizeof(LocGpsInterface), - 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 -}; - -// Function declarations for sLocEngAGpsInterface -static void loc_agps_init(LocAGpsCallbacks* callbacks); -static int loc_agps_open(const char* apn); -static int loc_agps_closed(); -static int loc_agps_open_failed(); -static int loc_agps_set_server(LocAGpsType type, const char *hostname, int port); -static int loc_agps_open_with_apniptype( const char* apn, LocApnIpType apnIpType); - -static const LocAGpsInterface sLocEngAGpsInterface = -{ - sizeof(LocAGpsInterface), - loc_agps_init, - loc_agps_open, - loc_agps_closed, - loc_agps_open_failed, - loc_agps_set_server, - loc_agps_open_with_apniptype -}; - -static int loc_xtra_init(LocGpsXtraCallbacks* callbacks); -static int loc_xtra_inject_data(char* data, int length); - -static const LocGpsXtraInterface sLocEngXTRAInterface = -{ - sizeof(LocGpsXtraInterface), - loc_xtra_init, - loc_xtra_inject_data -}; - -static loc_gps_ni_notify_callback gps_ni_cb = NULL; -static void local_ni_cb(LocGpsNiNotification *notification, bool esEnalbed); - -static GpsNiExtCallbacks sGpsNiExtCallbacks = { - local_ni_cb -}; - -static void loc_ni_init(LocGpsNiCallbacks *callbacks); -static void loc_ni_respond(int notif_id, LocGpsUserResponseType user_response); - -static const LocGpsNiInterface sLocEngNiInterface = -{ - sizeof(LocGpsNiInterface), - loc_ni_init, - loc_ni_respond, -}; - -static int loc_gps_measurement_init(LocGpsMeasurementCallbacks* callbacks); -static void loc_gps_measurement_close(); - -static const LocGpsMeasurementInterface sLocEngGpsMeasurementInterface = -{ - sizeof(LocGpsMeasurementInterface), - loc_gps_measurement_init, - loc_gps_measurement_close -}; - -static void loc_agps_ril_init( LocAGpsRilCallbacks* callbacks ); -static void loc_agps_ril_set_ref_location(const LocAGpsRefLocation *agps_reflocation, size_t sz_struct); -static void loc_agps_ril_set_set_id(LocAGpsSetIDType 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 LocAGpsRilInterface sLocEngAGpsRilInterface = -{ - sizeof(LocAGpsRilInterface), - 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 -}; - -static int loc_agps_install_certificates(const LocDerEncodedCertificate* certificates, - size_t length); -static int loc_agps_revoke_certificates(const LocSha1CertificateFingerprint* fingerprints, - size_t length); - -static const LocSuplCertificateInterface sLocEngAGpsCertInterface = -{ - sizeof(LocSuplCertificateInterface), - loc_agps_install_certificates, - loc_agps_revoke_certificates -}; - -static void loc_configuration_update(const char* config_data, int32_t length); - -static const LocGnssConfigurationInterface sLocEngConfigInterface = -{ - sizeof(LocGnssConfigurationInterface), - loc_configuration_update -}; - -static loc_eng_data_s_type loc_afw_data; -static int gss_fd = -1; -static int sGnssType = GNSS_UNKNOWN; -/*=========================================================================== -FUNCTION loc_eng_gps_get_hardware_interface - -DESCRIPTION - Returns LocGpsInterface - if GPS is enabled. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -extern "C" const LocGpsInterface* loc_eng_gps_get_hardware_interface () -{ - ENTRY_LOG_CALLFLOW(); - const LocGpsInterface* ret_val; - - char propBuf[PROPERTY_VALUE_MAX]; - memset(propBuf, 0, sizeof(propBuf)); - - loc_eng_read_config(); - - // check to see if GPS should be disabled - platform_lib_abstraction_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; - } - - loc_eng_read_config(); - - EXIT_LOG(%p, ret_val); - return ret_val; -} - -extern "C" const LocGpsInterface* loc_eng_get_gps_interface() -{ - unsigned int target = TARGET_DEFAULT; - loc_eng_read_config(); - - target = loc_get_target(); - LOC_LOGD("Target name check returned %s", loc_get_target_name(target)); - - sGnssType = getTargetGnssType(target); - switch (sGnssType) - { - case GNSS_GSS: - case GNSS_AUTO: - //APQ8064 - gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB); - gss_fd = open("/dev/gss", O_RDONLY); - if (gss_fd < 0) { - LOC_LOGE("GSS open failed: %s\n", strerror(errno)); - } - else { - LOC_LOGD("GSS open success! CAPABILITIES %0lx\n", - gps_conf.CAPABILITIES); - } - break; - case GNSS_NONE: - //MPQ8064 - LOC_LOGE("No GPS HW on this target. Not returning interface."); - return NULL; - case GNSS_QCA1530: - // qca1530 chip is present - gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB); - LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES); - break; - } - 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(LocGpsCallbacks* callbacks) -{ - int retVal = -1; - unsigned int target = (unsigned int) -1; - ENTRY_LOG(); - LOC_API_ADAPTER_EVENT_MASK_T event; - - if (NULL == callbacks) { - LOC_LOGE("loc_init failed. cb = NULL\n"); - EXIT_LOG(%d, retVal); - return retVal; - } - - event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | - LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT | - 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; - - target = loc_get_target(); - - /* If platform is "auto" and external dr enabled then enable - ** Measurement report and SV Polynomial report - */ - if((1 == gps_conf.EXTERNAL_DR_ENABLED)) - { - event |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT | - LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT; - } - - LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */ - callbacks->status_cb, /* status_cb */ - local_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 */ - callbacks->request_utc_time_cb, /* request_utc_time_cb */ - callbacks->set_system_info_cb, /* set_system_info_cb */ - callbacks->gnss_sv_status_cb, /* gnss_sv_status_cb */ - }; - - gps_loc_cb = callbacks->location_cb; - gps_sv_cb = callbacks->sv_status_cb; - - retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL); - loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities(); - loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities(); - loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities() - && !loc_afw_data.adapter->hasNativeXtraClient(); - loc_afw_data.adapter->setGpsLockMsg(0); - loc_afw_data.adapter->requestUlp(ContextBase::getCarrierCapabilities()); - loc_afw_data.adapter->setXtraUserAgent(); - - if(retVal) { - LOC_LOGE("loc_eng_init() fail!"); - goto err; - } - - loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530); - loc_afw_data.adapter->setPowerVote(true); - - LOC_LOGD("loc_eng_init() success!"); - -err: - EXIT_LOG(%d, retVal); - return retVal; -} - -/*=========================================================================== -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_afw_data.adapter->setPowerVote(false); - loc_afw_data.adapter->setGpsLockMsg(gps_conf.GPS_LOCK); - - 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 = -1; - 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(LocGpsPositionMode mode, - LocGpsPositionRecurrence recurrence, - uint32_t min_interval, - uint32_t preferred_accuracy, - uint32_t preferred_time) -{ - ENTRY_LOG(); - int ret_val = -1; - LocPositionMode locMode; - switch (mode) { - case LOC_GPS_POSITION_MODE_MS_BASED: - locMode = LOC_POSITION_MODE_MS_BASED; - break; - case LOC_GPS_POSITION_MODE_MS_ASSISTED: - locMode = LOC_POSITION_MODE_MS_ASSISTED; - break; - default: - locMode = LOC_POSITION_MODE_STANDALONE; - break; - } - - // set position sharing option to true - bool sharePosition = true; - - LocPosMode params(locMode, recurrence, min_interval, - preferred_accuracy, preferred_time, - sharePosition, NULL, NULL); - ret_val = loc_eng_set_position_mode(loc_afw_data, params); - - 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(LocGpsUtcTime time, int64_t timeReference, int uncertainty) -{ - ENTRY_LOG(); - int ret_val = 0; - - 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 = 0; - 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 LocGpsAidingData matches with - LOC API specification. - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_delete_aiding_data(LocGpsAidingData f) -{ - ENTRY_LOG(); - -#ifndef TARGET_BUILD_VARIANT_USER - loc_eng_delete_aiding_data(loc_afw_data, f); -#endif - - EXIT_LOG(%s, VOID_RET); -} - -static const LocGpsGeofencingInterface* get_geofence_interface(void) -{ - ENTRY_LOG(); - void *handle; - const char *error; - typedef const LocGpsGeofencingInterface* (*get_gps_geofence_interface_function) (void); - get_gps_geofence_interface_function get_gps_geofence_interface; - static const LocGpsGeofencingInterface* geofence_interface = NULL; - - dlerror(); /* Clear any existing error */ - - handle = dlopen ("libgeofence.so", RTLD_NOW); - - if (!handle) - { - if ((error = dlerror()) != NULL) { - LOC_LOGE ("%s, dlopen for libgeofence.so failed, error = %s\n", __func__, error); - } - goto exit; - } - dlerror(); /* Clear any existing error */ - get_gps_geofence_interface = (get_gps_geofence_interface_function)dlsym(handle, "loc_gps_geofence_get_interface"); - if ((error = dlerror()) != NULL) { - LOC_LOGE ("%s, dlsym for get_gps_geofence_interface failed, error = %s\n", __func__, error); - goto exit; - } - if (NULL == get_gps_geofence_interface) { - LOC_LOGE ("%s, get_gps_geofence_interface is NULL\n", __func__); - goto exit; - } - - geofence_interface = get_gps_geofence_interface(); - -exit: - EXIT_LOG(%d, geofence_interface == NULL); - return geofence_interface; -} -/*=========================================================================== -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 - -===========================================================================*/ -const void* loc_get_extension(const char* name) -{ - ENTRY_LOG(); - const void* ret_val = NULL; - - LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name); - if (strcmp(name, LOC_GPS_XTRA_INTERFACE) == 0) - { - ret_val = &sLocEngXTRAInterface; - } - else if (strcmp(name, LOC_AGPS_INTERFACE) == 0) - { - ret_val = &sLocEngAGpsInterface; - } - else if (strcmp(name, LOC_GPS_NI_INTERFACE) == 0) - { - ret_val = &sLocEngNiInterface; - } - else if (strcmp(name, LOC_AGPS_RIL_INTERFACE) == 0) - { - char baseband[PROPERTY_VALUE_MAX]; - platform_lib_abstraction_property_get("ro.baseband", baseband, "msm"); - if (strcmp(baseband, "csfb") == 0) - { - ret_val = &sLocEngAGpsRilInterface; - } - } - else if (strcmp(name, LOC_GPS_GEOFENCING_INTERFACE) == 0) - { - if ((gps_conf.CAPABILITIES | LOC_GPS_CAPABILITY_GEOFENCING) == gps_conf.CAPABILITIES ){ - ret_val = get_geofence_interface(); - } - } - else if (strcmp(name, LOC_SUPL_CERTIFICATE_INTERFACE) == 0) - { - ret_val = &sLocEngAGpsCertInterface; - } - else if (strcmp(name, LOC_GNSS_CONFIGURATION_INTERFACE) == 0) - { - ret_val = &sLocEngConfigInterface; - } - else if (strcmp(name, LOC_GPS_MEASUREMENT_INTERFACE) == 0) - { - ret_val = &sLocEngGpsMeasurementInterface; - } - 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(LocAGpsCallbacks* callbacks) -{ - ENTRY_LOG(); - loc_eng_agps_init(loc_afw_data, (AGpsExtCallbacks*)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 - -===========================================================================*/ -static int loc_agps_open(const char* apn) -{ - ENTRY_LOG(); - LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL; - AGpsBearerType bearerType = AGPS_APN_BEARER_IPV4; - int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_open_with_apniptype - -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 - -===========================================================================*/ -static int loc_agps_open_with_apniptype(const char* apn, LocApnIpType apnIpType) -{ - ENTRY_LOG(); - LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL; - AGpsBearerType bearerType; - - switch (apnIpType) { - case LOC_APN_IP_IPV4: - bearerType = AGPS_APN_BEARER_IPV4; - break; - case LOC_APN_IP_IPV6: - bearerType = AGPS_APN_BEARER_IPV6; - break; - case LOC_APN_IP_IPV4V6: - bearerType = AGPS_APN_BEARER_IPV4V6; - break; - default: - bearerType = AGPS_APN_BEARER_IPV4; - break; - } - - int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -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 - -===========================================================================*/ -static int loc_agps_closed() -{ - ENTRY_LOG(); - LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL; - int ret_val = loc_eng_agps_closed(loc_afw_data, agpsType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -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 - -===========================================================================*/ -int loc_agps_open_failed() -{ - ENTRY_LOG(); - LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL; - int ret_val = loc_eng_agps_open_failed(loc_afw_data, agpsType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -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(LocAGpsType type, const char* hostname, int port) -{ - ENTRY_LOG(); - LocServerType serverType; - switch (type) { - case LOC_AGPS_TYPE_SUPL: - serverType = LOC_AGPS_SUPL_SERVER; - break; - case LOC_AGPS_TYPE_C2K: - serverType = LOC_AGPS_CDMA_PDE_SERVER; - break; - default: - serverType = LOC_AGPS_SUPL_SERVER; - } - int ret_val = loc_eng_set_server_proxy(loc_afw_data, serverType, hostname, port); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTIONf571 - loc_xtra_init - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_xtra_init(LocGpsXtraCallbacks* callbacks) -{ - ENTRY_LOG(); - GpsXtraExtCallbacks extCallbacks; - memset(&extCallbacks, 0, sizeof(extCallbacks)); - extCallbacks.download_request_cb = callbacks->download_request_cb; - int ret_val = loc_eng_xtra_init(loc_afw_data, &extCallbacks); - - 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 = -1; - if( (data != NULL) && ((unsigned int)length <= XTRA_DATA_MAX_SIZE)) - ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length); - else - LOC_LOGE("%s, Could not inject XTRA data. Buffer address: %p, length: %d", - __func__, data, length); - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_gps_measurement_init - -DESCRIPTION - This function initializes the gps measurement interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_gps_measurement_init(LocGpsMeasurementCallbacks* callbacks) -{ - ENTRY_LOG(); - int ret_val = loc_eng_gps_measurement_init(loc_afw_data, - callbacks); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_gps_measurement_close - -DESCRIPTION - This function closes the gps measurement interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_gps_measurement_close() -{ - ENTRY_LOG(); - loc_eng_gps_measurement_close(loc_afw_data); - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_ni_init - -DESCRIPTION - This function initializes the NI interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_ni_init(LocGpsNiCallbacks *callbacks) -{ - ENTRY_LOG(); - gps_ni_cb = callbacks->notify_cb; - loc_eng_ni_init(loc_afw_data, &sGpsNiExtCallbacks); - 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, LocGpsUserResponseType 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( LocAGpsRilCallbacks* callbacks ) {} -static void loc_agps_ril_set_ref_location(const LocAGpsRefLocation *agps_reflocation, size_t sz_struct) {} -static void loc_agps_ril_set_set_id(LocAGpsSetIDType 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); -} - -static int loc_agps_install_certificates(const LocDerEncodedCertificate* certificates, - size_t length) -{ - ENTRY_LOG(); - int ret_val = loc_eng_agps_install_certificates(loc_afw_data, certificates, length); - EXIT_LOG(%d, ret_val); - return ret_val; -} -static int loc_agps_revoke_certificates(const LocSha1CertificateFingerprint* fingerprints, - size_t length) -{ - ENTRY_LOG(); - LOC_LOGE("%s:%d] agps_revoke_certificates not supported", __func__, __LINE__); - int ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC; - EXIT_LOG(%d, ret_val); - return ret_val; -} - -static void loc_configuration_update(const char* config_data, int32_t length) -{ - ENTRY_LOG(); - loc_eng_configuration_update(loc_afw_data, config_data, length); - switch (sGnssType) - { - case GNSS_GSS: - case GNSS_AUTO: - case GNSS_QCA1530: - //APQ - gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB); - break; - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_loc_cb(UlpLocation* location, void* locExt) -{ - ENTRY_LOG(); - if (NULL != location) { - CALLBACK_LOG_CALLFLOW("location_cb - from", %d, location->position_source); - - if (NULL != gps_loc_cb) { - gps_loc_cb(&location->gpsLocation); - } - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_sv_cb(LocGpsSvStatus* 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); -} - -static void local_ni_cb(LocGpsNiNotification *notification, bool esEnalbed) -{ - if (NULL != gps_ni_cb) { - gps_ni_cb(notification); - } -} - diff --git a/loc_api/libloc_api_50001/loc.h b/loc_api/libloc_api_50001/loc.h deleted file mode 100644 index 9edd8c0a..00000000 --- a/loc_api/libloc_api_50001/loc.h +++ /dev/null @@ -1,66 +0,0 @@ -/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef __LOC_H__ -#define __LOC_H__ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include -#include - -#define XTRA_DATA_MAX_SIZE 100000 /*bytes*/ - -typedef void (*loc_location_cb_ext) (UlpLocation* location, void* locExt); -typedef void (*loc_sv_status_cb_ext) (LocGpsSvStatus* sv_status, void* svExt); -typedef void* (*loc_ext_parser)(void* data); - -typedef struct { - loc_location_cb_ext location_cb; - loc_gps_status_callback status_cb; - loc_sv_status_cb_ext sv_status_cb; - loc_gps_nmea_callback nmea_cb; - loc_gps_set_capabilities set_capabilities_cb; - loc_gps_acquire_wakelock acquire_wakelock_cb; - loc_gps_release_wakelock release_wakelock_cb; - loc_gps_create_thread create_thread_cb; - loc_ext_parser location_ext_parser; - loc_ext_parser sv_ext_parser; - loc_gps_request_utc_time request_utc_time_cb; - loc_gnss_set_system_info set_system_info_cb; - loc_gnss_sv_status_callback gnss_sv_status_cb; -} LocCallbacks; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif //__LOC_H__ diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp deleted file mode 100644 index 28ddcf79..00000000 --- a/loc_api/libloc_api_50001/loc_eng.cpp +++ /dev/null @@ -1,3125 +0,0 @@ -/* Copyright (c) 2009-2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include /* struct sockaddr_in */ -#include -#include -#include -#include -#include -#include - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "loc_core_log.h" -#include "loc_eng_log.h" - -#define SUCCESS TRUE -#define FAILURE FALSE - -#ifndef GPS_CONF_FILE -#define GPS_CONF_FILE "/etc/gps.conf" //??? platform independent -#endif - -#ifndef SAP_CONF_FILE -#define SAP_CONF_FILE "/etc/sap.conf" -#endif - -#define XTRA1_GPSONEXTRA "xtra1.gpsonextra.net" - -using namespace loc_core; - -boolean configAlreadyRead = false; -unsigned int agpsStatus = 0; - -/* Parameter spec table */ -static const loc_param_s_type gps_conf_table[] = -{ - {"GPS_LOCK", &gps_conf.GPS_LOCK, NULL, 'n'}, - {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'}, - {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'}, - {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'}, - {"LPPE_CP_TECHNOLOGY", &gps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'}, - {"LPPE_UP_TECHNOLOGY", &gps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'}, - {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}, - {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'}, - {"SUPL_ES", &gps_conf.SUPL_ES, NULL, 'n'}, - {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'}, - {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'}, - {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'}, - {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'}, - {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, - {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'}, - {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'}, - {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'}, - {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'}, - {"AGPS_CONFIG_INJECT", &gps_conf.AGPS_CONFIG_INJECT, NULL, 'n'}, - {"EXTERNAL_DR_ENABLED", &gps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'}, -}; - -static const loc_param_s_type sap_conf_table[] = -{ - {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'}, - {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'}, - {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'}, - {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'}, - {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'}, - {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'}, - {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, - {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'}, - {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, - {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'}, - {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'}, - {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'}, - {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'} -}; - -static void loc_default_parameters(void) -{ - /*Defaults for gps.conf*/ - gps_conf.INTERMEDIATE_POS = 0; - gps_conf.ACCURACY_THRES = 0; - gps_conf.NMEA_PROVIDER = 0; - gps_conf.GPS_LOCK = 0; - gps_conf.SUPL_VER = 0x10000; - gps_conf.SUPL_MODE = 0x3; - gps_conf.SUPL_ES = 0; - gps_conf.CAPABILITIES = 0x7; - /* LTE Positioning Profile configuration is disable by default*/ - gps_conf.LPP_PROFILE = 0; - /*By default no positioning protocol is selected on A-GLONASS system*/ - gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0; - /*XTRA version check is disabled by default*/ - gps_conf.XTRA_VERSION_CHECK=0; - /*Use emergency PDN by default*/ - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1; - /* By default no LPPe CP technology is enabled*/ - gps_conf.LPPE_CP_TECHNOLOGY = 0; - /* By default no LPPe UP technology is enabled*/ - gps_conf.LPPE_UP_TECHNOLOGY = 0; - - /*Defaults for sap.conf*/ - sap_conf.GYRO_BIAS_RANDOM_WALK = 0; - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2; - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5; - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2; - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5; - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4; - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25; - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4; - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25; - sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */ - sap_conf.SENSOR_USAGE = 0; /* Enabled */ - sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/ - /* Values MUST be set by OEMs in configuration for sensor-assisted - navigation to work. There are NO default values */ - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0; - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - /* default provider is SSC */ - sap_conf.SENSOR_PROVIDER = 1; - - /* None of the 10 slots for agps certificates are writable by default */ - gps_conf.AGPS_CERT_WRITABLE_MASK = 0; - - /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */ - gps_conf.AGPS_CONFIG_INJECT = 1; -} - -// 2nd half of init(), singled out for -// modem restart to use. -static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data); -static void loc_eng_dsclient_release(loc_eng_data_s_type &loc_eng_data); -static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data); - -static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char *hostname, int port); -// Internal functions -static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, - LocGpsStatusValue status); -static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data, - LocGpsStatusValue status); -static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data, - int connHandle, LocAGpsType agps_type); -static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ); -static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ; -static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ; - -static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data); -static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data); -static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data); -static void deleteAidingData(loc_eng_data_s_type &logEng); -static AgpsStateMachine* -getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType); -static void createAgnssNifs(loc_eng_data_s_type& locEng); -static int dataCallCb(void *cb_data); -static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) { - if (loc_eng_data.engine_status != LOC_GPS_STATUS_ENGINE_ON && - loc_eng_data.aiding_data_for_deletion != 0) - { - loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion); - loc_eng_data.aiding_data_for_deletion = 0; - } -} - -static void* noProc(void* data) -{ - return NULL; -} - -/********************************************************************* - * definitions of the static messages used in the file - *********************************************************************/ -// case LOC_ENG_MSG_REQUEST_NI: -LocEngRequestNi::LocEngRequestNi(void* locEng, - LocGpsNiNotification ¬if, - const void* data) : - LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) { - locallog(); -} -void LocEngRequestNi::proc() const { - loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng), - &mNotify, mPayload); -} -void LocEngRequestNi::locallog() const -{ - LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n " - "default response: %s\n requestor id encoding: %s\n" - " text encoding: %s\n passThroughData: %p", - mNotify.notification_id, - loc_get_ni_type_name(mNotify.ni_type), - mNotify.notify_flags, - mNotify.timeout, - loc_get_ni_response_name(mNotify.default_response), - loc_get_ni_encoding_name(mNotify.requestor_id_encoding), - loc_get_ni_encoding_name(mNotify.text_encoding), - mPayload); -} -inline void LocEngRequestNi::log() const { - locallog(); -} - -// case LOC_ENG_MSG_INFORM_NI_RESPONSE: -// in loc_eng_ni.cpp - -// case LOC_ENG_MSG_START_FIX: -LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngStartFix::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - loc_eng_start_handler(*locEng); -} -inline void LocEngStartFix::locallog() const -{ - LOC_LOGV("LocEngStartFix"); -} -inline void LocEngStartFix::log() const -{ - locallog(); -} -void LocEngStartFix::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_STOP_FIX: -LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngStopFix::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - mAdapter->clearGnssSvUsedListData(); - loc_eng_stop_handler(*locEng); -} -inline void LocEngStopFix::locallog() const -{ - LOC_LOGV("LocEngStopFix"); -} -inline void LocEngStopFix::log() const -{ - locallog(); -} -void LocEngStopFix::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_SET_POSITION_MODE: -LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter, - LocPosMode &mode) : - LocMsg(), mAdapter(adapter), mPosMode(mode) -{ - mPosMode.logv(); -} -inline void LocEngPositionMode::proc() const { - mAdapter->setPositionMode(&mPosMode); -} -inline void LocEngPositionMode::log() const { - mPosMode.logv(); -} -void LocEngPositionMode::send() const { - mAdapter->sendMsg(this); -} - -LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngGetZpp::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - loc_eng_get_zpp_handler(*locEng); -} -inline void LocEngGetZpp::locallog() const -{ - LOC_LOGV("LocEngGetZpp"); -} -inline void LocEngGetZpp::log() const -{ - locallog(); -} -void LocEngGetZpp::send() const { - mAdapter->sendMsg(this); -} - -struct LocEngSetTime : public LocMsg { - LocEngAdapter* mAdapter; - const LocGpsUtcTime mTime; - const int64_t mTimeReference; - const int mUncertainty; - inline LocEngSetTime(LocEngAdapter* adapter, - LocGpsUtcTime t, int64_t tf, int unc) : - LocMsg(), mAdapter(adapter), - mTime(t), mTimeReference(tf), mUncertainty(unc) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setTime(mTime, mTimeReference, mUncertainty); - } - inline void locallog() const { - LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d", - mTime, mTimeReference, mUncertainty); - } - inline virtual void log() const { - locallog(); - } -}; - - // case LOC_ENG_MSG_INJECT_LOCATION: -struct LocEngInjectLocation : public LocMsg { - LocEngAdapter* mAdapter; - const double mLatitude; - const double mLongitude; - const float mAccuracy; - inline LocEngInjectLocation(LocEngAdapter* adapter, - double lat, double lon, float accur) : - LocMsg(), mAdapter(adapter), - mLatitude(lat), mLongitude(lon), mAccuracy(accur) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy); - } - inline void locallog() const { - LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f", - mLatitude, mLongitude, mAccuracy); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SERVER_IPV4: -struct LocEngSetServerIpv4 : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned int mNlAddr; - const int mPort; - const LocServerType mServerType; - inline LocEngSetServerIpv4(LocEngAdapter* adapter, - unsigned int ip, - int port, - LocServerType type) : - LocMsg(), mAdapter(adapter), - mNlAddr(ip), mPort(port), mServerType(type) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setServer(mNlAddr, mPort, mServerType); - } - } - inline void locallog() const { - LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s", - mNlAddr, mPort, loc_get_server_type_name(mServerType)); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SERVER_URL: -struct LocEngSetServerUrl : public LocMsg { - LocEngAdapter* mAdapter; - const int mLen; - char* mUrl; - inline LocEngSetServerUrl(LocEngAdapter* adapter, - char* urlString, - int url_len) : - LocMsg(), mAdapter(adapter), - mLen(url_len), mUrl(new char[mLen+1]) - { - memcpy((void*)mUrl, (void*)urlString, url_len); - mUrl[mLen] = 0; - locallog(); - } - inline ~LocEngSetServerUrl() - { - delete[] mUrl; - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setServer(mUrl, mLen); - } - } - inline void locallog() const { - LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_A_GLONASS_PROTOCOL: -struct LocEngAGlonassProtocol : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned long mAGlonassProtocl; - inline LocEngAGlonassProtocol(LocEngAdapter* adapter, - unsigned long protocol) : - LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setAGLONASSProtocol(mAGlonassProtocl); - } - } - inline void locallog() const { - LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl); - } - inline virtual void log() const { - locallog(); - } -}; - - -struct LocEngLPPeProtocol : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned long mLPPeCP; - const unsigned long mLPPeUP; - inline LocEngLPPeProtocol(LocEngAdapter* adapter, - unsigned long lppeCP, unsigned long lppeUP) : - LocMsg(), mAdapter(adapter), mLPPeCP(lppeCP), mLPPeUP(lppeUP) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setLPPeProtocol(mLPPeCP, mLPPeUP); - } - inline void locallog() const { - LOC_LOGV("LPPe CP: 0x%lx LPPe UP: 0x%1x", mLPPeCP, mLPPeUP); - } - inline virtual void log() const { - locallog(); - } -}; - - -// case LOC_ENG_MSG_SUPL_VERSION: -struct LocEngSuplVer : public LocMsg { - LocEngAdapter* mAdapter; - const int mSuplVer; - inline LocEngSuplVer(LocEngAdapter* adapter, - int suplVer) : - LocMsg(), mAdapter(adapter), mSuplVer(suplVer) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setSUPLVersion(mSuplVer); - } - } - inline void locallog() const { - LOC_LOGV("SUPL Version: %d", mSuplVer); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngSuplMode : public LocMsg { - UlpProxyBase* mUlp; - - inline LocEngSuplMode(UlpProxyBase* ulp) : - LocMsg(), mUlp(ulp) - { - locallog(); - } - inline virtual void proc() const { - mUlp->setCapabilities(ContextBase::getCarrierCapabilities()); - } - inline void locallog() const { - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_NMEA_TYPE: -struct LocEngSetNmeaTypes : public LocMsg { - LocEngAdapter* mAdapter; - uint32_t nmeaTypesMask; - inline LocEngSetNmeaTypes(LocEngAdapter* adapter, - uint32_t typesMask) : - LocMsg(), mAdapter(adapter), nmeaTypesMask(typesMask) - { - locallog(); - } - inline virtual void proc() const { - // set the nmea types - mAdapter->setNMEATypes(nmeaTypesMask); - } - inline void locallog() const - { - LOC_LOGV("LocEngSetNmeaTypes %u\n",nmeaTypesMask); - } - inline virtual void log() const - { - locallog(); - } -}; - - -// case LOC_ENG_MSG_LPP_CONFIG: -struct LocEngLppConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mLppConfig; - inline LocEngLppConfig(LocEngAdapter* adapter, - int lppConfig) : - LocMsg(), mAdapter(adapter), mLppConfig(lppConfig) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setLPPConfig(mLppConfig); - } - } - inline void locallog() const { - LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG: -struct LocEngSensorControlConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mSensorsDisabled; - const int mSensorProvider; - inline LocEngSensorControlConfig(LocEngAdapter* adapter, - int sensorsDisabled, int sensorProvider) : - LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled), - mSensorProvider(sensorProvider) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider); - } - inline void locallog() const { - LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d", - mSensorsDisabled, mSensorProvider); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_PROPERTIES: -struct LocEngSensorProperties : public LocMsg { - LocEngAdapter* mAdapter; - const bool mGyroBiasVarianceRandomWalkValid; - const float mGyroBiasVarianceRandomWalk; - const bool mAccelRandomWalkValid; - const float mAccelRandomWalk; - const bool mAngleRandomWalkValid; - const float mAngleRandomWalk; - const bool mRateRandomWalkValid; - const float mRateRandomWalk; - const bool mVelocityRandomWalkValid; - const float mVelocityRandomWalk; - inline LocEngSensorProperties(LocEngAdapter* adapter, - bool gyroBiasRandomWalk_valid, - float gyroBiasRandomWalk, - bool accelRandomWalk_valid, - float accelRandomWalk, - bool angleRandomWalk_valid, - float angleRandomWalk, - bool rateRandomWalk_valid, - float rateRandomWalk, - bool velocityRandomWalk_valid, - float velocityRandomWalk) : - LocMsg(), mAdapter(adapter), - mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid), - mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk), - mAccelRandomWalkValid(accelRandomWalk_valid), - mAccelRandomWalk(accelRandomWalk), - mAngleRandomWalkValid(angleRandomWalk_valid), - mAngleRandomWalk(angleRandomWalk), - mRateRandomWalkValid(rateRandomWalk_valid), - mRateRandomWalk(rateRandomWalk), - mVelocityRandomWalkValid(velocityRandomWalk_valid), - mVelocityRandomWalk(velocityRandomWalk) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid, - mGyroBiasVarianceRandomWalk, - mAccelRandomWalkValid, - mAccelRandomWalk, - mAngleRandomWalkValid, - mAngleRandomWalk, - mRateRandomWalkValid, - mRateRandomWalk, - mVelocityRandomWalkValid, - mVelocityRandomWalk); - } - inline void locallog() const { - LOC_LOGV("Sensor properties validity, Gyro Random walk: %d " - "Accel Random Walk: %d " - "Angle Random Walk: %d Rate Random Walk: %d " - "Velocity Random Walk: %d\n" - "Sensor properties, Gyro Random walk: %f " - "Accel Random Walk: %f " - "Angle Random Walk: %f Rate Random Walk: %f " - "Velocity Random Walk: %f", - mGyroBiasVarianceRandomWalkValid, - mAccelRandomWalkValid, - mAngleRandomWalkValid, - mRateRandomWalkValid, - mVelocityRandomWalkValid, - mGyroBiasVarianceRandomWalk, - mAccelRandomWalk, - mAngleRandomWalk, - mRateRandomWalk, - mVelocityRandomWalk - ); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG: -struct LocEngSensorPerfControlConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mControlMode; - const int mAccelSamplesPerBatch; - const int mAccelBatchesPerSec; - const int mGyroSamplesPerBatch; - const int mGyroBatchesPerSec; - const int mAccelSamplesPerBatchHigh; - const int mAccelBatchesPerSecHigh; - const int mGyroSamplesPerBatchHigh; - const int mGyroBatchesPerSecHigh; - const int mAlgorithmConfig; - inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter, - int controlMode, - int accelSamplesPerBatch, - int accelBatchesPerSec, - int gyroSamplesPerBatch, - int gyroBatchesPerSec, - int accelSamplesPerBatchHigh, - int accelBatchesPerSecHigh, - int gyroSamplesPerBatchHigh, - int gyroBatchesPerSecHigh, - int algorithmConfig) : - LocMsg(), mAdapter(adapter), - mControlMode(controlMode), - mAccelSamplesPerBatch(accelSamplesPerBatch), - mAccelBatchesPerSec(accelBatchesPerSec), - mGyroSamplesPerBatch(gyroSamplesPerBatch), - mGyroBatchesPerSec(gyroBatchesPerSec), - mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh), - mAccelBatchesPerSecHigh(accelBatchesPerSecHigh), - mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh), - mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh), - mAlgorithmConfig(algorithmConfig) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorPerfControlConfig(mControlMode, - mAccelSamplesPerBatch, - mAccelBatchesPerSec, - mGyroSamplesPerBatch, - mGyroBatchesPerSec, - mAccelSamplesPerBatchHigh, - mAccelBatchesPerSecHigh, - mGyroSamplesPerBatchHigh, - mGyroBatchesPerSecHigh, - mAlgorithmConfig); - } - inline void locallog() const { - LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) " - "accel(#smp,#batches) (%u,%u) " - "gyro(#smp,#batches) (%u,%u), " - "accel_high(#smp,#batches) (%u,%u) " - "gyro_high(#smp,#batches) (%u,%u), " - "algorithmConfig(%u)\n", - mControlMode, - mAccelSamplesPerBatch, mAccelBatchesPerSec, - mGyroSamplesPerBatch, mGyroBatchesPerSec, - mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh, - mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh, - mAlgorithmConfig); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_REPORT_POSITION: -LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter, - UlpLocation &loc, - GpsLocationExtended &locExtended, - void* locExt, - enum loc_sess_status st, - LocPosTechMask technology) : - LocMsg(), mAdapter(adapter), mLocation(loc), - mLocationExtended(locExtended), - mLocationExt(((loc_eng_data_s_type*) - ((LocEngAdapter*) - (mAdapter))->getOwner())->location_ext_parser(locExt)), - mStatus(st), mTechMask(technology) -{ - locallog(); -} -void LocEngReportPosition::proc() const { - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) { - bool reported = false; - if (locEng->location_cb != NULL) { - if (LOC_SESS_FAILURE == mStatus) { - // in case we want to handle the failure case - locEng->location_cb(NULL, NULL); - reported = true; - } - // what's in the else if is... (line by line) - // 1. this is a final fix; and - // 1.1 it is a Satellite fix; or - // 1.2 it is a sensor fix - // 2. (must be intermediate fix... implicit) - // 2.1 we accepte intermediate; and - // 2.2 it is NOT the case that - // 2.2.1 there is inaccuracy; and - // 2.2.2 we care about inaccuracy; and - // 2.2.3 the inaccuracy exceeds our tolerance - else if ((LOC_SESS_SUCCESS == mStatus && - ((LOC_POS_TECH_MASK_SATELLITE | - LOC_POS_TECH_MASK_SENSORS | - LOC_POS_TECH_MASK_HYBRID) & - mTechMask)) || - (LOC_SESS_INTERMEDIATE == locEng->intermediateFix && - !((mLocation.gpsLocation.flags & - LOC_GPS_LOCATION_HAS_ACCURACY) && - (gps_conf.ACCURACY_THRES != 0) && - (mLocation.gpsLocation.accuracy > - gps_conf.ACCURACY_THRES)))) { - if (mLocationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) - { - adapter->setGnssSvUsedListData(mLocationExtended.gnss_sv_used_ids); - } - locEng->location_cb((UlpLocation*)&(mLocation), - (void*)mLocationExt); - reported = true; - } - } - - // if we have reported this fix - if (reported && - // and if this is a singleshot - LOC_GPS_POSITION_RECURRENCE_SINGLE == - locEng->adapter->getPositionMode().recurrence) { - if (LOC_SESS_INTERMEDIATE == mStatus) { - // modem could be still working for a final fix, - // although we no longer need it. So stopFix(). - locEng->adapter->stopFix(); - } - // turn off the session flag. - locEng->adapter->setInSession(false); - } - - LOC_LOGV("LocEngReportPosition::proc() - generateNmea: %d, position source: %d, " - "engine_status: %d, isInSession: %d", - locEng->generateNmea, mLocation.position_source, - locEng->engine_status, locEng->adapter->isInSession()); - - if (locEng->generateNmea && - locEng->adapter->isInSession()) - { - unsigned char generate_nmea = reported && - (mStatus != LOC_SESS_FAILURE); - loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended, - generate_nmea); - } - - // Free the allocated memory for rawData - UlpLocation* gp = (UlpLocation*)&(mLocation); - if (gp != NULL && gp->rawData != NULL) - { - delete (char*)gp->rawData; - gp->rawData = NULL; - gp->rawDataSize = 0; - } - } -} -void LocEngReportPosition::locallog() const { - LOC_LOGV("LocEngReportPosition"); -} -void LocEngReportPosition::log() const { - locallog(); -} -void LocEngReportPosition::send() const { - mAdapter->sendMsg(this); -} - - -// case LOC_ENG_MSG_REPORT_SV: -LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter, - LocGnssSvStatus &sv, - GpsLocationExtended &locExtended, - void* svExt) : - LocMsg(), mAdapter(adapter), mSvStatus(sv), - mLocationExtended(locExtended), - mSvExt(((loc_eng_data_s_type*) - ((LocEngAdapter*) - (mAdapter))->getOwner())->sv_ext_parser(svExt)) -{ - locallog(); -} -void LocEngReportSv::proc() const { - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - LocGnssSvStatus gnssSvStatus; - memcpy(&gnssSvStatus,&mSvStatus,sizeof(LocGnssSvStatus)); - if (adapter->isGnssSvIdUsedInPosAvail()) - { - GnssSvUsedInPosition gnssSvIdUsedInPosition = - adapter->getGnssSvUsedListData(); - int numSv = gnssSvStatus.num_svs; - int16_t gnssSvId = 0; - int prnMin = 0; - uint64_t svUsedIdMask = 0; - for (int i=0; i < numSv; i++) - { - gnssSvId = gnssSvStatus.gnss_sv_list[i].svid; - if (gnssSvId <= GPS_SV_PRN_MAX) - { - svUsedIdMask = gnssSvIdUsedInPosition.gps_sv_used_ids_mask; - prnMin = GPS_SV_PRN_MIN; - } - else if ((gnssSvId >= GLO_SV_PRN_MIN) && (gnssSvId <= GLO_SV_PRN_MAX)) - { - svUsedIdMask = gnssSvIdUsedInPosition.glo_sv_used_ids_mask; - prnMin = GLO_SV_PRN_MIN; - } - else if ((gnssSvId >= BDS_SV_PRN_MIN) && (gnssSvId <= BDS_SV_PRN_MAX)) - { - svUsedIdMask = gnssSvIdUsedInPosition.bds_sv_used_ids_mask; - prnMin = BDS_SV_PRN_MIN; - } - else if ((gnssSvId >= GAL_SV_PRN_MIN) && (gnssSvId <= GAL_SV_PRN_MAX)) - { - svUsedIdMask = gnssSvIdUsedInPosition.gal_sv_used_ids_mask; - prnMin = GAL_SV_PRN_MIN; - } - - // If SV ID was used in previous position fix, then set USED_IN_FIX - // flag, else clear the USED_IN_FIX flag. - if (svUsedIdMask & (1 << (gnssSvId - prnMin))) - { - gnssSvStatus.gnss_sv_list[i].flags |= LOC_GNSS_SV_FLAGS_USED_IN_FIX; - } - else - { - gnssSvStatus.gnss_sv_list[i].flags &= ~LOC_GNSS_SV_FLAGS_USED_IN_FIX; - } - } - } - - if (locEng->gnss_sv_status_cb != NULL) { - LOC_LOGE("Calling gnss_sv_status_cb"); - locEng->gnss_sv_status_cb((LocGnssSvStatus*)&(gnssSvStatus)); - } - - if (locEng->generateNmea) - { - loc_eng_nmea_generate_sv(locEng, gnssSvStatus, mLocationExtended); - } - } -} -void LocEngReportSv::locallog() const { - LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__); -} -inline void LocEngReportSv::log() const { - locallog(); -} -void LocEngReportSv::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_REPORT_STATUS: -LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter, - LocGpsStatusValue engineStatus) : - LocMsg(), mAdapter(adapter), mStatus(engineStatus) -{ - locallog(); -} -inline void LocEngReportStatus::proc() const -{ - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - loc_eng_report_status(*locEng, mStatus); - update_aiding_data_for_deletion(*locEng); -} -inline void LocEngReportStatus::locallog() const { - LOC_LOGV("LocEngReportStatus"); -} -inline void LocEngReportStatus::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REPORT_NMEA: -LocEngReportNmea::LocEngReportNmea(void* locEng, - const char* data, int len) : - LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len) -{ - memcpy((void*)mNmea, (void*)data, len); - locallog(); -} -void LocEngReportNmea::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; - - struct timeval tv; - gettimeofday(&tv, (struct timezone *) NULL); - int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; - - if (locEng->nmea_cb != NULL) - locEng->nmea_cb(now, mNmea, mLen); -} -inline void LocEngReportNmea::locallog() const { - LOC_LOGV("LocEngReportNmea"); -} -inline void LocEngReportNmea::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REPORT_XTRA_SERVER: -LocEngReportXtraServer::LocEngReportXtraServer(void* locEng, - const char *url1, - const char *url2, - const char *url3, - const int maxlength) : - LocMsg(), mLocEng(locEng), mMaxLen(maxlength), - mServers(new char[3*(mMaxLen+1)]) -{ - char * cptr = mServers; - memset(mServers, 0, 3*(mMaxLen+1)); - - // Override modem URLs with uncommented gps.conf urls - if( gps_conf.XTRA_SERVER_1[0] != '\0' ) { - url1 = &gps_conf.XTRA_SERVER_1[0]; - } - if( gps_conf.XTRA_SERVER_2[0] != '\0' ) { - url2 = &gps_conf.XTRA_SERVER_2[0]; - } - if( gps_conf.XTRA_SERVER_3[0] != '\0' ) { - url3 = &gps_conf.XTRA_SERVER_3[0]; - } - // copy non xtra1.gpsonextra.net URLs into the forwarding buffer. - if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url1, mMaxLen + 1); - cptr += mMaxLen + 1; - } - if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url2, mMaxLen + 1); - cptr += mMaxLen + 1; - } - if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url3, mMaxLen + 1); - } - locallog(); -} - -void LocEngReportXtraServer::proc() const { - loc_eng_xtra_data_s_type* locEngXtra = - &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data); - - if (locEngXtra->report_xtra_server_cb != NULL) { - CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers); - locEngXtra->report_xtra_server_cb(mServers, - &(mServers[mMaxLen+1]), - &(mServers[(mMaxLen+1)<<1])); - } else { - LOC_LOGE("Callback function for request xtra is NULL"); - } -} -inline void LocEngReportXtraServer::locallog() const { - LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n" - " server3: %s\n", - mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]); -} -inline void LocEngReportXtraServer::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_BIT: -// case LOC_ENG_MSG_RELEASE_BIT: -LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type, - int ipv4, char* ipv6, bool isReq) : - LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4), - mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) { - if (NULL != ipv6) - memcpy(mIPv6Addr, ipv6, 16); - locallog(); -} -inline LocEngReqRelBIT::~LocEngReqRelBIT() { - if (mIPv6Addr) { - delete[] mIPv6Addr; - } -} -void LocEngReqRelBIT::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - BITSubscriber s(getAgpsStateMachine(*locEng, mType), - mIPv4Addr, mIPv6Addr); - AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine; - - if (mIsReq) { - sm->subscribeRsrc((Subscriber*)&s); - } else { - sm->unsubscribeRsrc((Subscriber*)&s); - } -} -inline void LocEngReqRelBIT::locallog() const { - LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s", - (unsigned char)mIPv4Addr, - (unsigned char)(mIPv4Addr>>8), - (unsigned char)(mIPv4Addr>>16), - (unsigned char)(mIPv4Addr>>24), - NULL != mIPv6Addr ? mIPv6Addr : ""); -} -inline void LocEngReqRelBIT::log() const { - locallog(); -} -void LocEngReqRelBIT::send() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->sendMsg(this); -} - -// case LOC_ENG_MSG_RELEASE_BIT: -struct LocEngReleaseBIT : public LocMsg { - const BITSubscriber mSubscriber; - inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine, - unsigned int ipv4, char* ipv6) : - LocMsg(), - mSubscriber(stateMachine, ipv4, ipv6) - { - locallog(); - } - inline virtual void proc() const - { - AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine; - sm->unsubscribeRsrc((Subscriber*)&mSubscriber); - } - inline void locallog() const { - LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s", - (unsigned char)(mSubscriber.ID>>24), - (unsigned char)(mSubscriber.ID>>16), - (unsigned char)(mSubscriber.ID>>8), - (unsigned char)mSubscriber.ID, - NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : ""); - } - virtual void log() const { - locallog(); - } -}; - -// LocEngSuplEsOpened -LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -void LocEngSuplEsOpened::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif) { - AgpsStateMachine* sm = locEng->ds_nif; - sm->onRsrcEvent(RSRC_GRANTED); - } -} -void LocEngSuplEsOpened::locallog() const { - LOC_LOGV("LocEngSuplEsOpened"); -} -void LocEngSuplEsOpened::log() const { - locallog(); -} - -// LocEngSuplEsClosed -LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -void LocEngSuplEsClosed::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif) { - AgpsStateMachine* sm = locEng->ds_nif; - sm->onRsrcEvent(RSRC_RELEASED); - } -} -void LocEngSuplEsClosed::locallog() const { - LOC_LOGV("LocEngSuplEsClosed"); -} -void LocEngSuplEsClosed::log() const { - locallog(); -} - - -// case LOC_ENG_MSG_REQUEST_SUPL_ES: -LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) : - LocMsg(), mLocEng(locEng), mID(id) { - locallog(); -} -void LocEngRequestSuplEs::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - AgpsStateMachine* sm = locEng->ds_nif; - DSSubscriber s(sm, mID); - sm->subscribeRsrc((Subscriber*)&s); - } - else if (locEng->agnss_nif) { - AgpsStateMachine *sm = locEng->agnss_nif; - ATLSubscriber s(mID, - sm, - locEng->adapter, - false); - sm->subscribeRsrc((Subscriber*)&s); - LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__); - } - else { - locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1); - } -} -inline void LocEngRequestSuplEs::locallog() const { - LOC_LOGV("LocEngRequestSuplEs"); -} -inline void LocEngRequestSuplEs::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_ATL: -LocEngRequestATL::LocEngRequestATL(void* locEng, int id, - AGpsExtType agps_type) : - LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) { - locallog(); -} -void LocEngRequestATL::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - AgpsStateMachine* sm = (AgpsStateMachine*) - getAgpsStateMachine(*locEng, mType); - if (sm) { - ATLSubscriber s(mID, - sm, - locEng->adapter, - LOC_AGPS_TYPE_INVALID == mType); - sm->subscribeRsrc((Subscriber*)&s); - } else { - locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType); - } -} -inline void LocEngRequestATL::locallog() const { - LOC_LOGV("LocEngRequestATL"); -} -inline void LocEngRequestATL::log() const { - locallog(); -} - -// case LOC_ENG_MSG_RELEASE_ATL: -LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) : - LocMsg(), mLocEng(locEng), mID(id) { - locallog(); -} -void LocEngReleaseATL::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - - if (locEng->agnss_nif) { - ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false); - if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) { - LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif", - __func__, __LINE__); - return; - } - } - - if (locEng->internet_nif) { - ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false); - if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) { - LOC_LOGD("%s:%d]: Unsubscribed from internet_nif", - __func__, __LINE__); - return; - } - } - - if (locEng->ds_nif) { - DSSubscriber s3(locEng->ds_nif, mID); - if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) { - LOC_LOGD("%s:%d]: Unsubscribed from ds_nif", - __func__, __LINE__); - return; - } - } - - LOC_LOGW("%s:%d]: Could not release ATL. " - "No subscribers found\n", - __func__, __LINE__); - locEng->adapter->atlCloseStatus(mID, 0); -} -inline void LocEngReleaseATL::locallog() const { - LOC_LOGV("LocEngReleaseATL"); -} -inline void LocEngReleaseATL::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_WIFI: -// case LOC_ENG_MSG_RELEASE_WIFI: -LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type, - loc_if_req_sender_id_e_type sender_id, - char* s, char* p, bool isReq) : - LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id), - mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]), - mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]), - mIsReq(isReq) { - if (NULL != s) - strlcpy(mSSID, s, SSID_BUF_SIZE); - if (NULL != p) - strlcpy(mPassword, p, SSID_BUF_SIZE); - locallog(); -} -LocEngReqRelWifi::~LocEngReqRelWifi() { - if (NULL != mSSID) { - delete[] mSSID; - } - if (NULL != mPassword) { - delete[] mPassword; - } -} -void LocEngReqRelWifi::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType); -} -inline void LocEngReqRelWifi::locallog() const { - LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s", - mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi", - mSenderId, - NULL != mSSID ? mSSID : "", - NULL != mPassword ? mPassword : ""); -} -inline void LocEngReqRelWifi::log() const { - locallog(); -} -void LocEngReqRelWifi::send() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->sendMsg(this); -} - -// case LOC_ENG_MSG_REQUEST_XTRA_DATA: -LocEngRequestXtra::LocEngRequestXtra(void* locEng) : - mLocEng(locEng) { - locallog(); -} -void LocEngRequestXtra::proc() const -{ - loc_eng_xtra_data_s_type* locEngXtra = - &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data); - - if (locEngXtra->download_request_cb != NULL) { - CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng); - locEngXtra->download_request_cb(); - } else { - LOC_LOGE("Callback function for request xtra is NULL"); - } -} -inline void LocEngRequestXtra::locallog() const { - LOC_LOGV("LocEngReqXtra"); -} -inline void LocEngRequestXtra::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_TIME: -LocEngRequestTime::LocEngRequestTime(void* locEng) : - LocMsg(), mLocEng(locEng) -{ - locallog(); -} -void LocEngRequestTime::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_ON_DEMAND_TIME) { - if (locEng->request_utc_time_cb != NULL) { - locEng->request_utc_time_cb(); - } else { - LOC_LOGE("Callback function for request time is NULL"); - } - } -} -inline void LocEngRequestTime::locallog() const { - LOC_LOGV("LocEngReqTime"); -} -inline void LocEngRequestTime::log() const { - locallog(); -} - -// case LOC_ENG_MSG_DELETE_AIDING_DATA: -struct LocEngDelAidData : public LocMsg { - loc_eng_data_s_type* mLocEng; - const LocGpsAidingData mType; - inline LocEngDelAidData(loc_eng_data_s_type* locEng, - LocGpsAidingData f) : - LocMsg(), mLocEng(locEng), mType(f) - { - locallog(); - } - inline virtual void proc() const { - mLocEng->aiding_data_for_deletion = mType; - update_aiding_data_for_deletion(*mLocEng); - } - inline void locallog() const { - LOC_LOGV("aiding data msak %d", mType); - } - virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ENABLE_DATA: -struct LocEngEnableData : public LocMsg { - LocEngAdapter* mAdapter; - const int mEnable; - char* mAPN; - const int mLen; - inline LocEngEnableData(LocEngAdapter* adapter, - const char* name, int len, int enable) : - LocMsg(), mAdapter(adapter), - mEnable(enable), mAPN(NULL), mLen(len) - { - if (NULL != name) { - mAPN = new char[len+1]; - memcpy((void*)mAPN, (void*)name, len); - mAPN[len] = 0; - } - locallog(); - } - inline ~LocEngEnableData() { - if (NULL != mAPN) { - delete[] mAPN; - } - } - inline virtual void proc() const { - mAdapter->enableData(mEnable); - if (NULL != mAPN) { - mAdapter->setAPN(mAPN, mLen); - } - } - inline void locallog() const { - LOC_LOGV("apn: %s\n enable: %d", - (NULL == mAPN) ? "NULL" : mAPN, mEnable); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_INJECT_XTRA_DATA: -// loc_eng_xtra.cpp - -// case LOC_ENG_MSG_SET_CAPABILITIES: -struct LocEngSetCapabilities : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - if (NULL != mLocEng->set_capabilities_cb) { - LOC_LOGV("calling set_capabilities_cb 0x%x", - gps_conf.CAPABILITIES); - mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES); - } else { - LOC_LOGV("set_capabilities_cb is NULL.\n"); - } - } - inline void locallog() const - { - LOC_LOGV("LocEngSetCapabilities"); - } - inline virtual void log() const - { - locallog(); - } -}; - -struct LocEngSetSystemInfo : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - if (NULL != mLocEng->set_system_info_cb) { - LOC_LOGV("calling set_system_info_cb 0x%x", - mLocEng->adapter->mGnssInfo.year_of_hw); - mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo)); - } - else { - LOC_LOGV("set_system_info_cb is NULL.\n"); - } - } - inline void locallog() const - { - LOC_LOGV("LocEngSetSystemInfo"); - } - inline virtual void log() const - { - locallog(); - } -}; -// case LOC_ENG_MSG_LOC_INIT: -struct LocEngInit : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngInit(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - loc_eng_reinit(*mLocEng); - // set the capabilities - mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng)); - mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng)); - } - inline void locallog() const - { - LOC_LOGV("LocEngInit"); - } - inline virtual void log() const - { - locallog(); - } -}; - -// case LOC_ENG_MSG_REQUEST_XTRA_SERVER: -// loc_eng_xtra.cpp - -// case LOC_ENG_MSG_ATL_OPEN_SUCCESS: -struct LocEngAtlOpenSuccess : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - const int mLen; - char* mAPN; - const AGpsBearerType mBearerType; - inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType, - const char* name, - int len, - AGpsBearerType btype) : - LocMsg(), - mLocEng(locEng), mAgpsType(agpsType), mLen(len), - mAPN(new char[len+1]), mBearerType(btype) - { - memcpy((void*)mAPN, (void*)name, len); - mAPN[len] = 0; - locallog(); - } - inline ~LocEngAtlOpenSuccess() - { - delete[] mAPN; - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->setBearer(mBearerType); - sm->setAPN(mAPN, mLen); - sm->onRsrcEvent(RSRC_GRANTED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n" - " bearer type: %s", - loc_get_agps_type_name(mAgpsType), - mAPN, - loc_get_agps_bear_name(mBearerType)); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ATL_CLOSED: -struct LocEngAtlClosed : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - inline LocEngAtlClosed(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType) : - LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { - locallog(); - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->onRsrcEvent(RSRC_RELEASED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlClosed"); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ATL_OPEN_FAILED: -struct LocEngAtlOpenFailed : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType) : - LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { - locallog(); - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->onRsrcEvent(RSRC_DENIED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlOpenFailed"); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ENGINE_DOWN: -LocEngDown::LocEngDown(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -inline void LocEngDown::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - loc_eng_handle_engine_down(*locEng); -} -inline void LocEngDown::locallog() const { - LOC_LOGV("LocEngDown"); -} -inline void LocEngDown::log() const { - locallog(); -} - -// case LOC_ENG_MSG_ENGINE_UP: -LocEngUp::LocEngUp(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -inline void LocEngUp::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - loc_eng_handle_engine_up(*locEng); -} -inline void LocEngUp::locallog() const { - LOC_LOGV("LocEngUp"); -} -inline void LocEngUp::log() const { - locallog(); -} - -struct LocEngAgnssNifInit : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); - } - virtual void proc() const { - createAgnssNifs(*mLocEng); - } - void locallog() const { - LOC_LOGV("LocEngAgnssNifInit\n"); - } - virtual void log() const { - locallog(); - } -}; - -struct LocEngInstallAGpsCert : public LocMsg { - LocEngAdapter* mpAdapter; - const size_t mNumberOfCerts; - const uint32_t mSlotBitMask; - LocDerEncodedCertificate* mpData; - inline LocEngInstallAGpsCert(LocEngAdapter* adapter, - const LocDerEncodedCertificate* pData, - size_t numberOfCerts, - uint32_t slotBitMask) : - LocMsg(), mpAdapter(adapter), - mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask), - mpData(new LocDerEncodedCertificate[mNumberOfCerts]) - { - for (int i=0; i < mNumberOfCerts; i++) { - mpData[i].data = new u_char[pData[i].length]; - if (mpData[i].data) { - memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length); - mpData[i].length = pData[i].length; - } else { - LOC_LOGE("malloc failed for cert#%d", i); - break; - } - } - locallog(); - } - inline ~LocEngInstallAGpsCert() - { - for (int i=0; i < mNumberOfCerts; i++) { - if (mpData[i].data) { - delete[] mpData[i].data; - } - } - delete[] mpData; - } - inline virtual void proc() const { - mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask); - } - inline void locallog() const { - LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u", - mNumberOfCerts, mSlotBitMask); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngGnssConstellationConfig : public LocMsg { - LocEngAdapter* mAdapter; - inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) { - locallog(); - } - inline virtual void proc() const { - mAdapter->mGnssInfo.size = sizeof(LocGnssSystemInfo); - if (mAdapter->gnssConstellationConfig()) { - LOC_LOGV("Modem supports GNSS measurements\n"); - gps_conf.CAPABILITIES |= LOC_GPS_CAPABILITY_MEASUREMENTS; - mAdapter->mGnssInfo.year_of_hw = 2016; - } else { - mAdapter->mGnssInfo.year_of_hw = 2015; - LOC_LOGV("Modem does not support GNSS measurements\n"); - } - } - void locallog() const { - LOC_LOGV("LocEngGnssConstellationConfig\n"); - } - virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT: -LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng, - LocGnssData &gnssData) : - LocMsg(), mLocEng(locEng), mGnssData(gnssData) -{ - locallog(); -} -void LocEngReportGnssMeasurement::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - if (locEng->gnss_measurement_cb != NULL) { - LOC_LOGV("Calling gnss_measurement_cb"); - locEng->gnss_measurement_cb((LocGnssData*)&(mGnssData)); - } - } -} -void LocEngReportGnssMeasurement::locallog() const { - IF_LOC_LOGV { - LOC_LOGV("%s:%d]: Received in GPS HAL." - "GNSS Measurements count: %d \n", - __func__, __LINE__, mGnssData.measurement_count); - for (int i =0; i< mGnssData.measurement_count && i < LOC_GNSS_MAX_SVS; i++) { - LOC_LOGV(" GNSS measurement data in GPS HAL: \n" - " GPS_HAL => Measurement ID | svid | time_offset_ns | state |" - " c_n0_dbhz | pseudorange_rate_mps |" - " pseudorange_rate_uncertainty_mps |" - " accumulated_delta_range_state | flags \n" - " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n", - i, - mGnssData.measurements[i].svid, - mGnssData.measurements[i].time_offset_ns, - mGnssData.measurements[i].state, - mGnssData.measurements[i].c_n0_dbhz, - mGnssData.measurements[i].pseudorange_rate_mps, - mGnssData.measurements[i].pseudorange_rate_uncertainty_mps, - mGnssData.measurements[i].accumulated_delta_range_state, - mGnssData.measurements[i].flags); - } - LOC_LOGV(" GPS_HAL => Clocks Info: \n" - " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | " - " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags" - " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n", - mGnssData.clock.time_ns, - mGnssData.clock.full_bias_ns, - mGnssData.clock.bias_ns, - mGnssData.clock.bias_uncertainty_ns, - mGnssData.clock.drift_nsps, - mGnssData.clock.drift_uncertainty_nsps, - mGnssData.clock.hw_clock_discontinuity_count, - mGnssData.clock.flags); - } -} -inline void LocEngReportGnssMeasurement::log() const { - locallog(); -} - -/********************************************************************* - * Initialization checking macros - *********************************************************************/ -#define STATE_CHECK(ctx, x, ret) \ - if (!(ctx)) \ - { \ - /* Not intialized, abort */\ - LOC_LOGE("%s: log_eng state error: %s", __func__, x); \ - EXIT_LOG(%s, x); \ - ret; \ - } -#define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret) - -/*=========================================================================== -FUNCTION loc_eng_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/A - -===========================================================================*/ -int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, - LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context) - -{ - int ret_val = 0; - - ENTRY_LOG_CALLFLOW(); - if (NULL == callbacks || 0 == event) { - LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event); - ret_val = -1; - EXIT_LOG(%d, ret_val); - return ret_val; - } - - STATE_CHECK((NULL == loc_eng_data.adapter), - "instance already initialized", return 0); - - memset(&loc_eng_data, 0, sizeof (loc_eng_data)); - - // Save callbacks - loc_eng_data.location_cb = callbacks->location_cb; - loc_eng_data.sv_status_cb = callbacks->sv_status_cb; - loc_eng_data.status_cb = callbacks->status_cb; - loc_eng_data.nmea_cb = callbacks->nmea_cb; - loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb; - loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb; - loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb; - loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb; - loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb; - loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb; - loc_eng_data.location_ext_parser = callbacks->location_ext_parser ? - callbacks->location_ext_parser : noProc; - loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ? - callbacks->sv_ext_parser : noProc; - loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS; - // initial states taken care of by the memset above - // loc_eng_data.engine_status -- LOC_GPS_STATUS_NONE; - // loc_eng_data.fix_session_status -- LOC_GPS_STATUS_NONE; - // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE; - - if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP)) - { - event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report - loc_eng_data.generateNmea = true; - } - else if (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_MP) - { - loc_eng_data.generateNmea = false; - } - - loc_eng_data.adapter = - new LocEngAdapter(event, &loc_eng_data, context, - (LocThread::tCreate)callbacks->create_thread_cb); - - loc_eng_data.adapter->mGnssInfo.size = sizeof(LocGnssSystemInfo); - loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015; - LOC_LOGD("loc_eng_init created client, id = %p\n", - loc_eng_data.adapter); - loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data)); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - LocEngAdapter* adapter = loc_eng_data.adapter; - - adapter->sendMsg(new LocEngGnssConstellationConfig(adapter)); - adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); - adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); - adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE, - sap_conf.SENSOR_PROVIDER)); - adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); - adapter->sendMsg(new LocEngLPPeProtocol(adapter, gps_conf.LPPE_CP_TECHNOLOGY, - gps_conf.LPPE_UP_TECHNOLOGY)); - - if (!loc_eng_data.generateNmea) - { - NmeaSentenceTypesMask typesMask = LOC_NMEA_ALL_SUPPORTED_MASK; - LOC_LOGD("loc_eng_init setting nmea types, mask = %u\n",typesMask); - adapter->sendMsg(new LocEngSetNmeaTypes(adapter,typesMask)); - } - - /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */ - if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID || - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { - adapter->sendMsg(new LocEngSensorProperties(adapter, - sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, - sap_conf.GYRO_BIAS_RANDOM_WALK, - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY)); - } - - adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter, - sap_conf.SENSOR_CONTROL_MODE, - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, - sap_conf.SENSOR_ALGORITHM_CONFIG_MASK)); - - adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0))); - - loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK); - - LOC_LOGD("loc_eng_reinit reinit() successful"); - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_cleanup - -DESCRIPTION - Cleans location engine. The location client handle will be released. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - - // XTRA has no state, so we are fine with it. - - // we need to check and clear NI -#if 0 - // we need to check and clear ATL - if (NULL != loc_eng_data.agnss_nif) { - delete loc_eng_data.agnss_nif; - loc_eng_data.agnss_nif = NULL; - } - if (NULL != loc_eng_data.internet_nif) { - delete loc_eng_data.internet_nif; - loc_eng_data.internet_nif = NULL; - } -#endif - if (loc_eng_data.adapter->isInSession()) - { - LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now."); - loc_eng_stop(loc_eng_data); - } - -#if 0 // can't afford to actually clean up, for many reason. - - LOC_LOGD("loc_eng_init: client opened. close it now."); - delete loc_eng_data.adapter; - loc_eng_data.adapter = NULL; - - loc_eng_dmn_conn_loc_api_server_unblock(); - loc_eng_dmn_conn_loc_api_server_join(); - -#endif - - EXIT_LOG(%s, VOID_RET); -} - - -/*=========================================================================== -FUNCTION loc_eng_start - -DESCRIPTION - Starts the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_start(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix()) - { - loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - - if (!loc_eng_data.adapter->isInSession()) { - ret_val = loc_eng_data.adapter->startFix(); - - if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS || - ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN || - ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE || - ret_val == LOC_API_ADAPTER_ERR_INTERNAL) - { - loc_eng_data.adapter->setInSession(TRUE); - } - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_stop_wrapper - -DESCRIPTION - Stops the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_stop(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix()) - { - loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - - if (loc_eng_data.adapter->isInSession()) { - ret_val = loc_eng_data.adapter->stopFix(); - loc_eng_data.adapter->setInSession(FALSE); - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_mute_one_session - -DESCRIPTION - Mutes one session - -DEPENDENCIES - None - -RETURN VALUE - 0: Success - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT; - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_set_position_mode - -DESCRIPTION - Sets the mode and fix frequency for the tracking session. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data, - LocPosMode ¶ms) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - // The position mode for AUTO/GSS/QCA1530 can only be standalone - if (!(gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB) && - !(gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) && - (params.mode != LOC_POSITION_MODE_STANDALONE)) { - params.mode = LOC_POSITION_MODE_STANDALONE; - LOC_LOGD("Position mode changed to standalone for target with AUTO/GSS/qca1530."); - } - - if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params)) - { - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngPositionMode(adapter, params)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_inject_time - -DESCRIPTION - This is used by Java native function to do time injection. - -DEPENDENCIES - None - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, LocGpsUtcTime time, - int64_t timeReference, int uncertainty) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - LocEngAdapter* adapter = loc_eng_data.adapter; - - adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference, - uncertainty)); - - EXIT_LOG(%d, 0); - return 0; -} - - -/*=========================================================================== -FUNCTION loc_eng_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 -===========================================================================*/ -int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude, - double longitude, float accuracy) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - LocEngAdapter* adapter = loc_eng_data.adapter; - if(adapter->mSupportsPositionInjection) - { - adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude, - accuracy)); - } - - EXIT_LOG(%d, 0); - return 0; -} - - -/*=========================================================================== -FUNCTION loc_eng_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 LocGpsAidingData matches with - LOC API specification. - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, LocGpsAidingData f) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - - //report delete aiding data to ULP to send to DRPlugin - loc_eng_data.adapter->getUlpProxy()->reportDeleteAidingData(f); - - loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f)); - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - -FUNCTION loc_inform_gps_state - -DESCRIPTION - Informs the GPS Provider about the GPS status - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, LocGpsStatusValue status) -{ - ENTRY_LOG(); - - if (loc_eng_data.status_cb) - { - LocGpsStatus gs = { sizeof(gs),status }; - CALLBACK_LOG_CALLFLOW("status_cb", %s, - loc_get_gps_status_name(gs.status)); - loc_eng_data.status_cb(&gs); - } - - EXIT_LOG(%s, VOID_RET); -} - -static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - UlpLocation location; - LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT; - GpsLocationExtended locationExtended; - memset(&locationExtended, 0, sizeof (GpsLocationExtended)); - locationExtended.size = sizeof(locationExtended); - - ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask); - //Mark the location source as from ZPP - location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; - location.position_source = ULP_LOCATION_IS_FROM_ZPP; - - loc_eng_data.adapter->getUlpProxy()->reportPosition(location, - locationExtended, - NULL, - LOC_SESS_SUCCESS, - tech_mask); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/* - Callback function passed to Data Services State Machine - This becomes part of the state machine's servicer and - is used to send requests to the data services client -*/ -static int dataCallCb(void *cb_data) -{ - LOC_LOGD("Enter dataCallCb\n"); - int ret=0; - if(cb_data != NULL) { - dsCbData *cbData = (dsCbData *)cb_data; - LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter; - if(cbData->action == LOC_GPS_REQUEST_AGPS_DATA_CONN) { - LOC_LOGD("dataCallCb LOC_GPS_REQUEST_AGPS_DATA_CONN\n"); - ret = locAdapter->openAndStartDataCall(); - } - else if(cbData->action == LOC_GPS_RELEASE_AGPS_DATA_CONN) { - LOC_LOGD("dataCallCb LOC_GPS_RELEASE_AGPS_DATA_CONN\n"); - locAdapter->stopDataCall(); - } - } - else { - LOC_LOGE("NULL argument received. Failing.\n"); - ret = -1; - goto err; - } - -err: - LOC_LOGD("Exit dataCallCb ret = %d\n", ret); - return ret; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_reinit - -DESCRIPTION - 2nd half of loc_eng_agps_init(), singled out for modem restart to use. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - - // Set server addresses which came before init - if (loc_eng_data.supl_host_set) - { - loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER, - loc_eng_data.supl_host_buf, - loc_eng_data.supl_port_buf); - } - - if (loc_eng_data.c2k_host_set) - { - loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER, - loc_eng_data.c2k_host_buf, - loc_eng_data.c2k_port_buf); - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_dsclient_release - -DESCRIPTION - Stop/Close/Release DS client when modem SSR happens. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_dsclient_release(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int result = 1; - LocEngAdapter* adapter = loc_eng_data.adapter; - if (NULL != adapter && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) - { - // stop and close the ds client - adapter->stopDataCall(); - adapter->closeDataCall(); - adapter->releaseDataServiceClient(); - } - EXIT_LOG(%s, VOID_RET); -} - - -/*=========================================================================== -FUNCTION loc_eng_agps_init - -DESCRIPTION - Initialize the AGps interface. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - STATE_CHECK((NULL == loc_eng_data.agps_status_cb), - "agps instance already initialized", - return); - if (callbacks == NULL) { - LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks); - EXIT_LOG(%s, VOID_RET); - return; - } - LocEngAdapter* adapter = loc_eng_data.adapter; - loc_eng_data.agps_status_cb = callbacks->status_cb; - - if (NULL != adapter) { - if (adapter->mSupportsAgpsRequests) { - adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data)); - } - loc_eng_agps_reinit(loc_eng_data); - } - - EXIT_LOG(%s, VOID_RET); -} - -static void deleteAidingData(loc_eng_data_s_type &logEng) { - if (logEng.engine_status != LOC_GPS_STATUS_ENGINE_ON && - logEng.aiding_data_for_deletion != 0) { - logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion); - logEng.aiding_data_for_deletion = 0; - } -} - -// must be called under msg handler context -static void createAgnssNifs(loc_eng_data_s_type& locEng) { - bool agpsCapable = ((gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) || - (gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB)); - LocEngAdapter* adapter = locEng.adapter; - if (NULL != adapter && adapter->mSupportsAgpsRequests) { - if (NULL == locEng.internet_nif) { - locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps, - (void *)locEng.agps_status_cb, - LOC_AGPS_TYPE_WWAN_ANY, - false); - } - if (agpsCapable) { - if (NULL == locEng.agnss_nif) { - locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps, - (void *)locEng.agps_status_cb, - LOC_AGPS_TYPE_SUPL, - false); - } - if (NULL == locEng.ds_nif && - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL && - 0 == adapter->initDataServiceClient(false)) { - locEng.ds_nif = new DSStateMachine(servicerTypeExt, - (void *)dataCallCb, - locEng.adapter); - } - } - } -} - -// must be called under msg handler context -static AgpsStateMachine* -getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) { - AgpsStateMachine* stateMachine; - switch (agpsType) { - case LOC_AGPS_TYPE_INVALID: - case LOC_AGPS_TYPE_SUPL: { - stateMachine = locEng.agnss_nif; - break; - } - case LOC_AGPS_TYPE_SUPL_ES: { - if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - if (NULL == locEng.ds_nif) { - createAgnssNifs(locEng); - } - stateMachine = locEng.ds_nif; - } else { - stateMachine = locEng.agnss_nif; - } - break; - } - default: - stateMachine = locEng.internet_nif; - } - return stateMachine; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_open - -DESCRIPTION - This function is called when on-demand data connection opening is successful. -It should inform engine about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType, - const char* apn, AGpsBearerType bearerType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - if (apn == NULL) - { - LOC_LOGE("APN Name NULL\n"); - return 0; - } - - LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn); - - int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); - loc_eng_data.adapter->sendMsg( - new LocEngAtlOpenSuccess(&loc_eng_data, agpsType, - apn, apn_len, bearerType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_closed - -DESCRIPTION - This function is called when on-demand data connection closing is done. -It should inform engine about the data close result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data, - agpsType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_open_failed - -DESCRIPTION - This function is called when on-demand data connection opening has failed. -It should inform engine about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data, - agpsType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== - -FUNCTION resolve_in_addr - -DESCRIPTION - Translates a hostname to in_addr struct - -DEPENDENCIES - n/a - -RETURN VALUE - TRUE if successful - -SIDE EFFECTS - n/a - -===========================================================================*/ -static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr) -{ - ENTRY_LOG(); - boolean ret_val = TRUE; - - struct hostent *hp; - hp = gethostbyname(host_addr); - if (hp != NULL) /* DNS OK */ - { - memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length); - } - else - { - /* Try IP representation */ - if (inet_aton(host_addr, in_addr_ptr) == 0) - { - /* IP not valid */ - LOC_LOGE("DNS query on '%s' failed\n", host_addr); - ret_val = FALSE; - } - } - - EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_set_server - -DESCRIPTION - This is used to set the default AGPS server. Server address is obtained - from gps.conf. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char* hostname, int port) -{ - ENTRY_LOG(); - int ret = 0; - LocEngAdapter* adapter = loc_eng_data.adapter; - - if (LOC_AGPS_SUPL_SERVER == type) { - char url[MAX_URL_LEN]; - unsigned int len = 0; - const char nohost[] = "NONE"; - if (hostname == NULL || - strncasecmp(nohost, hostname, sizeof(nohost)) == 0) { - url[0] = NULL; - } else { - len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port); - } - - if (sizeof(url) > len) { - adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len)); - } - } else if (LOC_AGPS_CDMA_PDE_SERVER == type || - LOC_AGPS_CUSTOM_PDE_SERVER == type || - LOC_AGPS_MPC_SERVER == type) { - struct in_addr addr; - if (!resolve_in_addr(hostname, &addr)) - { - LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname); - ret = -2; - } else { - unsigned int ip = htonl(addr.s_addr); - adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type)); - } - } else { - LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type); - } - - EXIT_LOG(%d, ret); - return ret; -} - -/*=========================================================================== -FUNCTION loc_eng_set_server_proxy - -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 - -===========================================================================*/ -int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data, - LocServerType type, - const char* hostname, int port) -{ - ENTRY_LOG_CALLFLOW(); - int ret_val = 0; - - LOC_LOGV("save the address, type: %d, hostname: %s, port: %d", - (int) type, hostname, port); - switch (type) - { - case LOC_AGPS_SUPL_SERVER: - strlcpy(loc_eng_data.supl_host_buf, hostname, - sizeof(loc_eng_data.supl_host_buf)); - loc_eng_data.supl_port_buf = port; - loc_eng_data.supl_host_set = 1; - break; - case LOC_AGPS_CDMA_PDE_SERVER: - strlcpy(loc_eng_data.c2k_host_buf, hostname, - sizeof(loc_eng_data.c2k_host_buf)); - loc_eng_data.c2k_port_buf = port; - loc_eng_data.c2k_host_set = 1; - break; - default: - LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type); - } - - if (NULL != loc_eng_data.adapter) - { - ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port); - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_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 - -===========================================================================*/ -void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data, - int available, const char* apn) -{ - ENTRY_LOG_CALLFLOW(); - - //This is to store the status of data availability over the network. - //If GPS is not enabled, the INIT_CHECK will fail and the modem will - //not be updated with the network's availability. Since the data status - //can change before GPS is enabled the, storing the status will enable - //us to inform the modem after GPS is enabled - agpsStatus = available; - - INIT_CHECK(loc_eng_data.adapter, return); - if (apn != NULL) - { - LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn); - int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available)); - } - EXIT_LOG(%s, VOID_RET); -} - -int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data, - const LocDerEncodedCertificate* certificates, - size_t numberOfCerts) -{ - ENTRY_LOG_CALLFLOW(); - int ret_val = LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS; - - uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK; - uint32_t slotCount = 0; - for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) { - slotBitMaskCounter &= slotBitMaskCounter - 1; - } - LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u", - slotBitMask, slotCount, numberOfCerts); - - LocEngAdapter* adapter = loc_eng_data.adapter; - - if (numberOfCerts == 0) { - LOC_LOGE("No certs to install, since numberOfCerts is zero"); - ret_val = LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS; - } else if (!adapter) { - LOC_LOGE("adapter is null!"); - ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC; - } else if (slotCount < numberOfCerts) { - LOC_LOGE("Not enough cert slots (%u) to install %u certs!", - slotCount, numberOfCerts); - ret_val = LOC_AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES; - } else { - for (int i=0; i < numberOfCerts; ++i) - { - if (certificates[i].length > LOC_AGPS_CERTIFICATE_MAX_LENGTH) { - LOC_LOGE("cert#(%u) length of %u is too big! greater than %u", - certificates[i].length, LOC_AGPS_CERTIFICATE_MAX_LENGTH); - ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC; - break; - } - } - - if (ret_val == LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS) { - adapter->sendMsg(new LocEngInstallAGpsCert(adapter, - certificates, - numberOfCerts, - slotBitMask)); - } - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, - const char* config_data, int32_t length) -{ - ENTRY_LOG_CALLFLOW(); - - if (config_data && length > 0) { - loc_gps_cfg_s_type gps_conf_tmp = gps_conf; - UTIL_UPDATE_CONF(config_data, length, gps_conf_table); - LocEngAdapter* adapter = loc_eng_data.adapter; - - // it is possible that HAL is not init'ed at this time - if (adapter) { - if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) { - adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); - } - if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) { - adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); - } - if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) { - adapter->sendMsg(new LocEngAGlonassProtocol(adapter, - gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); - } - if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) { - adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy())); - } - // we always update lock mask, this is because if this is dsds device, we would not - // know if modem has switched dds, if so, lock mask may also need to be updated. - // if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK. - adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK); - } - - gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER; - gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE; - gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT; - gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE; - gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES; - gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK; - gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL; - gps_conf = gps_conf_tmp; - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_report_status - -DESCRIPTION - Reports GPS engine state to Java layer. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_report_status (loc_eng_data_s_type &loc_eng_data, LocGpsStatusValue status) -{ - ENTRY_LOG(); - // Switch from WAIT to MUTE, for "engine on" or "session begin" event - if (status == LOC_GPS_STATUS_SESSION_BEGIN || status == LOC_GPS_STATUS_ENGINE_ON) - { - if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT) - { - LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION"); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION; - } - } - - // Switch off MUTE session - if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION && - (status == LOC_GPS_STATUS_SESSION_END || status == LOC_GPS_STATUS_ENGINE_OFF)) - { - LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE"); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE; - } - - // Session End is not reported during Android navigating state - boolean navigating = loc_eng_data.adapter->isInSession(); - if (status != LOC_GPS_STATUS_NONE && - !(status == LOC_GPS_STATUS_SESSION_END && navigating) && - !(status == LOC_GPS_STATUS_SESSION_BEGIN && !navigating)) - { - if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - // Inform GpsLocationProvider about mNavigating status - loc_inform_gps_status(loc_eng_data, status); - } - else { - LOC_LOGD("loc_eng_report_status: muting the status report."); - } - } - - // Only keeps ENGINE ON/OFF in engine_status - if (status == LOC_GPS_STATUS_ENGINE_ON || status == LOC_GPS_STATUS_ENGINE_OFF) - { - loc_eng_data.engine_status = status; - } - - // Only keeps SESSION BEGIN/END in fix_session_status - if (status == LOC_GPS_STATUS_SESSION_BEGIN || status == LOC_GPS_STATUS_SESSION_END) - { - loc_eng_data.fix_session_status = status; - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_handle_engine_down - loc_eng_handle_engine_up - -DESCRIPTION - Calls this function when it is detected that modem restart is happening. - Either we detected the modem is down or received modem up event. - This must be called from the deferred thread to avoid race condition. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_ni_reset_on_engine_restart(loc_eng_data); - loc_eng_report_status(loc_eng_data, LOC_GPS_STATUS_ENGINE_OFF); - EXIT_LOG(%s, VOID_RET); -} - -void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_reinit(loc_eng_data); - - loc_eng_data.adapter->requestPowerVote(); - - if (loc_eng_data.agps_status_cb != NULL) { - if (loc_eng_data.agnss_nif) - loc_eng_data.agnss_nif->dropAllSubscribers(); - if (loc_eng_data.internet_nif) - loc_eng_data.internet_nif->dropAllSubscribers(); - - // reinitialize DS client in SSR mode - loc_eng_dsclient_release(loc_eng_data); - if (loc_eng_data.adapter->mSupportsAgpsRequests && - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - loc_eng_data.adapter->initDataServiceClient(true); - } - loc_eng_agps_reinit(loc_eng_data); - } - - // modem is back up. If we crashed in the middle of navigating, we restart. - if (loc_eng_data.adapter->isInSession()) { - // This sets the copy in adapter to modem - loc_eng_data.adapter->setInSession(false); - loc_eng_start_handler(loc_eng_data); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_read_config - -DESCRIPTION - Initiates the reading of the gps config file stored in /etc dir - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_read_config(void) -{ - ENTRY_LOG_CALLFLOW(); - if(configAlreadyRead == false) - { - // Initialize our defaults before reading of configuration file overwrites them. - loc_default_parameters(); - // We only want to parse the conf file once. This is a good place to ensure that. - // In fact one day the conf file should go into context. - UTIL_READ_CONF(GPS_CONF_FILE, gps_conf_table); - UTIL_READ_CONF(SAP_CONF_FILE, sap_conf_table); - configAlreadyRead = true; - } else { - LOC_LOGV("GPS Config file has already been read\n"); - } - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_gps_measurement_init - -DESCRIPTION - Initialize gps measurement module. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, - LocGpsMeasurementCallbacks* callbacks) -{ - ENTRY_LOG_CALLFLOW(); - - STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb), - "gnss measurement already initialized", - return LOC_GPS_MEASUREMENT_ERROR_ALREADY_INIT); - STATE_CHECK((callbacks != NULL), - "callbacks can not be NULL", - return LOC_GPS_MEASUREMENT_ERROR_GENERIC); - STATE_CHECK(loc_eng_data.adapter, - "LocGpsInterface must be initialized first", - return LOC_GPS_MEASUREMENT_ERROR_GENERIC); - - // updated the mask - LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; - loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_ENABLED); - // set up the callback - loc_eng_data.gnss_measurement_cb = callbacks->loc_gnss_measurement_callback; - LOC_LOGD ("%s, event masks updated successfully", __func__); - - return LOC_GPS_MEASUREMENT_OPERATION_SUCCESS; -} - -/*=========================================================================== -FUNCTION loc_eng_gps_measurement_close - -DESCRIPTION - Close gps measurement module. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - - INIT_CHECK(loc_eng_data.adapter, return); - - // updated the mask - LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; - loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_DISABLED); - // set up the callback - loc_eng_data.gnss_measurement_cb = NULL; - EXIT_LOG(%d, 0); -} diff --git a/loc_api/libloc_api_50001/loc_eng.h b/loc_api/libloc_api_50001/loc_eng.h deleted file mode 100644 index d78bef4c..00000000 --- a/loc_api/libloc_api_50001/loc_eng.h +++ /dev/null @@ -1,211 +0,0 @@ -/* Copyright (c) 2009-2014, 2016 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef LOC_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 -#include -#include -#include -#include -#include -#include -#include - -// 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 gps_conf ContextBase::mGps_conf -#define sap_conf ContextBase::mSap_conf - -enum loc_nmea_provider_e_type { - NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA - NMEA_PROVIDER_MP // Modem Processor Provider of NMEA -}; - -enum loc_mute_session_e_type { - LOC_MUTE_SESS_NONE = 0, - LOC_MUTE_SESS_WAIT, - LOC_MUTE_SESS_IN_SESSION -}; - -// Module data -typedef struct loc_eng_data_s -{ - LocEngAdapter *adapter; - loc_location_cb_ext location_cb; - loc_gps_status_callback status_cb; - loc_sv_status_cb_ext sv_status_cb; - agps_status_extended agps_status_cb; - loc_gps_nmea_callback nmea_cb; - loc_ni_notify_callback ni_notify_cb; - loc_gps_set_capabilities set_capabilities_cb; - loc_gps_acquire_wakelock acquire_wakelock_cb; - loc_gps_release_wakelock release_wakelock_cb; - loc_gps_request_utc_time request_utc_time_cb; - loc_gnss_set_system_info set_system_info_cb; - loc_gnss_sv_status_callback gnss_sv_status_cb; - loc_gnss_measurement_callback gnss_measurement_cb; - boolean intermediateFix; - LocAGpsStatusValue agps_status; - loc_eng_xtra_data_s_type xtra_module_data; - loc_eng_ni_data_s_type loc_eng_ni_data; - - // AGPS state machines - AgpsStateMachine* agnss_nif; - AgpsStateMachine* internet_nif; - //State machine for Data Services - AgpsStateMachine* ds_nif; - - // GPS engine status - LocGpsStatusValue engine_status; - LocGpsStatusValue fix_session_status; - - // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off - LocGpsAidingData aiding_data_for_deletion; - - // For muting session broadcast - loc_mute_session_e_type mute_session_state; - - // For nmea generation - boolean generateNmea; - uint32_t gps_used_mask; - uint32_t glo_used_mask; - uint32_t gal_used_mask; - float hdop; - float pdop; - float vdop; - - // 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_ext_parser location_ext_parser; - loc_ext_parser sv_ext_parser; -} loc_eng_data_s_type; - -//loc_eng functions -int loc_eng_init(loc_eng_data_s_type &loc_eng_data, - LocCallbacks* callbacks, - LOC_API_ADAPTER_EVENT_MASK_T event, - ContextBase* context); -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, - LocGpsUtcTime 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, - LocGpsAidingData f); -int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data, - LocPosMode ¶ms); -const void* loc_eng_get_extension(loc_eng_data_s_type &loc_eng_data, - const char* name); -int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char *hostname, int port); -void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data); -int loc_eng_read_config(void); - -//loc_eng_agps functions -void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, - AGpsExtCallbacks* callbacks); -int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType, - const char* apn, AGpsBearerType bearerType); -int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType); -int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType); -void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data, - int avaiable, const char* apn); -int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data, - const LocDerEncodedCertificate* certificates, - size_t length); - -//loc_eng_xtra functions -int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data, - GpsXtraExtCallbacks* callbacks); -int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data, - char* data, int length); -int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data); -void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, int check); - -//loc_eng_ni functions -extern void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, - GpsNiExtCallbacks *callbacks); -extern void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data, - int notif_id, LocGpsUserResponseType user_response); -extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data, - const LocGpsNiNotification *notif, - const void* passThrough); -extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data); - -void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, - const char* config_data, int32_t length); -int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, - LocGpsMeasurementCallbacks* callbacks); -void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif // LOC_ENG_H diff --git a/loc_api/libloc_api_50001/loc_eng_agps.cpp b/loc_api/libloc_api_50001/loc_eng_agps.cpp deleted file mode 100644 index 93260e3c..00000000 --- a/loc_api/libloc_api_50001/loc_eng_agps.cpp +++ /dev/null @@ -1,969 +0,0 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" - -#include -#include -#include -#include -#include -#include - -//====================================================================== -// 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; -const unsigned char DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4; -const unsigned int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500; -//====================================================================== -// Subscriber: BITSubscriber / ATLSubscriber / WIFISubscriber -//====================================================================== -bool Subscriber::forMe(Notification ¬ification) -{ - 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(mIPv6Addr, bitS->mIPv6Addr, sizeof(mIPv6Addr)))); -} - -bool BITSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_RELEASE_SUCCESS); - break; - case RSRC_DENIED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_FAILURE); - break; - case RSRC_GRANTED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_REQUEST_SUCCESS); - break; - default: - notify = false; - } - } - - return notify; -} - -bool ATLSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - ((LocEngAdapter*)mLocAdapter)->atlCloseStatus(ID, 1); - break; - case RSRC_DENIED: - { - AGpsExtType type = mBackwardCompatibleMode ? - LOC_AGPS_TYPE_INVALID : mStateMachine->getType(); - ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 0, - (char*)mStateMachine->getAPN(), - mStateMachine->getBearer(), - type); - } - break; - case RSRC_GRANTED: - { - AGpsExtType type = mBackwardCompatibleMode ? - LOC_AGPS_TYPE_INVALID : mStateMachine->getType(); - ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 1, - (char*)mStateMachine->getAPN(), - mStateMachine->getBearer(), - type); - } - break; - default: - notify = false; - } - } - - return notify; -} - -bool WIFISubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - break; - case RSRC_RELEASED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_RELEASE_SUCCESS); - break; - case RSRC_DENIED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_FAILURE); - break; - case RSRC_GRANTED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_REQUEST_SUCCESS); - break; - default: - notify = false; - } - } - - return notify; -} -bool DSSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - LOC_LOGD("DSSubscriber::notifyRsrcStatus. notify:%d \n",(int)(notify)); - if(notify) { - switch(notification.rsrcStatus) { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - case RSRC_DENIED: - case RSRC_GRANTED: - ((DSStateMachine *)mStateMachine)->informStatus(notification.rsrcStatus, ID); - break; - default: - notify = false; - } - } - return notify; -} -void DSSubscriber :: setInactive() -{ - mIsInactive = true; - ((DSStateMachine *)mStateMachine)->informStatus(RSRC_UNSUBSCRIBE, ID); -} -//====================================================================== -// 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) -{ - LOC_LOGD("AgpsReleasedState::onRsrcEvent; event:%d\n", (int)event); - 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); - // request from connecivity service for NIF - //The if condition is added so that if the data call setup fails - //for DS State Machine, we want to retry in released state. - //for AGps State Machine, sendRsrcRequest() will always return success - if(!mStateMachine->sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)) { - // move the state to PENDING - nextState = mPendingState; - } - } - 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;; - LOC_LOGD("AgpsPendingState::onRsrcEvent; event:%d\n", (int)event); - 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 = mReleasedState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN); - } else if (!mStateMachine->hasActiveSubscribers()) { - // only inactive subscribers, move to RELEASING state - nextState = mReleasingState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(LOC_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; - LOC_LOGD("AgpsAcquiredState::onRsrcEvent; event:%d\n", (int)event); - 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 = mReleasedState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN); - } else if (!mStateMachine->hasActiveSubscribers()) { - // only inactive subscribers, move to RELEASING state - nextState = mReleasingState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(LOC_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;; - LOC_LOGD("AgpsReleasingState::onRsrcEvent; event:%d\n", (int)event); - - 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 = mReleasedState; - } - } - break; - - case RSRC_DENIED: - // A race condition subscriber unsubscribes before AFW denies resource. - 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->hasActiveSubscribers()) { - nextState = mPendingState; - // request from connecivity service for NIF - mStateMachine->sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN); - } else { - nextState = mReleasedState; - } - } - break; - - case RSRC_GRANTED: - 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; -} -//====================================================================== -//Servicer -//====================================================================== -Servicer* Servicer :: getServicer(servicerType type, void *cb_func) -{ - LOC_LOGD(" Enter getServicer type:%d\n", (int)type); - switch(type) { - case servicerTypeNoCbParam: - return (new Servicer(cb_func)); - case servicerTypeExt: - return (new ExtServicer(cb_func)); - case servicerTypeAgps: - return (new AGpsServicer(cb_func)); - default: - return NULL; - } -} - -int Servicer :: requestRsrc(void *cb_data) -{ - callback(); - return 0; -} - -int ExtServicer :: requestRsrc(void *cb_data) -{ - int ret=-1; - LOC_LOGD("Enter ExtServicer :: requestRsrc\n"); - ret = callbackExt(cb_data); - LOC_LOGD("Exit ExtServicer :: requestRsrc\n"); - return(ret); -} - -int AGpsServicer :: requestRsrc(void *cb_data) -{ - callbackAGps((LocAGpsStatus *)cb_data); - return 0; -} - -//====================================================================== -// AgpsStateMachine -//====================================================================== - -AgpsStateMachine::AgpsStateMachine(servicerType servType, - void *cb_func, - AGpsExtType type, - bool enforceSingleSubscriber) : - mStatePtr(new AgpsReleasedState(this)),mType(type), - mAPN(NULL), - mAPNLen(0), - mBearer(AGPS_APN_BEARER_INVALID), - mEnforceSingleSubscriber(enforceSingleSubscriber), - mServicer(Servicer :: getServicer(servType, (void *)cb_func)) -{ - 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; - delete mServicer; - 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*)¬ification, true); - delete s; - } - } 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*)¬ification, false); - } -} - -void AgpsStateMachine::addSubscriber(Subscriber* subscriber) const -{ - Subscriber* s = NULL; - Notification notification((const Subscriber*)subscriber); - linked_list_search(mSubscribers, (void**)&s, - hasSubscriber, (void*)¬ification, false); - - if (NULL == s) { - linked_list_add(mSubscribers, subscriber->clone(), deleteObj); - } -} - -int AgpsStateMachine::sendRsrcRequest(LocAGpsStatusValue action) const -{ - Subscriber* s = NULL; - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&s, hasSubscriber, - (void*)¬ification, false); - - if ((NULL == s) == (LOC_GPS_RELEASE_AGPS_DATA_CONN == action)) { - AGpsExtStatus nifRequest; - nifRequest.size = sizeof(nifRequest); - nifRequest.type = mType; - nifRequest.status = action; - - if (s == NULL) { - nifRequest.ipv4_addr = INADDR_NONE; - memset(&nifRequest.addr, 0, sizeof(nifRequest.addr)); - nifRequest.ssid[0] = '\0'; - nifRequest.password[0] = '\0'; - } else { - s->setIPAddresses(nifRequest.addr); - s->setWifiInfo(nifRequest.ssid, nifRequest.password); - } - - CALLBACK_LOG_CALLFLOW("agps_cb", %s, loc_get_agps_status_name(action)); - mServicer->requestRsrc((void *)&nifRequest); - } - return 0; -} - -void AgpsStateMachine::subscribeRsrc(Subscriber *subscriber) -{ - if (mEnforceSingleSubscriber && hasSubscribers()) { - Notification notification(Notification::BROADCAST_ALL, RSRC_DENIED, true); - notifySubscriber(¬ification, subscriber); - } else { - 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*)¬ification, 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*)¬ification, false); - return NULL != s; -} - -//====================================================================== -// DSStateMachine -//====================================================================== -void delay_callback(void *callbackData, int result) -{ - if(callbackData) { - DSStateMachine *DSSMInstance = (DSStateMachine *)callbackData; - DSSMInstance->retryCallback(); - } - else { - LOC_LOGE(" NULL argument received. Failing.\n"); - goto err; - } -err: - return; -} - -DSStateMachine :: DSStateMachine(servicerType type, void *cb_func, - LocEngAdapter* adapterHandle): - AgpsStateMachine(type, cb_func, LOC_AGPS_TYPE_INVALID,false), - mLocAdapter(adapterHandle) -{ - LOC_LOGD("%s:%d]: New DSStateMachine\n", __func__, __LINE__); - mRetries = 0; -} - -void DSStateMachine :: retryCallback(void) -{ - DSSubscriber *subscriber = NULL; - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&subscriber, hasSubscriber, - (void*)¬ification, false); - if(subscriber) - mLocAdapter->requestSuplES(subscriber->ID); - else - LOC_LOGE("DSStateMachine :: retryCallback: No subscriber found." \ - "Cannot retry data call\n"); - return; -} - -int DSStateMachine :: sendRsrcRequest(LocAGpsStatusValue action) const -{ - DSSubscriber* s = NULL; - dsCbData cbData; - int ret=-1; - int connHandle=-1; - LOC_LOGD("Enter DSStateMachine :: sendRsrcRequest\n"); - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&s, hasSubscriber, - (void*)¬ification, false); - if(s) { - connHandle = s->ID; - LOC_LOGD("DSStateMachine :: sendRsrcRequest - subscriber found\n"); - } - else - LOC_LOGD("DSStateMachine :: sendRsrcRequest - No subscriber found\n"); - - cbData.action = action; - cbData.mAdapter = mLocAdapter; - ret = mServicer->requestRsrc((void *)&cbData); - //Only the request to start data call returns a success/failure - //The request to stop data call will always succeed - //Hence, the below block will only be executed when the - //request to start the data call fails - switch(ret) { - case LOC_API_ADAPTER_ERR_ENGINE_BUSY: - LOC_LOGD("DSStateMachine :: sendRsrcRequest - Failure returned: %d\n",ret); - ((DSStateMachine *)this)->incRetries(); - if(mRetries > MAX_START_DATA_CALL_RETRIES) { - LOC_LOGE(" Failed to start Data call. Fallback to normal ATL SUPL\n"); - informStatus(RSRC_DENIED, connHandle); - } - else { - if(loc_timer_start(DATA_CALL_RETRY_DELAY_MSEC, delay_callback, (void *)this)) { - LOC_LOGE("Error: Could not start delay thread\n"); - ret = -1; - goto err; - } - } - break; - case LOC_API_ADAPTER_ERR_UNSUPPORTED: - LOC_LOGE("No profile found for emergency call. Fallback to normal SUPL ATL\n"); - informStatus(RSRC_DENIED, connHandle); - break; - case LOC_API_ADAPTER_ERR_SUCCESS: - LOC_LOGD("%s:%d]: Request to start data call sent\n", __func__, __LINE__); - break; - case -1: - //One of the ways this case can be encountered is if the callback function - //receives a null argument, it just exits with -1 error - LOC_LOGE("Error: Something went wrong somewhere. Falling back to normal SUPL ATL\n"); - informStatus(RSRC_DENIED, connHandle); - break; - default: - LOC_LOGE("%s:%d]: Unrecognized return value\n", __func__, __LINE__); - } -err: - LOC_LOGD("EXIT DSStateMachine :: sendRsrcRequest; ret = %d\n", ret); - return ret; -} - -void DSStateMachine :: onRsrcEvent(AgpsRsrcStatus event) -{ - void* currState = (void *)mStatePtr; - LOC_LOGD("Enter DSStateMachine :: onRsrcEvent. event = %d\n", (int)event); - switch (event) - { - case RSRC_GRANTED: - LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_GRANTED\n"); - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - break; - case RSRC_RELEASED: - LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_RELEASED\n"); - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - //To handle the case where we get a RSRC_RELEASED in - //pending state, we translate that to a RSRC_DENIED state - //since the callback from DSI is either RSRC_GRANTED or RSRC_RELEASED - //for when the call is connected or disconnected respectively. - if((void *)mStatePtr != currState) - break; - else { - event = RSRC_DENIED; - LOC_LOGE(" Switching event to RSRC_DENIED\n"); - } - case RSRC_DENIED: - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - break; - default: - LOC_LOGW("AgpsStateMachine: unrecognized event %d", event); - break; - } - LOC_LOGD("Exit DSStateMachine :: onRsrcEvent. event = %d\n", (int)event); -} - -void DSStateMachine :: informStatus(AgpsRsrcStatus status, int ID) const -{ - LOC_LOGD("DSStateMachine :: informStatus. Status=%d\n",(int)status); - switch(status) { - case RSRC_UNSUBSCRIBE: - mLocAdapter->atlCloseStatus(ID, 1); - break; - case RSRC_RELEASED: - mLocAdapter->closeDataCall(); - break; - case RSRC_DENIED: - ((DSStateMachine *)this)->mRetries = 0; - mLocAdapter->requestATL(ID, LOC_AGPS_TYPE_SUPL); - break; - case RSRC_GRANTED: - mLocAdapter->atlOpenStatus(ID, 1, - NULL, - AGPS_APN_BEARER_INVALID, - LOC_AGPS_TYPE_INVALID); - break; - default: - LOC_LOGW("DSStateMachine :: informStatus - unknown status"); - } - return; -} diff --git a/loc_api/libloc_api_50001/loc_eng_agps.h b/loc_api/libloc_api_50001/loc_eng_agps.h deleted file mode 100644 index ff879f4b..00000000 --- a/loc_api/libloc_api_50001/loc_eng_agps.h +++ /dev/null @@ -1,434 +0,0 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef __LOC_ENG_AGPS_H__ -#define __LOC_ENG_AGPS_H__ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#if defined(USE_GLIB) && !defined(OFF_TARGET) -#include -#endif /* USE_GLIB */ - -// forward declaration -class AgpsStateMachine; -struct Subscriber; - -// NIF resource events -typedef enum { - RSRC_SUBSCRIBE, - RSRC_UNSUBSCRIBE, - RSRC_GRANTED, - RSRC_RELEASED, - RSRC_DENIED, - RSRC_STATUS_MAX -} AgpsRsrcStatus; - -typedef enum { - servicerTypeNoCbParam, - servicerTypeAgps, - servicerTypeExt -}servicerType; - -//DS Callback struct -typedef struct { - LocEngAdapter *mAdapter; - LocAGpsStatusValue action; -}dsCbData; - -// 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; - friend class DSStateMachine; - // 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 Servicer { - void (*callback)(void); -public: - static Servicer* getServicer(servicerType type, void *cb_func); - virtual int requestRsrc(void *cb_data); - Servicer() {} - Servicer(void *cb_func) - { callback = (void(*)(void))(cb_func); } - virtual ~Servicer(){} - inline virtual char *whoami() {return (char*)"Servicer";} -}; - -class ExtServicer : public Servicer { - int (*callbackExt)(void *cb_data); -public: - int requestRsrc(void *cb_data); - ExtServicer() {} - ExtServicer(void *cb_func) - { callbackExt = (int(*)(void *))(cb_func); } - virtual ~ExtServicer(){} - inline virtual char *whoami() {return (char*)"ExtServicer";} -}; - -class AGpsServicer : public Servicer { - void (*callbackAGps)(LocAGpsStatus* status); -public: - int requestRsrc(void *cb_data); - AGpsServicer() {} - AGpsServicer(void *cb_func) - { callbackAGps = (void(*)(LocAGpsStatus *))(cb_func); } - virtual ~AGpsServicer(){} - inline virtual char *whoami() {return (char*)"AGpsServicer";} -}; - -class AgpsStateMachine { -protected: - // a linked list of subscribers. - void* mSubscribers; - //handle to whoever provides the service - Servicer *mServicer; - // 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; - // pointer to the current state. - AgpsState* mStatePtr; -private: - // NIF type: AGNSS or INTERNET. - const AGpsExtType mType; - // 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; - // bear - AGpsBearerType mBearer; - // ipv4 address for routing - bool mEnforceSingleSubscriber; - -public: - AgpsStateMachine(servicerType servType, void *cb_func, - AGpsExtType type, bool enforceSingleSubscriber); - virtual ~AgpsStateMachine(); - - // self explanatory methods below - void setAPN(const char* apn, unsigned int len); - inline const char* getAPN() const { return (const char*)mAPN; } - inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; } - inline AGpsBearerType getBearer() const { return mBearer; } - inline AGpsExtType getType() const { return (AGpsExtType)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; - - virtual void onRsrcEvent(AgpsRsrcStatus event); - - // put the data together and send the FW - virtual int sendRsrcRequest(LocAGpsStatusValue action) const; - - //if list is empty, linked_list_empty returns 1 - //else if list is not empty, returns 0 - //so hasSubscribers() returns 1 if list is not empty - //and returns 0 if list is empty - 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; - -}; - -class DSStateMachine : public AgpsStateMachine { - static const unsigned char MAX_START_DATA_CALL_RETRIES; - static const unsigned int DATA_CALL_RETRY_DELAY_MSEC; - LocEngAdapter* mLocAdapter; - unsigned char mRetries; -public: - DSStateMachine(servicerType type, - void *cb_func, - LocEngAdapter* adapterHandle); - int sendRsrcRequest(LocAGpsStatusValue action) const; - void onRsrcEvent(AgpsRsrcStatus event); - void retryCallback(); - void informStatus(AgpsRsrcStatus status, int ID) const; - inline void incRetries() {mRetries++;} - inline virtual char *whoami() {return (char*)"DSStateMachine";} -}; - -// 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 uint32_t ID; - const AgpsStateMachine* mStateMachine; - inline Subscriber(const int id, - const AgpsStateMachine* stateMachine) : - ID(id), mStateMachine(stateMachine) {} - inline virtual ~Subscriber() {} - - virtual void setIPAddresses(uint32_t &v4, char* v6) = 0; - virtual void setIPAddresses(struct sockaddr_storage& addr) = 0; - inline virtual void setWifiInfo(char* ssid, char* password) - { ssid[0] = 0; password[0] = 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 ¬ification) = 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 ¬ification); -}; - -// BITSubscriber, created with requests from BIT daemon -struct BITSubscriber : public Subscriber { - char mIPv6Addr[16]; - - inline BITSubscriber(const AgpsStateMachine* stateMachine, - unsigned int ipv4, char* ipv6) : - Subscriber(ipv4, stateMachine) - { - if (NULL == ipv6) { - mIPv6Addr[0] = 0; - } else { - memcpy(mIPv6Addr, ipv6, sizeof(mIPv6Addr)); - } - } - - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) - { v4 = ID; memcpy(v6, mIPv6Addr, sizeof(mIPv6Addr)); } - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6;/*todo: convert mIPv6Addr into addr */ } - - virtual Subscriber* clone() - { - return new BITSubscriber(mStateMachine, ID, mIPv6Addr); - } - - virtual bool equals(const Subscriber *s) const; - inline virtual ~BITSubscriber(){} -}; - -// ATLSubscriber, created with requests from ATL -struct ATLSubscriber : public Subscriber { - const LocEngAdapter* mLocAdapter; - const bool mBackwardCompatibleMode; - inline ATLSubscriber(const int id, - const AgpsStateMachine* stateMachine, - const LocEngAdapter* adapter, - const bool compatibleMode) : - Subscriber(id, stateMachine), mLocAdapter(adapter), - mBackwardCompatibleMode(compatibleMode){} - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) - { v4 = INADDR_NONE; v6[0] = 0; } - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - - inline virtual Subscriber* clone() - { - return new ATLSubscriber(ID, mStateMachine, mLocAdapter, - mBackwardCompatibleMode); - } - inline virtual ~ATLSubscriber(){} -}; - -// WIFISubscriber, created with requests from MSAPM or QuIPC -struct WIFISubscriber : public Subscriber { - char * mSSID; - char * mPassword; - loc_if_req_sender_id_e_type senderId; - bool mIsInactive; - inline WIFISubscriber(const AgpsStateMachine* stateMachine, - char * ssid, char * password, loc_if_req_sender_id_e_type sender_id) : - Subscriber(sender_id, stateMachine), - mSSID(NULL == ssid ? NULL : new char[SSID_BUF_SIZE]), - mPassword(NULL == password ? NULL : new char[SSID_BUF_SIZE]), - senderId(sender_id) - { - if (NULL != mSSID) - strlcpy(mSSID, ssid, SSID_BUF_SIZE); - if (NULL != mPassword) - strlcpy(mPassword, password, SSID_BUF_SIZE); - mIsInactive = false; - } - - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) {} - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - - inline virtual void setWifiInfo(char* ssid, char* password) - { - if (NULL != mSSID) - strlcpy(ssid, mSSID, SSID_BUF_SIZE); - else - ssid[0] = '\0'; - if (NULL != mPassword) - strlcpy(password, mPassword, SSID_BUF_SIZE); - else - password[0] = '\0'; - } - - inline virtual bool waitForCloseComplete() { return true; } - - inline virtual void setInactive() { mIsInactive = true; } - inline virtual bool isInactive() { return mIsInactive; } - - virtual Subscriber* clone() - { - return new WIFISubscriber(mStateMachine, mSSID, mPassword, senderId); - } - inline virtual ~WIFISubscriber(){} -}; - -struct DSSubscriber : public Subscriber { - bool mIsInactive; - inline DSSubscriber(const AgpsStateMachine *stateMachine, - const int id) : - Subscriber(id, stateMachine) - { - mIsInactive = false; - } - inline virtual void setIPAddresses(uint32_t &v4, char* v6) {} - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - virtual Subscriber* clone() - {return new DSSubscriber(mStateMachine, ID);} - virtual bool notifyRsrcStatus(Notification ¬ification); - inline virtual bool waitForCloseComplete() { return true; } - virtual void setInactive(); - inline virtual bool isInactive() - { return mIsInactive; } - inline virtual ~DSSubscriber(){} - inline virtual char *whoami() {return (char*)"DSSubscriber";} -}; - -#endif //__LOC_ENG_AGPS_H__ diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp b/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp deleted file mode 100644 index 5510fc5c..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp +++ /dev/null @@ -1,269 +0,0 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include "loc_eng_dmn_conn_glue_msg.h" -#include "loc_eng_dmn_conn_handler.h" -#include "loc_eng_dmn_conn.h" -#include "loc_eng_msg.h" - -static int loc_api_server_msgqid; -static int loc_api_resp_msgqid; -static int quipc_msgqid; -static int msapm_msgqid; -static int msapu_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 const char * global_quipc_ctrl_q_path = QUIPC_CTRL_Q_PATH; -static const char * global_msapm_ctrl_q_path = MSAPM_CTRL_Q_PATH; -static const char * global_msapu_ctrl_q_path = MSAPU_CTRL_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); - //change mode/group for the global_loc_api_q_path pipe - int result = chmod (global_loc_api_q_path, 0660); - if (result != 0) - { - LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_q_path, strerror(errno)); - } - - struct group * gps_group = getgrnam("gps"); - if (gps_group != NULL) - { - result = chown (global_loc_api_q_path, -1, gps_group->gr_gid); - if (result != 0) - { - LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n", - global_loc_api_q_path, gps_group->gr_gid, result, strerror(errno)); - } - } - else - { - LOC_LOGE("getgrnam for gps failed, error code = %d\n", errno); - } - - loc_api_resp_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_resp_q_path, O_RDWR); - - //change mode/group for the global_loc_api_resp_q_path pipe - result = chmod (global_loc_api_resp_q_path, 0660); - if (result != 0) - { - LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_resp_q_path, strerror(errno)); - } - - if (gps_group != NULL) - { - result = chown (global_loc_api_resp_q_path, -1, gps_group->gr_gid); - if (result != 0) - { - LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n", - global_loc_api_resp_q_path, - gps_group->gr_gid, result, strerror(errno)); - } - } - - quipc_msgqid = loc_eng_dmn_conn_glue_msgget(global_quipc_ctrl_q_path, O_RDWR); - msapm_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapm_ctrl_q_path , O_RDWR); - msapu_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapu_ctrl_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) { - free(p_cmsgbuf); - LOC_LOGE("%s:%d] fail receiving msg from gpsone_daemon, retry later\n", __func__, __LINE__); - usleep(1000); - return -1; - } - - 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); - loc_eng_dmn_conn_glue_msgremove( global_quipc_ctrl_q_path, quipc_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_msapm_ctrl_q_path, msapm_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_msapu_ctrl_q_path, msapu_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 sender_id, int status) { - struct ctrl_msgbuf cmsgbuf; - LOC_LOGD("%s:%d] quipc_msgqid = %d\n", __func__, __LINE__, quipc_msgqid); - cmsgbuf.ctrl_type = GPSONE_LOC_API_RESPONSE; - cmsgbuf.cmsg.cmsg_response.result = status; - switch (sender_id) { - case LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(quipc_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(msapm_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(msapu_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON", __func__, __LINE__); - 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; - } - break; - } - default: { - LOC_LOGD("%s:%d] invalid sender ID!", __func__, __LINE__); - } - } - return 0; -} - diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn.h deleted file mode 100644 index 1d8c1428..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h +++ /dev/null @@ -1,59 +0,0 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_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/location/gpsone_d/gpsone_loc_api_q" -#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_resp_q" -#define QUIPC_CTRL_Q_PATH "/data/misc/location/gpsone_d/quipc_ctrl_q" -#define MSAPM_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapm_ctrl_q" -#define MSAPU_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapu_ctrl_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" -#define QUIPC_CTRL_Q_PATH "/tmp/quipc_ctrl_q" -#define MSAPM_CTRL_Q_PATH "/tmp/msapm_ctrl_q" -#define MSAPU_CTRL_Q_PATH "/tmp/msapu_ctrl_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, int); - -#endif /* LOC_ENG_DATA_SERVER_H */ - diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c b/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c deleted file mode 100644 index e947fa1d..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c +++ /dev/null @@ -1,222 +0,0 @@ -/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#include -#include - -#include - -#include -#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; -} - diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h deleted file mode 100644 index d685c87e..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_ENG_DMN_CONN_GLUE_MSG_H -#define LOC_ENG_DMN_CONN_GLUE_MSG_H - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - - -#include -#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 */ diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c b/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c deleted file mode 100644 index cbc4ea64..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c +++ /dev/null @@ -1,215 +0,0 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#include -#include -#include - -// #include -#include -// #include -#include -#include - -#include "loc_eng_dmn_conn_glue_pipe.h" -#include -/*=========================================================================== -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, 0660); - - if ((result == -1) && (errno != EEXIST)) { - LOC_LOGE("failed: %s\n", strerror(errno)); - return result; - } - - // The mode in mkfifo is not honoured and does not provide the - // group permissions. Doing chmod to add group permissions. - result = chmod (pipe_name, 0660); - if (result != 0){ - LOC_LOGE ("%s failed to change mode for %s, error = %s\n", __func__, - pipe_name, strerror(errno)); - } - - 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 != NULL) { - 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; -} diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h deleted file mode 100644 index b2fa3a03..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h +++ /dev/null @@ -1,50 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_ENG_DMN_CONN_GLUE_PIPE_H -#define LOC_ENG_DMN_CONN_GLUE_PIPE_H - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include - -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 */ diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp b/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp deleted file mode 100644 index 7fbe62ff..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp +++ /dev/null @@ -1,236 +0,0 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#include -#include -#include -#include - -#include -#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; - } - - if (NULL != loc_api_handle) { - AGpsExtType type; - switch (pmsg->cmsg.cmsg_if_request.type) { - case IF_REQUEST_TYPE_SUPL: - { - LOC_LOGD("IF_REQUEST_TYPE_SUPL"); - type = LOC_AGPS_TYPE_SUPL; - break; - } - case IF_REQUEST_TYPE_WIFI: - { - LOC_LOGD("IF_REQUEST_TYPE_WIFI"); - type = LOC_AGPS_TYPE_WIFI; - break; - } - case IF_REQUEST_TYPE_ANY: - { - LOC_LOGD("IF_REQUEST_TYPE_ANY"); - type = LOC_AGPS_TYPE_ANY; - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_TYPE!"); - return -1; - } - } - switch (pmsg->cmsg.cmsg_if_request.sender_id) { - case IF_REQUEST_SENDER_ID_QUIPC: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPM: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPU: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_GPSONE_DAEMON: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON"); - LocEngReqRelBIT* msg = - new LocEngReqRelBIT(loc_api_handle, - type, - pmsg->cmsg.cmsg_if_request.ipv4_addr, - (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr, - true); - msg->send(); - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_SENDER_ID!"); - return -1; - } - } - } - -#else - loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, 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 - AGpsExtType type; - switch (pmsg->cmsg.cmsg_if_request.type) { - case IF_REQUEST_TYPE_SUPL: - { - LOC_LOGD("IF_REQUEST_TYPE_SUPL"); - type = LOC_AGPS_TYPE_SUPL; - break; - } - case IF_REQUEST_TYPE_WIFI: - { - LOC_LOGD("IF_REQUEST_TYPE_WIFI"); - type = LOC_AGPS_TYPE_WIFI; - break; - } - case IF_REQUEST_TYPE_ANY: - { - LOC_LOGD("IF_REQUEST_TYPE_ANY"); - type = LOC_AGPS_TYPE_ANY; - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_TYPE!"); - return -1; - } - } - switch (pmsg->cmsg.cmsg_if_request.sender_id) { - case IF_REQUEST_SENDER_ID_QUIPC: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPM: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPU: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_GPSONE_DAEMON: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON"); - LocEngReqRelBIT* msg = - new LocEngReqRelBIT(loc_api_handle, - type, - pmsg->cmsg.cmsg_if_request.ipv4_addr, - (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr, - false); - msg->send(); - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_SENDER_ID!"); - return -1; - } - } -#else - loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, GPSONE_LOC_API_IF_RELEASE_SUCCESS); -#endif - return 0; -} - diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h deleted file mode 100644 index f1a51c7a..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h +++ /dev/null @@ -1,104 +0,0 @@ -/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_ENG_DATA_SERVER_HANDLER -#define LOC_ENG_DATA_SERVER_HANDLER - -#include -#include - -//for SSID_BUF_SIZE -#ifndef SSID_BUF_SIZE - #define SSID_BUF_SIZE (32+1) -#endif - -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; -}; - -typedef enum { - IF_REQUEST_TYPE_SUPL = 0, - IF_REQUEST_TYPE_WIFI, - IF_REQUEST_TYPE_ANY -} ctrl_if_req_type_e_type; - -typedef enum { - IF_REQUEST_SENDER_ID_QUIPC = 0, - IF_REQUEST_SENDER_ID_MSAPM, - IF_REQUEST_SENDER_ID_MSAPU, - IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - IF_REQUEST_SENDER_ID_MODEM -} ctrl_if_req_sender_id_e_type; - -struct ctrl_msg_if_request { - ctrl_if_req_type_e_type type; - ctrl_if_req_sender_id_e_type sender_id; - unsigned long ipv4_addr; - unsigned char ipv6_addr[16]; - char ssid[SSID_BUF_SIZE]; - char password[SSID_BUF_SIZE]; -}; - -/* 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 */ diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c b/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c deleted file mode 100644 index b30f6d7a..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c +++ /dev/null @@ -1,398 +0,0 @@ -/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#include - -#include -#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; -} - diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h deleted file mode 100644 index 89e598b5..00000000 --- a/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h +++ /dev/null @@ -1,74 +0,0 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ -#define __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include - -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__ */ diff --git a/loc_api/libloc_api_50001/loc_eng_log.cpp b/loc_api/libloc_api_50001/loc_eng_log.cpp deleted file mode 100644 index 3a34167a..00000000 --- a/loc_api/libloc_api_50001/loc_eng_log.cpp +++ /dev/null @@ -1,35 +0,0 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" - -#include "loc_log.h" -#include "loc_eng_log.h" - diff --git a/loc_api/libloc_api_50001/loc_eng_msg.h b/loc_api/libloc_api_50001/loc_eng_msg.h deleted file mode 100644 index 6f335e6b..00000000 --- a/loc_api/libloc_api_50001/loc_eng_msg.h +++ /dev/null @@ -1,305 +0,0 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ -#ifndef LOC_ENG_MSG_H -#define LOC_ENG_MSG_H - - -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef SSID_BUF_SIZE - #define SSID_BUF_SIZE (32+1) -#endif -#if defined(USE_GLIB) && !defined(OFF_TARGET) - -#include - -#endif /* USE_GLIB */ -#include "platform_lib_includes.h" - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -using namespace loc_core; - -struct LocEngPositionMode : public LocMsg { - LocEngAdapter* mAdapter; - const LocPosMode mPosMode; - LocEngPositionMode(LocEngAdapter* adapter, LocPosMode &mode); - virtual void proc() const; - virtual void log() const; - void send() const; -}; - - -struct LocEngStartFix : public LocMsg { - LocEngAdapter* mAdapter; - LocEngStartFix(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngStopFix : public LocMsg { - LocEngAdapter* mAdapter; - LocEngStopFix(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportPosition : public LocMsg { - LocAdapterBase* mAdapter; - const UlpLocation mLocation; - const GpsLocationExtended mLocationExtended; - const void* mLocationExt; - const enum loc_sess_status mStatus; - const LocPosTechMask mTechMask; - LocEngReportPosition(LocAdapterBase* adapter, - UlpLocation &loc, - GpsLocationExtended &locExtended, - void* locExt, - enum loc_sess_status st, - LocPosTechMask technology); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportSv : public LocMsg { - LocAdapterBase* mAdapter; - const LocGnssSvStatus mSvStatus; - const GpsLocationExtended mLocationExtended; - const void* mSvExt; - LocEngReportSv(LocAdapterBase* adapter, - LocGnssSvStatus &sv, - GpsLocationExtended &locExtended, - void* svExtended); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportStatus : public LocMsg { - LocAdapterBase* mAdapter; - const LocGpsStatusValue mStatus; - LocEngReportStatus(LocAdapterBase* adapter, - LocGpsStatusValue engineStatus); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReportNmea : public LocMsg { - void* mLocEng; - char* const mNmea; - const int mLen; - LocEngReportNmea(void* locEng, - const char* data, int len); - inline virtual ~LocEngReportNmea() - { - delete[] mNmea; - } - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReportXtraServer : public LocMsg { - void* mLocEng; - int mMaxLen; - char *mServers; - LocEngReportXtraServer(void* locEng, - const char *url1, const char *url2, - const char *url3, const int maxlength); - inline virtual ~LocEngReportXtraServer() - { - delete[] mServers; - } - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngSuplEsOpened : public LocMsg { - void* mLocEng; - LocEngSuplEsOpened(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngSuplEsClosed : public LocMsg { - void* mLocEng; - LocEngSuplEsClosed(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestSuplEs : public LocMsg { - void* mLocEng; - const int mID; - LocEngRequestSuplEs(void* locEng, int id); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestATL : public LocMsg { - void* mLocEng; - const int mID; - const AGpsExtType mType; - LocEngRequestATL(void* locEng, int id, - AGpsExtType agps_type); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReleaseATL : public LocMsg { - void* mLocEng; - const int mID; - LocEngReleaseATL(void* locEng, int id); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReqRelBIT : public LocMsg { - void* mLocEng; - const AGpsExtType mType; - const int mIPv4Addr; - char* const mIPv6Addr; - const bool mIsReq; - LocEngReqRelBIT(void* instance, AGpsExtType type, - int ipv4, char* ipv6, bool isReq); - virtual ~LocEngReqRelBIT(); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReqRelWifi : public LocMsg { - void* mLocEng; - const AGpsExtType mType; - const loc_if_req_sender_id_e_type mSenderId; - char* const mSSID; - char* const mPassword; - const bool mIsReq; - LocEngReqRelWifi(void* locEng, AGpsExtType type, - loc_if_req_sender_id_e_type sender_id, - char* s, char* p, bool isReq); - virtual ~LocEngReqRelWifi(); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngRequestXtra : public LocMsg { - void* mLocEng; - LocEngRequestXtra(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestTime : public LocMsg { - void* mLocEng; - LocEngRequestTime(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestNi : public LocMsg { - void* mLocEng; - const LocGpsNiNotification mNotify; - const void *mPayload; - LocEngRequestNi(void* locEng, - LocGpsNiNotification ¬if, - const void* data); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngDown : public LocMsg { - void* mLocEng; - LocEngDown(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngUp : public LocMsg { - void* mLocEng; - LocEngUp(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngGetZpp : public LocMsg { - LocEngAdapter* mAdapter; - LocEngGetZpp(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportGnssMeasurement : public LocMsg { - void* mLocEng; - const LocGnssData mGnssData; - LocEngReportGnssMeasurement(void* locEng, - LocGnssData &gnssData); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* LOC_ENG_MSG_H */ diff --git a/loc_api/libloc_api_50001/loc_eng_ni.cpp b/loc_api/libloc_api_50001/loc_eng_ni.cpp deleted file mode 100644 index 3a7d8fb4..00000000 --- a/loc_api/libloc_api_50001/loc_eng_ni.cpp +++ /dev/null @@ -1,413 +0,0 @@ -/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -using namespace loc_core; - -/*============================================================================= - * - * DATA DECLARATION - * - *============================================================================*/ - -/*============================================================================= - * - * FUNCTION DECLARATIONS - * - *============================================================================*/ -static void* ni_thread_proc(void *args); - -struct LocEngInformNiResponse : public LocMsg { - LocEngAdapter* mAdapter; - const LocGpsUserResponseType mResponse; - const void *mPayload; - inline LocEngInformNiResponse(LocEngAdapter* adapter, - LocGpsUserResponseType resp, - const void* data) : - LocMsg(), mAdapter(adapter), - mResponse(resp), mPayload(data) - { - locallog(); - } - inline ~LocEngInformNiResponse() - { - // this is a bit weird since mPayload is not - // allocated by this class. But there is no better way. - // mPayload actually won't be NULL here. - free((void*)mPayload); - } - inline virtual void proc() const - { - mAdapter->informNiResponse(mResponse, mPayload); - } - inline void locallog() const - { - LOC_LOGV("LocEngInformNiResponse - " - "response: %s\n mPayload: %p", - loc_get_ni_response_name(mResponse), - mPayload); - } - inline virtual void log() const - { - locallog(); - } -}; - -/*=========================================================================== - -FUNCTION loc_eng_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 - -===========================================================================*/ -void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data, - const LocGpsNiNotification *notif, - const void* passThrough) -{ - ENTRY_LOG(); - char lcs_addr[32]; // Decoded LCS address for UMTS CP NI - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_session_s_type* pSession = NULL; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - if (notif->ni_type == LOC_GPS_NI_TYPE_EMERGENCY_SUPL) { - if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d", - notif->ni_type); - if (NULL != passThrough) { - free((void*)passThrough); - } - } else { - pSession = &loc_eng_ni_data_p->sessionEs; - } - } else { - if (NULL != loc_eng_ni_data_p->session.rawRequest || - NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d", - notif->ni_type); - if (NULL != passThrough) { - free((void*)passThrough); - } - } else { - pSession = &loc_eng_ni_data_p->session; - } - } - - - if (pSession) { - /* Save request */ - pSession->rawRequest = (void*)passThrough; - pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter; - pSession->adapter = loc_eng_data.adapter; - - /* Fill in notification */ - ((LocGpsNiNotification*)notif)->notification_id = pSession->reqID; - - if (notif->notify_flags == LOC_GPS_NI_PRIVACY_OVERRIDE) - { - loc_eng_mute_one_session(loc_eng_data); - } - - /* Log requestor ID and text for debugging */ - LOC_LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif->ni_type, notif->timeout, notif->default_response); - LOC_LOGI(" requestor_id: %s (encoding: %d)", notif->requestor_id, notif->requestor_id_encoding); - LOC_LOGI(" text: %s text (encoding: %d)", notif->text, notif->text_encoding); - if (notif->extras[0]) - { - LOC_LOGI(" extras: %s", notif->extras); - } - - /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though - * the OEM layer in java does not do so. - **/ - pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME); - LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft); - - int rc = 0; - rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession); - if (rc) - { - LOC_LOGE("Loc NI thread is not created.\n"); - } - rc = pthread_detach(pSession->thread); - if (rc) - { - LOC_LOGE("Loc NI thread is not detached.\n"); - } - - CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id); - loc_eng_data.ni_notify_cb((LocGpsNiNotification*)notif, gps_conf.SUPL_ES != 0); - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - -FUNCTION ni_thread_proc - -===========================================================================*/ -static void* ni_thread_proc(void *args) -{ - ENTRY_LOG(); - - loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args; - int rc = 0; /* return code from pthread calls */ - - struct timeval present_time; - struct timespec expire_time; - - LOC_LOGD("Starting Loc NI thread...\n"); - pthread_mutex_lock(&pSession->tLock); - /* Calculate absolute expire time */ - gettimeofday(&present_time, NULL); - expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft; - expire_time.tv_nsec = present_time.tv_usec * 1000; - LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n", - (long) expire_time.tv_sec, pSession->respTimeLeft ); - - while (!pSession->respRecvd) - { - rc = pthread_cond_timedwait(&pSession->tCond, - &pSession->tLock, - &expire_time); - if (rc == ETIMEDOUT) - { - pSession->resp = LOC_GPS_NI_RESPONSE_NORESP; - LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc ); - break; - } - } - LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from " - "pthread_cond_timedwait = %d\n",rc ); - pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/ - - LOC_LOGD("pSession->resp is %d\n",pSession->resp); - - // adding this check to support modem restart, in which case, we need the thread - // to exit without calling sending data. We made sure that rawRequest is NULL in - // loc_eng_ni_reset_on_engine_restart() - LocEngAdapter* adapter = pSession->adapter; - LocEngInformNiResponse *msg = NULL; - - if (NULL != pSession->rawRequest) { - if (pSession->resp != LOC_GPS_NI_RESPONSE_IGNORE) { - LOC_LOGD("pSession->resp != LOC_GPS_NI_RESPONSE_IGNORE \n"); - msg = new LocEngInformNiResponse(adapter, - pSession->resp, - pSession->rawRequest); - } else { - LOC_LOGD("this is the ignore reply for SUPL ES\n"); - free(pSession->rawRequest); - } - pSession->rawRequest = NULL; - } - pthread_mutex_unlock(&pSession->tLock); - - pSession->respTimeLeft = 0; - pSession->reqID = 0; - - if (NULL != msg) { - LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n"); - adapter->sendMsg(msg); - } - - EXIT_LOG(%s, VOID_RET); - return NULL; -} - -void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - // only if modem has requested but then died. - if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - free(loc_eng_ni_data_p->sessionEs.rawRequest); - loc_eng_ni_data_p->sessionEs.rawRequest = NULL; - - pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock); - // the goal is to wake up ni_thread_proc - // and let it exit. - loc_eng_ni_data_p->sessionEs.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock); - } - - if (NULL != loc_eng_ni_data_p->session.rawRequest) { - free(loc_eng_ni_data_p->session.rawRequest); - loc_eng_ni_data_p->session.rawRequest = NULL; - - pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock); - // the goal is to wake up ni_thread_proc - // and let it exit. - loc_eng_ni_data_p->session.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->session.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -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(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callbacks) -{ - ENTRY_LOG_CALLFLOW(); - - if(callbacks == NULL) - EXIT_LOG(%s, "loc_eng_ni_init: failed, cb is NULL"); - else if (NULL == callbacks->notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init: failed, no cb."); - } else if (NULL != loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init: already inited."); - } else { - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_data_p->sessionEs.respTimeLeft = 0; - loc_eng_ni_data_p->sessionEs.respRecvd = FALSE; - loc_eng_ni_data_p->sessionEs.rawRequest = NULL; - loc_eng_ni_data_p->sessionEs.reqID = 0; - pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL); - pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL); - - loc_eng_ni_data_p->session.respTimeLeft = 0; - loc_eng_ni_data_p->session.respRecvd = FALSE; - loc_eng_ni_data_p->session.rawRequest = NULL; - loc_eng_ni_data_p->session.reqID = 0; - pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL); - pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL); - - loc_eng_data.ni_notify_cb = callbacks->notify_cb; - EXIT_LOG(%s, VOID_RET); - } -} - -/*=========================================================================== -FUNCTION loc_eng_ni_respond - -DESCRIPTION - This function receives user response from upper layer framework - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data, - int notif_id, LocGpsUserResponseType user_response) -{ - ENTRY_LOG_CALLFLOW(); - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_session_s_type* pSession = NULL; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - if (notif_id == loc_eng_ni_data_p->sessionEs.reqID && - NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - pSession = &loc_eng_ni_data_p->sessionEs; - // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted - if (user_response == LOC_GPS_NI_RESPONSE_ACCEPT && - NULL != loc_eng_ni_data_p->session.rawRequest) { - pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock); - loc_eng_ni_data_p->session.resp = LOC_GPS_NI_RESPONSE_IGNORE; - loc_eng_ni_data_p->session.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->session.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock); - } - } else if (notif_id == loc_eng_ni_data_p->session.reqID && - NULL != loc_eng_ni_data_p->session.rawRequest) { - pSession = &loc_eng_ni_data_p->session; - } - - if (pSession) { - LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id); - pthread_mutex_lock(&pSession->tLock); - pSession->resp = user_response; - pSession->respRecvd = TRUE; - pthread_cond_signal(&pSession->tCond); - pthread_mutex_unlock(&pSession->tLock); - } - else { - LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id); - } - - EXIT_LOG(%s, VOID_RET); -} diff --git a/loc_api/libloc_api_50001/loc_eng_ni.h b/loc_api/libloc_api_50001/loc_eng_ni.h deleted file mode 100644 index afb406fb..00000000 --- a/loc_api/libloc_api_50001/loc_eng_ni.h +++ /dev/null @@ -1,59 +0,0 @@ -/* Copyright (c) 2009,2011,2014 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef LOC_ENG_NI_H -#define LOC_ENG_NI_H - -#include -#include - -#define LOC_NI_NO_RESPONSE_TIME 20 /* secs */ -#define LOC_NI_NOTIF_KEY_ADDRESS "Address" -#define LOC_GPS_NI_RESPONSE_IGNORE 4 - -typedef struct { - pthread_t thread; /* NI thread */ - int respTimeLeft; /* examine time for NI response */ - bool respRecvd; /* NI User reponse received or not from Java layer*/ - void* rawRequest; - int reqID; /* ID to check against response */ - LocGpsUserResponseType resp; - pthread_cond_t tCond; - pthread_mutex_t tLock; - LocEngAdapter* adapter; -} loc_eng_ni_session_s_type; - -typedef struct { - loc_eng_ni_session_s_type session; /* SUPL NI Session */ - loc_eng_ni_session_s_type sessionEs; /* Emergency SUPL NI Session */ - int reqIDCounter; -} loc_eng_ni_data_s_type; - - -#endif /* LOC_ENG_NI_H */ diff --git a/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/loc_api/libloc_api_50001/loc_eng_nmea.cpp deleted file mode 100644 index e7138b68..00000000 --- a/loc_api/libloc_api_50001/loc_eng_nmea.cpp +++ /dev/null @@ -1,1027 +0,0 @@ -/* Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng_nmea" -#include -#include -#include -#include - -#define GLONASS_SV_ID_OFFSET 64 -#define MAX_SATELLITES_IN_USE 12 -typedef struct loc_nmea_sv_meta_s -{ - char talker[3]; - LocGnssConstellationType svType; - uint32_t mask; - uint32_t svIdOffset; -} loc_nmea_sv_meta; - -/*=========================================================================== -FUNCTION loc_eng_nmea_sv_meta_init - -DESCRIPTION - Init loc_nmea_sv_meta passed in - -DEPENDENCIES - NONE - -RETURN VALUE - Pointer to loc_nmea_sv_meta - -SIDE EFFECTS - N/A - -===========================================================================*/ -static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_eng_data_s_type *loc_eng_data_p, - loc_nmea_sv_meta& sv_meta, LocGnssConstellationType svType, bool needCombine) -{ - if (!loc_eng_data_p) - return NULL; - - memset(&sv_meta, 0, sizeof(sv_meta)); - sv_meta.svType = svType; - sv_meta.talker[0] = 'G'; - - switch (svType) - { - case LOC_GNSS_CONSTELLATION_GPS: - sv_meta.talker[1] = 'P'; - sv_meta.mask = loc_eng_data_p->gps_used_mask; - break; - case LOC_GNSS_CONSTELLATION_GLONASS: - sv_meta.talker[1] = 'L'; - sv_meta.mask = loc_eng_data_p->glo_used_mask; - // GLONASS SV ids are from 65-96 - sv_meta.svIdOffset = GLONASS_SV_ID_OFFSET; - break; - case LOC_GNSS_CONSTELLATION_GALILEO: - sv_meta.talker[1] = 'A'; - sv_meta.mask = loc_eng_data_p->gal_used_mask; - break; - default: - LOC_LOGE("NMEA Error unknow constellation type: %d", svType); - return NULL; - } - if (needCombine && - (loc_eng_data_p->gps_used_mask ? 1 : 0) + - (loc_eng_data_p->glo_used_mask ? 1 : 0) + - (loc_eng_data_p->gal_used_mask ? 1 : 0) > 1) - { - // If GPS, GLONASS, Galileo etc. are combined - // to obtain the reported position solution, - // talker shall be set to GN, to indicate that - // the satellites are used in a combined solution - sv_meta.talker[1] = 'N'; - } - return &sv_meta; -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_count_bits - -DESCRIPTION - Count how many bits are set in mask - -DEPENDENCIES - NONE - -RETURN VALUE - Bits number set in mask - -SIDE EFFECTS - N/A - -===========================================================================*/ -static uint32_t loc_eng_nmea_count_bits(uint32_t mask) -{ - uint32_t count = 0; - while (mask) - { - if (mask & 1) - count++; - mask = mask >> 1; - } - return count; -} - - -/*=========================================================================== -FUNCTION loc_eng_nmea_send - -DESCRIPTION - send out NMEA sentence - -DEPENDENCIES - NONE - -RETURN VALUE - Total length of the nmea sentence - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p) -{ - struct timeval tv; - gettimeofday(&tv, (struct timezone *) NULL); - int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; - if (loc_eng_data_p->nmea_cb != NULL) - loc_eng_data_p->nmea_cb(now, pNmea, length); - - loc_eng_data_p->adapter->getUlpProxy()->reportNmea(pNmea, length); - - LOC_LOGD("NMEA <%s", pNmea); -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_put_checksum - -DESCRIPTION - Generate NMEA sentences generated based on position report - -DEPENDENCIES - NONE - -RETURN VALUE - Total length of the nmea sentence - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_nmea_put_checksum(char *pNmea, int maxSize) -{ - uint8_t checksum = 0; - int length = 0; - - pNmea++; //skip the $ - while (*pNmea != '\0') - { - checksum ^= *pNmea++; - length++; - } - - // length now contains nmea sentence string length not including $ sign. - int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum); - - // total length of nmea sentence is length of nmea sentence inc $ sign plus - // length of checksum (+1 is to cover the $ character in the length). - return (length + checksumLength + 1); -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_GSA - -DESCRIPTION - Generate NMEA GSA sentences generated based on position report - Currently below sentences are generated: - - $GPGSA : GPS DOP and active SVs - - $GLGSA : GLONASS DOP and active SVs - - $GAGSA : GALILEO DOP and active SVs - - $GNGSA : GNSS DOP and active SVs - -DEPENDENCIES - NONE - -RETURN VALUE - Number of SVs used - -SIDE EFFECTS - N/A - -===========================================================================*/ -uint32_t loc_eng_nmea_generate_GSA(loc_eng_data_s_type *loc_eng_data_p, - const GpsLocationExtended &locationExtended, - char* sentence, - int bufSize, - loc_nmea_sv_meta* sv_meta_p) -{ - if (!loc_eng_data_p || !sentence || bufSize <= 0 || !sv_meta_p) - { - LOC_LOGE("NMEA Error invalid arguments."); - return 0; - } - - char* pMarker = sentence; - int lengthRemaining = bufSize; - int length = 0; - - uint32_t svUsedCount = 0; - uint32_t svUsedList[32] = {0}; - - char fixType = '\0'; - - const char* talker = sv_meta_p->talker; - uint32_t svIdOffset = sv_meta_p->svIdOffset; - uint32_t mask = sv_meta_p->mask; - - for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) - { - if (mask & 1) - svUsedList[svUsedCount++] = i + svIdOffset; - mask = mask >> 1; - } - - if (svUsedCount == 0 && LOC_GNSS_CONSTELLATION_GPS != sv_meta_p->svType) - return 0; - - if (svUsedCount == 0) - fixType = '1'; // no fix - else if (svUsedCount <= 3) - fixType = '2'; // 2D fix - else - fixType = '3'; // 3D fix - - // Start printing the sentence - // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc - // a : Mode : A : Automatic, allowed to automatically switch 2D/3D - // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix) - // xx : 12 SV ID - // p.p : Position DOP (Dilution of Precision) - // h.h : Horizontal DOP - // v.v : Vertical DOP - // cc : Checksum value - length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", talker, fixType); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return 0; - } - pMarker += length; - lengthRemaining -= length; - - // Add first 12 satellite IDs - for (uint8_t i = 0; i < 12; i++) - { - if (i < svUsedCount) - length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]); - else - length = snprintf(pMarker, lengthRemaining, ","); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return 0; - } - pMarker += length; - lengthRemaining -= length; - } - - // Add the position/horizontal/vertical DOP values - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { // dop is in locationExtended, (QMI) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - locationExtended.pdop, - locationExtended.hdop, - locationExtended.vdop); - } - else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) - { // dop was cached from sv report (RPC) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - loc_eng_data_p->pdop, - loc_eng_data_p->hdop, - loc_eng_data_p->vdop); - } - else - { // no dop - length = snprintf(pMarker, lengthRemaining, ",,"); - } - - /* Sentence is ready, add checksum and broadcast */ - length = loc_eng_nmea_put_checksum(sentence, bufSize); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - return svUsedCount; -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_GSV - -DESCRIPTION - Generate NMEA GSV sentences generated based on sv report - Currently below sentences are generated: - - $GPGSV: GPS Satellites in View - - $GNGSV: GLONASS Satellites in View - - $GAGSV: GALILEO Satellites in View - -DEPENDENCIES - NONE - -RETURN VALUE - NONE - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_generate_GSV(loc_eng_data_s_type *loc_eng_data_p, - const LocGnssSvStatus &svStatus, - char* sentence, - int bufSize, - loc_nmea_sv_meta* sv_meta_p) -{ - if (!loc_eng_data_p || !sentence || bufSize <= 0) - { - LOC_LOGE("NMEA Error invalid argument."); - return; - } - - char* pMarker = sentence; - int lengthRemaining = bufSize; - int length = 0; - int sentenceCount = 0; - int sentenceNumber = 1; - int svNumber = 1; - - const char* talker = sv_meta_p->talker; - uint32_t svIdOffset = sv_meta_p->svIdOffset; - uint32_t mask = sv_meta_p->mask; - uint32_t svCount = loc_eng_nmea_count_bits(mask); - - - if (svCount <= 0) - { - // no svs in view, so just send a blank $--GSV sentence - snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", talker); - length = loc_eng_nmea_put_checksum(sentence, bufSize); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - return; - } - - svNumber = 1; - sentenceNumber = 1; - sentenceCount = svCount / 4 + (svCount % 4 != 0); - - while (sentenceNumber <= sentenceCount) - { - pMarker = sentence; - lengthRemaining = bufSize; - - length = snprintf(pMarker, lengthRemaining, "$%sGSV,%d,%d,%02d", - talker, sentenceCount, sentenceNumber, svCount); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - for (int i=0; (svNumber <= svStatus.num_svs) && (i < 4); svNumber++) - { - if (sv_meta_p->svType == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", - svStatus.gnss_sv_list[svNumber - 1].svid, - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].elevation), //float to int - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].azimuth)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz > 0) - { - length = snprintf(pMarker, lengthRemaining,"%02d", - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - } - - i++; - } - - } - - length = loc_eng_nmea_put_checksum(sentence, bufSize); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - sentenceNumber++; - - } //while -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_pos - -DESCRIPTION - Generate NMEA sentences generated based on position report - Currently below sentences are generated within this function: - - $GPGSA : GPS DOP and active SVs - - $GLGSA : GLONASS DOP and active SVs - - $GAGSA : GALILEO DOP and active SVs - - $GNGSA : GNSS DOP and active SVs - - $--VTG : Track made good and ground speed - - $--RMC : Recommended minimum navigation information - - $--GGA : Time, position and fix related data - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, - const UlpLocation &location, - const GpsLocationExtended &locationExtended, - unsigned char generate_nmea) -{ - ENTRY_LOG(); - time_t utcTime(location.gpsLocation.timestamp/1000); - tm * pTm = gmtime(&utcTime); - if (NULL == pTm) { - LOC_LOGE("gmtime failed"); - return; - } - - char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; - char* pMarker = sentence; - int lengthRemaining = sizeof(sentence); - int length = 0; - int utcYear = pTm->tm_year % 100; // 2 digit year - int utcMonth = pTm->tm_mon + 1; // tm_mon starts at zero - int utcDay = pTm->tm_mday; - int utcHours = pTm->tm_hour; - int utcMinutes = pTm->tm_min; - int utcSeconds = pTm->tm_sec; - int utcMSeconds = (location.gpsLocation.timestamp)%1000; - - if (generate_nmea) { - char talker[3] = {'G', 'P', '\0'}; - uint32_t svUsedCount = 0; - uint32_t count = 0; - loc_nmea_sv_meta sv_meta; - // ------------------- - // ---$GPGSA/$GNGSA--- - // ------------------- - - count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GPS, true)); - if (count > 0) - { - svUsedCount += count; - talker[1] = sv_meta.talker[1]; - } - - // ------------------- - // ---$GLGSA/$GNGSA--- - // ------------------- - - count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GLONASS, true)); - if (count > 0) - { - svUsedCount += count; - talker[1] = sv_meta.talker[1]; - } - - // ------------------- - // ---$GAGSA/$GNGSA--- - // ------------------- - - count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GALILEO, true)); - if (count > 0) - { - svUsedCount += count; - talker[1] = sv_meta.talker[1]; - } - - // ------------------- - // ------$--VTG------- - // ------------------- - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) - { - float magTrack = location.gpsLocation.bearing; - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) - { - float magTrack = location.gpsLocation.bearing - locationExtended.magneticDeviation; - if (magTrack < 0.0) - magTrack += 360.0; - else if (magTrack > 360.0) - magTrack -= 360.0; - } - - length = snprintf(pMarker, lengthRemaining, "$%sVTG,%.1lf,T,%.1lf,M,", talker, location.gpsLocation.bearing, magTrack); - } - else - { - length = snprintf(pMarker, lengthRemaining, "$%sVTG,,T,,M,", talker); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) - { - float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); - float speedKmPerHour = location.gpsLocation.speed * 3.6; - - length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour); - } - else - { - length = snprintf(pMarker, lengthRemaining, ",N,,K,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) - length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous - else - length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------- - // ------$--RMC------- - // ------------------- - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$%sRMC,%02d%02d%02d.%02d,A," , - talker, utcHours, utcMinutes, utcSeconds,utcMSeconds/10); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) - { - double latitude = location.gpsLocation.latitude; - double longitude = location.gpsLocation.longitude; - char latHemisphere; - char lonHemisphere; - double latMinutes; - double lonMinutes; - - if (latitude > 0) - { - latHemisphere = 'N'; - } - else - { - latHemisphere = 'S'; - latitude *= -1.0; - } - - if (longitude < 0) - { - lonHemisphere = 'W'; - longitude *= -1.0; - } - else - { - lonHemisphere = 'E'; - } - - latMinutes = fmod(latitude * 60.0 , 60.0); - lonMinutes = fmod(longitude * 60.0 , 60.0); - - length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", - (uint8_t)floor(latitude), latMinutes, latHemisphere, - (uint8_t)floor(longitude),lonMinutes, lonHemisphere); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) - { - float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); - length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots); - } - else - { - length = snprintf(pMarker, lengthRemaining, ","); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,", location.gpsLocation.bearing); - } - else - { - length = snprintf(pMarker, lengthRemaining, ","); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,", - utcDay, utcMonth, utcYear); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) - { - float magneticVariation = locationExtended.magneticDeviation; - char direction; - if (magneticVariation < 0.0) - { - direction = 'W'; - magneticVariation *= -1.0; - } - else - { - direction = 'E'; - } - - length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,", - magneticVariation, direction); - } - else - { - length = snprintf(pMarker, lengthRemaining, ",,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) - length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous - else - length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------- - // ------$--GGA------- - // ------------------- - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$%sGGA,%02d%02d%02d.%02d," , - talker, utcHours, utcMinutes, utcSeconds, utcMSeconds/10); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) - { - double latitude = location.gpsLocation.latitude; - double longitude = location.gpsLocation.longitude; - char latHemisphere; - char lonHemisphere; - double latMinutes; - double lonMinutes; - - if (latitude > 0) - { - latHemisphere = 'N'; - } - else - { - latHemisphere = 'S'; - latitude *= -1.0; - } - - if (longitude < 0) - { - lonHemisphere = 'W'; - longitude *= -1.0; - } - else - { - lonHemisphere = 'E'; - } - - latMinutes = fmod(latitude * 60.0 , 60.0); - lonMinutes = fmod(longitude * 60.0 , 60.0); - - length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", - (uint8_t)floor(latitude), latMinutes, latHemisphere, - (uint8_t)floor(longitude),lonMinutes, lonHemisphere); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - char gpsQuality; - if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) - gpsQuality = '0'; // 0 means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - gpsQuality = '1'; // 1 means GPS fix - else - gpsQuality = '2'; // 2 means DGPS fix - - // Number of satellites in use, 00-12 - if (svUsedCount > MAX_SATELLITES_IN_USE) - svUsedCount = MAX_SATELLITES_IN_USE; - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { // dop is in locationExtended, (QMI) - length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", - gpsQuality, svUsedCount, locationExtended.hdop); - } - else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) - { // dop was cached from sv report (RPC) - length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", - gpsQuality, svUsedCount, loc_eng_data_p->hdop); - } - else - { // no hdop - length = snprintf(pMarker, lengthRemaining, "%c,%02d,,", - gpsQuality, svUsedCount); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,M,", - locationExtended.altitudeMeanSeaLevel); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if ((location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ALTITUDE) && - (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,", - location.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,"); - } - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // clear the cache so they can't be used again - loc_eng_data_p->gps_used_mask = 0; - loc_eng_data_p->glo_used_mask = 0; - loc_eng_data_p->gal_used_mask = 0; - } - //Send blank NMEA reports for non-final fixes - else { - strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - } - // clear the dop cache so they can't be used again - loc_eng_data_p->pdop = 0; - loc_eng_data_p->hdop = 0; - loc_eng_data_p->vdop = 0; - - EXIT_LOG(%d, 0); -} - - - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_sv - -DESCRIPTION - Generate NMEA sentences generated based on sv report - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, - const LocGnssSvStatus &svStatus, const GpsLocationExtended &locationExtended) -{ - ENTRY_LOG(); - - char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; - char* pMarker = sentence; - int lengthRemaining = sizeof(sentence); - int length = 0; - int svCount = svStatus.num_svs; - int sentenceCount = 0; - int sentenceNumber = 1; - int svNumber = 1; - - //Count GPS SVs for saparating GPS from GLONASS and throw others - - loc_eng_data_p->gps_used_mask = 0; - loc_eng_data_p->glo_used_mask = 0; - loc_eng_data_p->gal_used_mask = 0; - for(svNumber=1; svNumber <= svCount; svNumber++) { - if (LOC_GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - // cache the used in fix mask, as it will be needed to send $GPGSA - // during the position report - if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX)) - { - loc_eng_data_p->gps_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); - } - } - else if (LOC_GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - // cache the used in fix mask, as it will be needed to send $GNGSA - // during the position report - if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX)) - { - loc_eng_data_p->glo_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); - } - } - else if (LOC_GNSS_CONSTELLATION_GALILEO == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - // cache the used in fix mask, as it will be needed to send $GAGSA - // during the position report - if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX)) - { - loc_eng_data_p->gal_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); - } - } - } - - loc_nmea_sv_meta sv_meta; - // ------------------ - // ------$GPGSV------ - // ------------------ - - loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GPS, false)); - - // ------------------ - // ------$GLGSV------ - // ------------------ - - loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GLONASS, false)); - - // ------------------ - // ------$GAGSV------ - // ------------------ - - loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence), - loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GALILEO, false)); - - - // For RPC, the DOP are sent during sv report, so cache them - // now to be sent during position report. - // For QMI, the DOP will be in position report. - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { - loc_eng_data_p->pdop = locationExtended.pdop; - loc_eng_data_p->hdop = locationExtended.hdop; - loc_eng_data_p->vdop = locationExtended.vdop; - } - else - { - loc_eng_data_p->pdop = 0; - loc_eng_data_p->hdop = 0; - loc_eng_data_p->vdop = 0; - } - - EXIT_LOG(%d, 0); -} diff --git a/loc_api/libloc_api_50001/loc_eng_nmea.h b/loc_api/libloc_api_50001/loc_eng_nmea.h deleted file mode 100644 index 9480a6ad..00000000 --- a/loc_api/libloc_api_50001/loc_eng_nmea.h +++ /dev/null @@ -1,42 +0,0 @@ -/* Copyright (c) 2012, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef LOC_ENG_NMEA_H -#define LOC_ENG_NMEA_H - -#include - -#define NMEA_SENTENCE_MAX_LENGTH 200 - -void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p); -int loc_eng_nmea_put_checksum(char *pNmea, int maxSize); -void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const LocGnssSvStatus &svStatus, const GpsLocationExtended &locationExtended); -void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, const UlpLocation &location, const GpsLocationExtended &locationExtended, unsigned char generate_nmea); - -#endif // LOC_ENG_NMEA_H diff --git a/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/loc_api/libloc_api_50001/loc_eng_xtra.cpp deleted file mode 100644 index b5bf4e76..00000000 --- a/loc_api/libloc_api_50001/loc_eng_xtra.cpp +++ /dev/null @@ -1,219 +0,0 @@ -/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation, nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" - -#include -#include -#include - -using namespace loc_core; - -struct LocEngRequestXtraServer : public LocMsg { - LocEngAdapter* mAdapter; - inline LocEngRequestXtraServer(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->requestXtraServer(); - } - inline void locallog() const { - LOC_LOGV("LocEngRequestXtraServer"); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngInjectXtraData : public LocMsg { - LocEngAdapter* mAdapter; - char* mData; - const int mLen; - inline LocEngInjectXtraData(LocEngAdapter* adapter, - char* data, int len): - LocMsg(), mAdapter(adapter), - mData(new char[len]), mLen(len) - { - memcpy((void*)mData, (void*)data, len); - locallog(); - } - inline ~LocEngInjectXtraData() - { - delete[] mData; - } - inline virtual void proc() const { - mAdapter->setXtraData(mData, mLen); - } - inline void locallog() const { - LOC_LOGV("length: %d\n data: %p", mLen, mData); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngSetXtraVersionCheck : public LocMsg { - LocEngAdapter *mAdapter; - int mCheck; - inline LocEngSetXtraVersionCheck(LocEngAdapter* adapter, - int check): - mAdapter(adapter), mCheck(check) {} - inline virtual void proc() const { - locallog(); - mAdapter->setXtraVersionCheck(mCheck); - } - inline void locallog() const { - LOC_LOGD("%s:%d]: mCheck: %d", - __func__, __LINE__, mCheck); - } - inline virtual void log() const { - locallog(); - } -}; - -/*=========================================================================== -FUNCTION loc_eng_xtra_init - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data, - GpsXtraExtCallbacks* callbacks) -{ - int ret_val = -1; - loc_eng_xtra_data_s_type *xtra_module_data_ptr; - ENTRY_LOG(); - - if(!loc_eng_data.adapter->mSupportsTimeInjection - || loc_eng_data.adapter->hasNativeXtraClient()) { - LOC_LOGD("XTRA is already supported. disable it here.\n"); - EXIT_LOG(%d, 1); // return 1 denote failure - return 1; - } - - if(callbacks == NULL) { - LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL"); - } else { - xtra_module_data_ptr = &loc_eng_data.xtra_module_data; - xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb; - xtra_module_data_ptr->report_xtra_server_cb = callbacks->report_xtra_server_cb; - - ret_val = 0; - } - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_xtra_inject_data - -DESCRIPTION - Injects XTRA file into the engine but buffers the data if engine is busy. - -DEPENDENCIES - N/A - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data, - char* data, int length) -{ - ENTRY_LOG(); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngInjectXtraData(adapter, data, length)); - EXIT_LOG(%d, 0); - return 0; -} -/*=========================================================================== -FUNCTION loc_eng_xtra_request_server - -DESCRIPTION - Request the Xtra server url from the modem - -DEPENDENCIES - N/A - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngRequestXtraServer(adapter)); - EXIT_LOG(%d, 0); - return 0; -} -/*=========================================================================== -FUNCTION loc_eng_xtra_version_check - -DESCRIPTION - Injects the enable/disable value for checking XTRA version - that is specified in gps.conf - -DEPENDENCIES - N/A - -RETURN VALUE - none - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, - int check) -{ - ENTRY_LOG(); - LocEngAdapter *adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngSetXtraVersionCheck(adapter, check)); - EXIT_LOG(%d, 0); -} diff --git a/loc_api/libloc_api_50001/loc_eng_xtra.h b/loc_api/libloc_api_50001/loc_eng_xtra.h deleted file mode 100644 index 41a006f9..00000000 --- a/loc_api/libloc_api_50001/loc_eng_xtra.h +++ /dev/null @@ -1,45 +0,0 @@ -/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of The Linux Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR - * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#ifndef LOC_ENG_XTRA_H -#define LOC_ENG_XTRA_H - -// Module data -typedef struct -{ - // loc_eng_ioctl_cb_data_s_type ioctl_cb_data; - loc_gps_xtra_download_request download_request_cb; - report_xtra_server report_xtra_server_cb; - - // XTRA data buffer - char *xtra_data_for_injection; // NULL if no pending data - int xtra_data_len; -} loc_eng_xtra_data_s_type; - -#endif // LOC_ENG_XTRA_H diff --git a/location/Android.mk b/location/Android.mk new file mode 100644 index 00000000..49a60d7d --- /dev/null +++ b/location/Android.mk @@ -0,0 +1,41 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) +ifneq ($(BUILD_TINY_ANDROID),true) + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := liblocation_api +LOCAL_MODULE_OWNER := qti + +LOCAL_MODULE_TAGS := optional + +LOCAL_SHARED_LIBRARIES := \ + libutils \ + libcutils \ + libgps.utils \ + libdl \ + liblog + +LOCAL_SRC_FILES += \ + LocationAPI.cpp \ + LocationAPIClientBase.cpp + +LOCAL_CFLAGS += \ + -fno-short-enums + +LOCAL_C_INCLUDES:= \ + $(TARGET_OUT_HEADERS)/gps.utils + +LOCAL_COPY_HEADERS_TO:= liblocation_api/ +LOCAL_COPY_HEADERS:= \ + LocationAPI.h \ + LocationAPIClientBase.h \ + location_interface.h + +LOCAL_PRELINK_MODULE := false + +include $(BUILD_SHARED_LIBRARY) + +endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/location/LocationAPI.cpp b/location/LocationAPI.cpp new file mode 100644 index 00000000..c800851c --- /dev/null +++ b/location/LocationAPI.cpp @@ -0,0 +1,675 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#define LOG_TAG "LocSvc_LocationAPI" + +#include +#include +#include +#include +#include + +typedef void* (getLocationInterface)(); +typedef std::map LocationClientMap; +typedef struct { + LocationClientMap clientData; + LocationControlAPI* controlAPI; + LocationControlCallbacks controlCallbacks; + GnssInterface* gnssInterface; + GeofenceInterface* geofenceInterface; + FlpInterface* flpInterface; +} LocationAPIData; +static LocationAPIData gData = {}; +static pthread_mutex_t gDataMutex = PTHREAD_MUTEX_INITIALIZER; +static bool gGnssLoadFailed = false; +static bool gFlpLoadFailed = false; +static bool gGeofenceLoadFailed = false; + +static bool needsGnssTrackingInfo(LocationCallbacks& locationCallbacks) +{ + return (locationCallbacks.gnssLocationInfoCb != nullptr || + locationCallbacks.gnssSvCb != nullptr || + locationCallbacks.gnssNmeaCb != nullptr || + locationCallbacks.gnssMeasurementsCb != nullptr); +} + +static bool isGnssClient(LocationCallbacks& locationCallbacks) +{ + return (locationCallbacks.gnssNiCb != nullptr || + locationCallbacks.trackingCb != nullptr || + locationCallbacks.gnssMeasurementsCb != nullptr); +} + +static bool isFlpClient(LocationCallbacks& locationCallbacks) +{ + return (locationCallbacks.trackingCb != nullptr || + locationCallbacks.batchingCb != nullptr); +} + +static bool isGeofenceClient(LocationCallbacks& locationCallbacks) +{ + return (locationCallbacks.geofenceBreachCb != nullptr || + locationCallbacks.geofenceStatusCb != nullptr); +} + +static void* loadLocationInterface(const char* library, const char* name) { + LOC_LOGD("%s]: loading %s::%s ...", __func__, library, name); + if (NULL == library || NULL == name) { + return NULL; + } + getLocationInterface* getter = NULL; + const char *error; + dlerror(); + void *handle = dlopen(library, RTLD_NOW); + if (NULL == handle || (error = dlerror()) != NULL) { + LOC_LOGW("dlopen for %s failed, error = %s", library, error); + } else { + getter = (getLocationInterface*)dlsym(handle, name); + if ((error = dlerror()) != NULL) { + LOC_LOGW("dlsym for %s::%s failed, error = %s", library, name, error); + getter = NULL; + } + } + + if (NULL == getter) { + return (void*)getter; + } else { + return (*getter)(); + } +} + +LocationAPI* +LocationAPI::createInstance(LocationCallbacks& locationCallbacks) +{ + if (nullptr == locationCallbacks.capabilitiesCb || + nullptr == locationCallbacks.responseCb || + nullptr == locationCallbacks.collectiveResponseCb) { + return NULL; + } + + LocationAPI* newLocationAPI = new LocationAPI(); + bool requestedCapabilities = false; + + pthread_mutex_lock(&gDataMutex); + + if (isGnssClient(locationCallbacks)) { + if (NULL == gData.gnssInterface && !gGnssLoadFailed) { + gData.gnssInterface = + (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface"); + if (NULL == gData.gnssInterface) { + gGnssLoadFailed = true; + LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__); + } else { + gData.gnssInterface->initialize(); + } + } + if (NULL != gData.gnssInterface) { + gData.gnssInterface->addClient(newLocationAPI, locationCallbacks); + if (!requestedCapabilities) { + gData.gnssInterface->requestCapabilities(newLocationAPI); + requestedCapabilities = true; + } + } + } + + if (isFlpClient(locationCallbacks)) { + if (NULL == gData.flpInterface && !gFlpLoadFailed) { + gData.flpInterface = + (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface"); + if (NULL == gData.flpInterface) { + gFlpLoadFailed = true; + LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__); + } else { + gData.flpInterface->initialize(); + } + } + if (NULL != gData.flpInterface) { + gData.flpInterface->addClient(newLocationAPI, locationCallbacks); + if (!requestedCapabilities) { + gData.flpInterface->requestCapabilities(newLocationAPI); + requestedCapabilities = true; + } + } + } + + if (isGeofenceClient(locationCallbacks)) { + if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) { + gData.geofenceInterface = + (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface"); + if (NULL == gData.geofenceInterface) { + gGeofenceLoadFailed = true; + LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__); + } else { + gData.geofenceInterface->initialize(); + } + } + if (NULL != gData.geofenceInterface) { + gData.geofenceInterface->addClient(newLocationAPI, locationCallbacks); + if (!requestedCapabilities) { + gData.geofenceInterface->requestCapabilities(newLocationAPI); + requestedCapabilities = true; + } + } + } + + gData.clientData[newLocationAPI] = locationCallbacks; + + pthread_mutex_unlock(&gDataMutex); + + return newLocationAPI; +} + +void +LocationAPI::destroy() +{ + delete this; +} + +LocationAPI::LocationAPI() +{ + LOC_LOGD("LOCATION API CONSTRUCTOR"); +} + +LocationAPI::~LocationAPI() +{ + LOC_LOGD("LOCATION API DESTRUCTOR"); + pthread_mutex_lock(&gDataMutex); + + auto it = gData.clientData.find(this); + if (it != gData.clientData.end()) { + size_t gnssClientCount = 0; + size_t flpClientCount = 0; + size_t geofenceClientCount = 0; + for (auto it2=gData.clientData.begin(); it2 != gData.clientData.end(); ++it2) { + if (isGnssClient(it2->second)) { + gnssClientCount++; + } + if (isFlpClient(it2->second)) { + flpClientCount++; + } + if (isGeofenceClient(it2->second)) { + geofenceClientCount++; + } + } + if (isGnssClient(it->second) && NULL != gData.gnssInterface) { + gData.gnssInterface->removeClient(it->first); + if (1 == gnssClientCount && NULL == gData.controlAPI) { + gData.gnssInterface->deinitialize(); + } + } + if (isFlpClient(it->second) && NULL != gData.flpInterface) { + gData.flpInterface->removeClient(it->first); + if (1 == flpClientCount) { + gData.flpInterface->deinitialize(); + } + } + if (isGeofenceClient(it->second) && NULL != gData.geofenceInterface) { + gData.geofenceInterface->removeClient(it->first); + if (1 == geofenceClientCount) { + gData.geofenceInterface->deinitialize(); + } + } + gData.clientData.erase(it); + } else { + LOC_LOGE("%s:%d]: Location API client %p not found in client data", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::updateCallbacks(LocationCallbacks& locationCallbacks) +{ + if (nullptr == locationCallbacks.capabilitiesCb || + nullptr == locationCallbacks.responseCb || + nullptr == locationCallbacks.collectiveResponseCb) { + return; + } + + pthread_mutex_lock(&gDataMutex); + + if (isGnssClient(locationCallbacks)) { + if (NULL == gData.gnssInterface && !gGnssLoadFailed) { + gData.gnssInterface = + (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface"); + if (NULL == gData.gnssInterface) { + gGnssLoadFailed = true; + LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__); + } else { + gData.gnssInterface->initialize(); + } + } + if (NULL != gData.gnssInterface) { + // either adds new Client or updates existing Client + gData.gnssInterface->addClient(this, locationCallbacks); + } + } + + if (isFlpClient(locationCallbacks)) { + if (NULL == gData.flpInterface && !gFlpLoadFailed) { + gData.flpInterface = + (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface"); + if (NULL == gData.flpInterface) { + gFlpLoadFailed = true; + LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__); + } else { + gData.flpInterface->initialize(); + } + } + if (NULL != gData.flpInterface) { + // either adds new Client or updates existing Client + gData.flpInterface->addClient(this, locationCallbacks); + } + } + + if (isGeofenceClient(locationCallbacks)) { + if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) { + gData.geofenceInterface = + (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface"); + if (NULL == gData.geofenceInterface) { + gGeofenceLoadFailed = true; + LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__); + } else { + gData.geofenceInterface->initialize(); + } + } + if (NULL != gData.geofenceInterface) { + // either adds new Client or updates existing Client + gData.geofenceInterface->addClient(this, locationCallbacks); + } + } + + gData.clientData[this] = locationCallbacks; + + pthread_mutex_unlock(&gDataMutex); +} + +uint32_t +LocationAPI::startTracking(LocationOptions& locationOptions) +{ + uint32_t id = 0; + pthread_mutex_lock(&gDataMutex); + + auto it = gData.clientData.find(this); + if (it != gData.clientData.end()) { + if (gData.flpInterface != NULL && locationOptions.minDistance > 0) { + id = gData.flpInterface->startTracking(this, locationOptions); + } else if (gData.gnssInterface != NULL && needsGnssTrackingInfo(it->second)) { + id = gData.gnssInterface->startTracking(this, locationOptions); + } else if (gData.flpInterface != NULL) { + id = gData.flpInterface->startTracking(this, locationOptions); + } else if (gData.gnssInterface != NULL) { + id = gData.gnssInterface->startTracking(this, locationOptions); + } else { + LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + } else { + LOC_LOGE("%s:%d]: Location API client %p not found in client data", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return id; +} + +void +LocationAPI::stopTracking(uint32_t id) +{ + pthread_mutex_lock(&gDataMutex); + + auto it = gData.clientData.find(this); + if (it != gData.clientData.end()) { + // we don't know if tracking was started on flp or gnss, so we call stop on both, where + // stopTracking call to the incorrect interface will fail without response back to client + if (gData.gnssInterface != NULL) { + gData.gnssInterface->stopTracking(this, id); + } + if (gData.flpInterface != NULL) { + gData.flpInterface->stopTracking(this, id); + } + if (gData.flpInterface != NULL && gData.gnssInterface != NULL) { + LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + } else { + LOC_LOGE("%s:%d]: Location API client %p not found in client data", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions) +{ + pthread_mutex_lock(&gDataMutex); + + auto it = gData.clientData.find(this); + if (it != gData.clientData.end()) { + // we don't know if tracking was started on flp or gnss, so we call update on both, where + // updateTracking call to the incorrect interface will fail without response back to client + if (gData.gnssInterface != NULL) { + gData.gnssInterface->updateTrackingOptions(this, id, locationOptions); + } + if (gData.flpInterface != NULL) { + gData.flpInterface->updateTrackingOptions(this, id, locationOptions); + } + if (gData.flpInterface != NULL && gData.gnssInterface != NULL) { + LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + } else { + LOC_LOGE("%s:%d]: Location API client %p not found in client data", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +uint32_t +LocationAPI::startBatching(LocationOptions& locationOptions) +{ + uint32_t id = 0; + pthread_mutex_lock(&gDataMutex); + + if (gData.flpInterface != NULL) { + id = gData.flpInterface->startBatching(this, locationOptions); + } else { + LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return id; +} + +void +LocationAPI::stopBatching(uint32_t id) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.flpInterface != NULL) { + gData.flpInterface->stopBatching(this, id); + } else { + LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::updateBatchingOptions(uint32_t id, LocationOptions& locationOptions) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.flpInterface != NULL) { + gData.flpInterface->updateBatchingOptions(this, + id, + locationOptions); + } else { + LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::getBatchedLocations(uint32_t id, size_t count) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.flpInterface != NULL) { + gData.flpInterface->getBatchedLocations(this, id, count); + } else { + LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +uint32_t* +LocationAPI::addGeofences(size_t count, GeofenceOption* options, GeofenceInfo* info) +{ + uint32_t* ids = NULL; + pthread_mutex_lock(&gDataMutex); + + if (gData.geofenceInterface != NULL) { + ids = gData.geofenceInterface->addGeofences(this, count, options, info); + } else { + LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return ids; +} + +void +LocationAPI::removeGeofences(size_t count, uint32_t* ids) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.geofenceInterface != NULL) { + gData.geofenceInterface->removeGeofences(this, count, ids); + } else { + LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.geofenceInterface != NULL) { + gData.geofenceInterface->modifyGeofences(this, count, ids, options); + } else { + LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::pauseGeofences(size_t count, uint32_t* ids) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.geofenceInterface != NULL) { + gData.geofenceInterface->pauseGeofences(this, count, ids); + } else { + LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::resumeGeofences(size_t count, uint32_t* ids) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.geofenceInterface != NULL) { + gData.geofenceInterface->resumeGeofences(this, count, ids); + } else { + LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +void +LocationAPI::gnssNiResponse(uint32_t id, GnssNiResponse response) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.gnssInterface != NULL) { + gData.gnssInterface->gnssNiResponse(this, id, response); + } else { + LOC_LOGE("%s:%d]: No gnss interface available for Location API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +LocationControlAPI* +LocationControlAPI::createInstance(LocationControlCallbacks& locationControlCallbacks) +{ + LocationControlAPI* controlAPI = NULL; + pthread_mutex_lock(&gDataMutex); + + if (nullptr != locationControlCallbacks.responseCb && NULL == gData.controlAPI) { + if (NULL == gData.gnssInterface && !gGnssLoadFailed) { + gData.gnssInterface = + (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface"); + if (NULL == gData.gnssInterface) { + gGnssLoadFailed = true; + LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__); + } else { + gData.gnssInterface->initialize(); + } + } + if (NULL != gData.gnssInterface) { + gData.controlAPI = new LocationControlAPI(); + gData.controlCallbacks = locationControlCallbacks; + gData.gnssInterface->setControlCallbacks(locationControlCallbacks); + controlAPI = gData.controlAPI; + } + } + + pthread_mutex_unlock(&gDataMutex); + return controlAPI; +} + +void +LocationControlAPI::destroy() +{ + delete this; +} + +LocationControlAPI::LocationControlAPI() +{ + LOC_LOGD("LOCATION CONTROL API CONSTRUCTOR"); +} + +LocationControlAPI::~LocationControlAPI() +{ + LOC_LOGD("LOCATION CONTROL API DESTRUCTOR"); + pthread_mutex_lock(&gDataMutex); + + size_t gnssClientCount = 0; + for (auto it=gData.clientData.begin(); it != gData.clientData.end(); ++it) { + if (isGnssClient(it->second)) { + gnssClientCount++; + } + } + if (gData.gnssInterface != NULL && 0 == gnssClientCount) { + //@todo: we might want to call gData.gnssInterface.disable before deinitialize? + gData.gnssInterface->deinitialize(); + } + gData.controlAPI = NULL; + + pthread_mutex_unlock(&gDataMutex); +} + +uint32_t +LocationControlAPI::enable(LocationTechnologyType techType) +{ + uint32_t id = 0; + pthread_mutex_lock(&gDataMutex); + + if (gData.gnssInterface != NULL) { + id = gData.gnssInterface->enable(techType); + } else { + LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return id; +} + +void +LocationControlAPI::disable(uint32_t id) +{ + pthread_mutex_lock(&gDataMutex); + + if (gData.gnssInterface != NULL) { + gData.gnssInterface->disable(id); + } else { + LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); +} + +uint32_t* +LocationControlAPI::gnssUpdateConfig(GnssConfig config) +{ + uint32_t* ids = NULL; + pthread_mutex_lock(&gDataMutex); + + if (gData.gnssInterface != NULL) { + ids = gData.gnssInterface->gnssUpdateConfig(config); + } else { + LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return ids; +} + +uint32_t +LocationControlAPI::gnssDeleteAidingData(GnssAidingData& data) +{ + uint32_t id = 0; + pthread_mutex_lock(&gDataMutex); + + if (gData.gnssInterface != NULL) { + id = gData.gnssInterface->gnssDeleteAidingData(data); + } else { + LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ", + __func__, __LINE__, this); + } + + pthread_mutex_unlock(&gDataMutex); + return id; +} diff --git a/location/LocationAPI.h b/location/LocationAPI.h new file mode 100644 index 00000000..cc15ddd3 --- /dev/null +++ b/location/LocationAPI.h @@ -0,0 +1,866 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LOCATION_H +#define LOCATION_H + +#include +#include + +#define GNSS_NI_REQUESTOR_MAX 256 +#define GNSS_NI_MESSAGE_ID_MAX 2048 +#define GNSS_SV_MAX 64 +#define GNSS_MEASUREMENTS_MAX 64 + +typedef enum { + LOCATION_ERROR_SUCCESS = 0, + LOCATION_ERROR_GENERAL_FAILURE, + LOCATION_ERROR_CALLBACK_MISSING, + LOCATION_ERROR_INVALID_PARAMETER, + LOCATION_ERROR_ID_EXISTS, + LOCATION_ERROR_ID_UNKNOWN, + LOCATION_ERROR_ALREADY_STARTED, + LOCATION_ERROR_GEOFENCES_AT_MAX, + LOCATION_ERROR_NOT_SUPPORTED +} LocationError; + +// Flags to indicate which values are valid in a Location +typedef uint16_t LocationFlagsMask; +typedef enum { + LOCATION_HAS_LAT_LONG_BIT = (1<<0), // location has valid latitude and longitude + LOCATION_HAS_ALTITUDE_BIT = (1<<1), // location has valid altitude + LOCATION_HAS_SPEED_BIT = (1<<2), // location has valid speed + LOCATION_HAS_BEARING_BIT = (1<<3), // location has valid bearing + LOCATION_HAS_ACCURACY_BIT = (1<<4), // location has valid accuracy +} LocationFlagsBits; + +typedef uint16_t LocationTechnologyMask; +typedef enum { + LOCATION_TECHNOLOGY_GNSS_BIT = (1<<0), // location was calculated using GNSS + LOCATION_TECHNOLOGY_CELL_BIT = (1<<1), // location was calculated using Cell + LOCATION_TECHNOLOGY_WIFI_BIT = (1<<2), // location was calculated using WiFi + LOCATION_TECHNOLOGY_SENSORS_BIT = (1<<3), // location was calculated using Sensors +} LocationTechnologyBits; + +typedef enum { + LOCATION_RELIABILITY_NOT_SET = 0, + LOCATION_RELIABILITY_VERY_LOW, + LOCATION_RELIABILITY_LOW, + LOCATION_RELIABILITY_MEDIUM, + LOCATION_RELIABILITY_HIGH, +} LocationReliability; + +typedef uint32_t GnssLocationInfoFlagMask; +typedef enum { + GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT = (1<<0), // valid altitude mean sea level + GNSS_LOCATION_INFO_DOP_BIT = (1<<1), // valid pdop, hdop, and vdop + GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT = (1<<2), // valid magnetic deviation + GNSS_LOCATION_INFO_VER_ACCURACY_BIT = (1<<3), // valid vertical accuracy + GNSS_LOCATION_INFO_SPEED_ACCURACY_BIT = (1<<4), // valid speed accuracy + GNSS_LOCATION_INFO_BEARING_ACCURACY_BIT = (1<<5), // valid bearing accuracy + GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT = (1<<6), // valid horizontal reliability + GNSS_LOCATION_INFO_VER_RELIABILITY_BIT = (1<<7), // valid vertical reliability + GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT = (1<<8), // valid elipsode semi major + GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT = (1<<9), // valid elipsode semi minor + GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<10),// valid accuracy elipsode azimuth +} GnssLocationInfoFlagBits; + +typedef enum { + GEOFENCE_BREACH_ENTER = 0, + GEOFENCE_BREACH_EXIT, + GEOFENCE_BREACH_DWELL_IN, + GEOFENCE_BREACH_DWELL_OUT, + GEOFENCE_BREACH_UNKNOWN, +} GeofenceBreachType; + +typedef uint16_t GeofenceBreachTypeMask; +typedef enum { + GEOFENCE_BREACH_ENTER_BIT = (1<<0), + GEOFENCE_BREACH_EXIT_BIT = (1<<1), + GEOFENCE_BREACH_DWELL_IN_BIT = (1<<2), + GEOFENCE_BREACH_DWELL_OUT_BIT = (1<<3), +} GeofenceBreachTypeBits; + +typedef enum { + GEOFENCE_STATUS_AVAILABILE_NO = 0, + GEOFENCE_STATUS_AVAILABILE_YES, +} GeofenceStatusAvailable; + +typedef uint32_t LocationCapabilitiesMask; +typedef enum { + // supports startTracking API with minInterval param + LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT = (1<<0), + // supports startBatching API with minInterval param + LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT = (1<<1), + // supports startTracking API with minDistance param + LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT = (1<<2), + // supports startBatching API with minDistance param + LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT = (1<<3), + // supports addGeofences API + LOCATION_CAPABILITIES_GEOFENCE_BIT = (1<<4), + // supports GnssMeasurementsCallback + LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT = (1<<5), + // supports startTracking/startBatching API with LocationOptions.mode of MSB (Ms Based) + LOCATION_CAPABILITIES_GNSS_MSB_BIT = (1<<6), + // supports startTracking/startBatching API with LocationOptions.mode of MSA (MS Assisted) + LOCATION_CAPABILITIES_GNSS_MSA_BIT = (1<<7), +} LocationCapabilitiesBits; + +typedef enum { + LOCATION_TECHNOLOGY_TYPE_GNSS = 0, +} LocationTechnologyType; + +// Configures how GPS is locked when GPS is disabled (through GnssDisable) +typedef enum { + GNSS_CONFIG_GPS_LOCK_NONE = 0, // gps is not locked when GPS is disabled (GnssDisable) + GNSS_CONFIG_GPS_LOCK_MO, // gps mobile originated (MO) is locked when GPS is disabled + GNSS_CONFIG_GPS_LOCK_NI, // gps network initiated (NI) is locked when GPS is disabled + GNSS_CONFIG_GPS_LOCK_MO_AND_NI,// gps MO and NI is locked when GPS is disabled +} GnssConfigGpsLock; + +// SUPL version +typedef enum { + GNSS_CONFIG_SUPL_VERSION_1_0_0 = 1, + GNSS_CONFIG_SUPL_VERSION_2_0_0, + GNSS_CONFIG_SUPL_VERSION_2_0_2, +} GnssConfigSuplVersion; + +// LTE Positioning Profile +typedef enum { + GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE = 0, // RRLP on LTE (Default) + GNSS_CONFIG_LPP_PROFILE_USER_PLANE, // LPP User Plane (UP) on LTE + GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE, // LPP_Control_Plane (CP) + GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE, // Both LPP UP and CP +} GnssConfigLppProfile; + +// Technology for LPPe Control Plane +typedef uint16_t GnssConfigLppeControlPlaneMask; +typedef enum { + GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT = (1<<0), // DBH + GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS +} GnssConfigLppeControlPlaneBits; + +// Technology for LPPe User Plane +typedef uint16_t GnssConfigLppeUserPlaneMask; +typedef enum { + GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT = (1<<0), // DBH + GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS +} GnssConfigLppeUserPlaneBits; + +// Positioning Protocol on A-GLONASS system +typedef uint16_t GnssConfigAGlonassPositionProtocolMask; +typedef enum { + GNSS_CONFIG_RRC_CONTROL_PLANE_BIT = (1<<0), // RRC Control Plane + GNSS_CONFIG_RRLP_USER_PLANE_BIT = (1<<1), // RRLP User Plane + GNSS_CONFIG_LLP_USER_PLANE_BIT = (1<<2), // LPP User Plane + GNSS_CONFIG_LLP_CONTROL_PLANE_BIT = (1<<3), // LPP Control Plane +} GnssConfigAGlonassPositionProtocolBits; + +typedef enum { + GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO = 0, + GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES, +} GnssConfigEmergencyPdnForEmergencySupl; + +typedef enum { + GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO = 0, + GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES, +} GnssConfigSuplEmergencyServices; + +typedef uint16_t GnssConfigSuplModeMask; +typedef enum { + GNSS_CONFIG_SUPL_MODE_MSB = (1<<0), + GNSS_CONFIG_SUPL_MODE_MSA = (1<<1), +} GnssConfigSuplModeBits; + +typedef uint32_t GnssConfigFlagsMask; +typedef enum { + GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT = (1<<0), + GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT = (1<<1), + GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT = (1<<2), + GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT = (1<<3), + GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT = (1<<4), + GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT = (1<<5), + GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT = (1<<6), + GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT = (1<<7), + GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT = (1<<8), + GNSS_CONFIG_FLAGS_SUPL_MODE_BIT = (1<<9), +} GnssConfigFlagsBits; + +typedef enum { + GNSS_NI_ENCODING_TYPE_NONE = 0, + GNSS_NI_ENCODING_TYPE_GSM_DEFAULT, + GNSS_NI_ENCODING_TYPE_UTF8, + GNSS_NI_ENCODING_TYPE_UCS2, +} GnssNiEncodingType; + +typedef enum { + GNSS_NI_TYPE_VOICE = 0, + GNSS_NI_TYPE_SUPL, + GNSS_NI_TYPE_CONTROL_PLANE, + GNSS_NI_TYPE_EMERGENCY_SUPL +} GnssNiType; + +typedef uint16_t GnssNiOptionsMask; +typedef enum { + GNSS_NI_OPTIONS_NOTIFICATION = (1<<0), + GNSS_NI_OPTIONS_VERIFICATION = (1<<1), + GNSS_NI_OPTIONS_PRIVACY_OVERRIDE = (1<<2), +} GnssNiOptionsBits; + +typedef enum { + GNSS_NI_RESPONSE_ACCEPT = 1, + GNSS_NI_RESPONSE_DENY, + GNSS_NI_RESPONSE_NO_RESPONSE, + GNSS_NI_RESPONSE_IGNORE, +} GnssNiResponse; + +typedef enum { + GNSS_SV_TYPE_UNKNOWN = 0, + GNSS_SV_TYPE_GPS, + GNSS_SV_TYPE_SBAS, + GNSS_SV_TYPE_GLONASS, + GNSS_SV_TYPE_QZSS, + GNSS_SV_TYPE_BEIDOU, + GNSS_SV_TYPE_GALILEO, +} GnssSvType; + +typedef uint16_t GnssSvOptionsMask; +typedef enum { + GNSS_SV_OPTIONS_HAS_EPHEMER_BIT = (1<<0), + GNSS_SV_OPTIONS_HAS_ALMANAC_BIT = (1<<1), + GNSS_SV_OPTIONS_USED_IN_FIX_BIT = (1<<2), +} GnssSvOptionsBits; + +typedef enum { + GNSS_ASSISTANCE_TYPE_SUPL = 0, + GNSS_ASSISTANCE_TYPE_C2K, +} GnssAssistanceType; + +typedef enum { + GNSS_SUPL_MODE_STANDALONE = 0, + GNSS_SUPL_MODE_MSB, + GNSS_SUPL_MODE_MSA, +} GnssSuplMode; + +typedef uint16_t GnssMeasurementsAdrStateMask; +typedef enum { + GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_UNKNOWN = 0, + GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT = (1<<0), + GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT = (1<<1), + GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT = (1<<2), +} GnssMeasurementsAdrStateBits; + +typedef uint32_t GnssMeasurementsDataFlagsMask; +typedef enum { + GNSS_MEASUREMENTS_DATA_SV_ID_BIT = (1<<0), + GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT = (1<<1), + GNSS_MEASUREMENTS_DATA_STATE_BIT = (1<<2), + GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_BIT = (1<<3), + GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_UNCERTAINTY_BIT = (1<<4), + GNSS_MEASUREMENTS_DATA_CARRIER_TO_NOISE_BIT = (1<<5), + GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT = (1<<6), + GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT = (1<<7), + GNSS_MEASUREMENTS_DATA_ADR_STATE_BIT = (1<<8), + GNSS_MEASUREMENTS_DATA_ADR_BIT = (1<<9), + GNSS_MEASUREMENTS_DATA_ADR_UNCERTAINTY_BIT = (1<<10), + GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT = (1<<11), + GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT = (1<<12), + GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT = (1<<13), + GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT = (1<<14), + GNSS_MEASUREMENTS_DATA_MULTIPATH_INDICATOR_BIT = (1<<15), + GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT = (1<<16), +} GnssMeasurementsDataFlagsBits; + +typedef uint32_t GnssMeasurementsStateMask; +typedef enum { + GNSS_MEASUREMENTS_STATE_UNKNOWN_BIT = 0, + GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT = (1<<0), + GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT = (1<<1), + GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT = (1<<2), + GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT = (1<<3), + GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT = (1<<4), + GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT = (1<<5), + GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT = (1<<6), + GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT = (1<<7), + GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT = (1<<8), + GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT = (1<<9), + GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT = (1<<10), + GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT = (1<<11), + GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT = (1<<12), + GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT = (1<<13), +} GnssMeasurementsStateBits; + +typedef enum { + GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN = 0, + GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT, + GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT, +} GnssMeasurementsMultipathIndicator; + +typedef uint32_t GnssMeasurementsClockFlagsMask; +typedef enum { + GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT = (1<<0), + GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_BIT = (1<<1), + GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT = (1<<2), + GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT = (1<<3), + GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT = (1<<4), + GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT = (1<<5), + GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT = (1<<6), + GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT = (1<<7), + GNSS_MEASUREMENTS_CLOCK_FLAGS_HW_CLOCK_DISCONTINUITY_COUNT_BIT = (1<<8), +} GnssMeasurementsClockFlagsBits; + +typedef uint32_t GnssAidingDataSvMask; +typedef enum { + GNSS_AIDING_DATA_SV_EPHEMERIS = (1<<0), // ephemeris + GNSS_AIDING_DATA_SV_ALMANAC = (1<<1), // almanac + GNSS_AIDING_DATA_SV_HEALTH = (1<<2), // health + GNSS_AIDING_DATA_SV_DIRECTION = (1<<3), // direction + GNSS_AIDING_DATA_SV_STEER = (1<<4), // steer + GNSS_AIDING_DATA_SV_ALMANAC_CORR = (1<<5), // almanac correction + GNSS_AIDING_DATA_SV_BLACKLIST = (1<<6), // blacklist SVs + GNSS_AIDING_DATA_SV_SA_DATA = (1<<7), // sensitivity assistance data + GNSS_AIDING_DATA_SV_NO_EXIST = (1<<8), // SV does not exist + GNSS_AIDING_DATA_SV_IONOSPHERE = (1<<9), // ionosphere correction + GNSS_AIDING_DATA_SV_TIME = (1<<10),// reset satellite time +} GnssAidingDataSvBits; + +typedef uint32_t GnssAidingDataSvTypeMask; +typedef enum { + GNSS_AIDING_DATA_SV_TYPE_GPS = (1<<0), + GNSS_AIDING_DATA_SV_TYPE_GLONASS = (1<<1), + GNSS_AIDING_DATA_SV_TYPE_QZSS = (1<<2), + GNSS_AIDING_DATA_SV_TYPE_BEIDOU = (1<<3), + GNSS_AIDING_DATA_SV_TYPE_GALILEO = (1<<4), +} GnssAidingDataSvTypeBits; + +typedef struct { + GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits + GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits +} GnssAidingDataSv; + +typedef uint32_t GnssAidingDataCommonMask; +typedef enum { + GNSS_AIDING_DATA_COMMON_POSITION = (1<<0), // position estimate + GNSS_AIDING_DATA_COMMON_TIME = (1<<1), // reset all clock values + GNSS_AIDING_DATA_COMMON_UTC = (1<<2), // UTC estimate + GNSS_AIDING_DATA_COMMON_RTI = (1<<3), // RTI + GNSS_AIDING_DATA_COMMON_FREQ_BIAS_EST = (1<<4), // frequency bias estimate + GNSS_AIDING_DATA_COMMON_CELLDB = (1<<5), // all celldb info +} GnssAidingDataCommonBits; + +typedef struct { + GnssAidingDataCommonMask mask; // bitwise OR of GnssAidingDataCommonBits +} GnssAidingDataCommon; + +typedef struct { + bool deleteAll; // if true, delete all aiding data and ignore other params + GnssAidingDataSv sv; // SV specific aiding data + GnssAidingDataCommon common; // common aiding data +} GnssAidingData; + +typedef struct { + size_t size; // set to sizeof(Location) + LocationFlagsMask flags; // bitwise OR of LocationFlagsBits to mark which params are valid + uint64_t timestamp; // UTC timestamp for location fix, milliseconds since January 1, 1970 + double latitude; // in degrees + double longitude; // in degrees + double altitude; // in meters above the WGS 84 reference ellipsoid + float speed; // in meters per second + float bearing; // in degrees; range [0, 360) + float accuracy; // in meters + LocationTechnologyMask techMask; +} Location; + +typedef struct { + size_t size; // set to sizeof(LocationOptions) + uint32_t minInterval; // in milliseconds + uint32_t minDistance; // in meters. if minDistance > 0, gnssSvCallback/gnssNmeaCallback/ + // gnssMeasurementsCallback may not be called + GnssSuplMode mode; // Standalone/MS-Based/MS-Assisted +} LocationOptions; + +typedef struct { + size_t size; // set to sizeof(GeofenceOption) + GeofenceBreachTypeMask breachTypeMask; // bitwise OR of GeofenceBreachTypeBits + uint32_t responsiveness; // in milliseconds + uint32_t dwellTime; // in seconds +} GeofenceOption; + +typedef struct { + size_t size; // set to sizeof(GeofenceInfo) + double latitude; // in degrees + double longitude; // in degrees + double radius; // in meters +} GeofenceInfo; + +typedef struct { + size_t size; // set to sizeof(GeofenceBreachNotification) + size_t count; // number of ids in array + uint32_t* ids; // array of ids that have breached + Location location; // location associated with breach + GeofenceBreachType type; // type of breach + uint64_t timestamp; // timestamp of breach +} GeofenceBreachNotification; + +typedef struct { + size_t size; // set to sizeof(GeofenceBreachNotification) + GeofenceStatusAvailable available; // GEOFENCE_STATUS_AVAILABILE_NO/_YES + LocationTechnologyType techType; // GNSS +} GeofenceStatusNotification; + +typedef struct { + size_t size; // set to sizeof(GnssLocationInfo) + GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity + float altitudeMeanSeaLevel; // altitude wrt mean sea level + float pdop; // position dilusion of precision + float hdop; // horizontal dilusion of precision + float vdop; // vertical dilusion of precision + float magneticDeviation; // magnetic deviation + float verAccuracy; // vertical accuracy in meters + float speedAccuracy; // speed accuracy in meters/second + float bearingAccuracy; // bearing accuracy in degrees (0 to 359.999) + LocationReliability horReliability; // horizontal reliability + LocationReliability verReliability; // vertical reliability + float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis + float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis + float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth +} GnssLocationInfoNotification; + +typedef struct { + size_t size; // set to sizeof(GnssNiNotification) + GnssNiType type; // type of NI (Voice, SUPL, Control Plane) + GnssNiOptionsMask options; // bitwise OR of GnssNiOptionsBits + uint32_t timeout; // time (seconds) to wait for user input + GnssNiResponse timeoutResponse; // the response that should be sent when timeout expires + char requestor[GNSS_NI_REQUESTOR_MAX]; // the requestor that is making the request + GnssNiEncodingType requestorEncoding; // the encoding type for requestor + char message[GNSS_NI_MESSAGE_ID_MAX]; // the message to show user + GnssNiEncodingType messageEncoding; // the encoding type for message + char extras[GNSS_NI_MESSAGE_ID_MAX]; +} GnssNiNotification; + +typedef struct { + size_t size; // set to sizeof(GnssSv) + uint16_t svId; // Unique Identifier + GnssSvType type; // type of SV (GPS, SBAS, GLONASS, QZSS, BEIDOU, GALILEO) + float cN0Dbhz; // signal strength + float elevation; // elevation of SV (in degrees) + float azimuth; // azimuth of SV (in degrees) + GnssSvOptionsMask gnssSvOptionsMask; // Bitwise OR of GnssSvOptionsBits +} GnssSv; + +typedef struct { + size_t size; // set to sizeof(GnssConfigSetAssistanceServer) + GnssAssistanceType type; // SUPL or C2K + const char* hostName; // null terminated string + uint32_t port; // port of server +} GnssConfigSetAssistanceServer; + +typedef struct { + size_t size; // set to sizeof(GnssMeasurementsData) + GnssMeasurementsDataFlagsMask flags; // bitwise OR of GnssMeasurementsDataFlagsBits + int16_t svId; + GnssSvType svType; + double timeOffsetNs; + GnssMeasurementsStateMask stateMask; // bitwise OR of GnssMeasurementsStateBits + int64_t receivedSvTimeNs; + int64_t receivedSvTimeUncertaintyNs; + double carrierToNoiseDbHz; + double pseudorangeRateMps; + double pseudorangeRateUncertaintyMps; + GnssMeasurementsAdrStateMask adrStateMask; // bitwise OR of GnssMeasurementsAdrStateBits + double adrMeters; + double adrUncertaintyMeters; + float carrierFrequencyHz; + int64_t carrierCycles; + double carrierPhase; + double carrierPhaseUncertainty; + GnssMeasurementsMultipathIndicator multipathIndicator; + double signalToNoiseRatioDb; +} GnssMeasurementsData; + +typedef struct { + size_t size; // set to sizeof(GnssMeasurementsClock) + GnssMeasurementsClockFlagsMask flags; // bitwise OR of GnssMeasurementsClockFlagsBits + int16_t leapSecond; + int64_t timeNs; + double timeUncertaintyNs; + int64_t fullBiasNs; + double biasNs; + double biasUncertaintyNs; + double driftNsps; + double driftUncertaintyNsps; + uint32_t hwClockDiscontinuityCount; +} GnssMeasurementsClock; + +typedef struct { + size_t size; // set to sizeof(GnssSvNotification) + size_t count; // number of SVs in the GnssSv array + GnssSv gnssSvs[GNSS_SV_MAX]; // information on a number of SVs +} GnssSvNotification; + +typedef struct { + size_t size; // set to sizeof(GnssNmeaNotification) + uint64_t timestamp; // timestamp + const char* nmea; // nmea text + size_t length; // length of the nmea text +} GnssNmeaNotification; + +typedef struct { + size_t size; // set to sizeof(GnssMeasurementsNotification) + size_t count; // number of items in GnssMeasurements array + GnssMeasurementsData measurements[GNSS_MEASUREMENTS_MAX]; + GnssMeasurementsClock clock; // clock +} GnssMeasurementsNotification; + +typedef struct { + size_t size; // set to sizeof(GnssConfig) + GnssConfigFlagsMask flags; // bitwise OR of GnssConfigFlagsBits to mark which params are valid + GnssConfigGpsLock gpsLock; + GnssConfigSuplVersion suplVersion; + GnssConfigSetAssistanceServer assistanceServer; + GnssConfigLppProfile lppProfile; + GnssConfigLppeControlPlaneMask lppeControlPlaneMask; + GnssConfigLppeUserPlaneMask lppeUserPlaneMask; + GnssConfigAGlonassPositionProtocolMask aGlonassPositionProtocolMask; + GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl; + GnssConfigSuplEmergencyServices suplEmergencyServices; + GnssConfigSuplModeMask suplModeMask; //bitwise OR of GnssConfigSuplModeBits +} GnssConfig; + +/* Provides the capabilities of the system + capabilities callback is called once soon after createInstance is called */ +typedef std::function capabilitiesCallback; + +/* Used by tracking, batching, and miscellanous APIs + responseCallback is called for every Tracking, Batching API, and Miscellanous API */ +typedef std::function responseCallback; + +/* Used by APIs that gets more than one LocationError in it's response + collectiveResponseCallback is called for every geofence API call. + ids array and LocationError array are only valid until collectiveResponseCallback returns. */ +typedef std::function collectiveResponseCallback; + +/* Used for startTracking API, optional can be NULL + trackingCallback is called when delivering a location in a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function trackingCallback; + +/* Used for startBatching API, optional can be NULL + batchingCallback is called when delivering locations in a batching session. + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function batchingCallback; + +/* Gives GNSS Location information, optional can be NULL + gnssLocationInfoCallback is called only during a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function gnssLocationInfoCallback; + +/* Used for addGeofences API, optional can be NULL + geofenceBreachCallback is called when any number of geofences have a state change */ +typedef std::function geofenceBreachCallback; + +/* Used for addGeofences API, optional can be NULL + geofenceStatusCallback is called when any number of geofences have a status change */ +typedef std::function geofenceStatusCallback; + +/* Network Initiated request, optional can be NULL + This callback should be responded to by calling gnssNiResponse */ +typedef std::function gnssNiCallback; + +/* Gives GNSS SV information, optional can be NULL + gnssSvCallback is called only during a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function gnssSvCallback; + +/* Gives GNSS NMEA data, optional can be NULL + gnssNmeaCallback is called only during a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function gnssNmeaCallback; + +/* Gives GNSS Measurements information, optional can be NULL + gnssMeasurementsCallback is called only during a tracking session + broadcasted to all clients, no matter if a session has started by client */ +typedef std::function gnssMeasurementsCallback; + +typedef struct { + size_t size; // set to sizeof(LocationCallbacks) + capabilitiesCallback capabilitiesCb; // mandatory + responseCallback responseCb; // mandatory + collectiveResponseCallback collectiveResponseCb; // mandatory + trackingCallback trackingCb; // optional + batchingCallback batchingCb; // optional + geofenceBreachCallback geofenceBreachCb; // optional + geofenceStatusCallback geofenceStatusCb; // optional + gnssLocationInfoCallback gnssLocationInfoCb; // optional + gnssNiCallback gnssNiCb; // optional + gnssSvCallback gnssSvCb; // optional + gnssNmeaCallback gnssNmeaCb; // optional + gnssMeasurementsCallback gnssMeasurementsCb; // optional +} LocationCallbacks; + +class LocationAPI +{ +private: + LocationAPI(); + ~LocationAPI(); + +public: + /* creates an instance to LocationAPI object. + Will return NULL if mandatory parameters are invalid or if the maximum number + of instances have been reached */ + static LocationAPI* createInstance(LocationCallbacks&); + + /* destroy/cleans up the instance, which should be called when LocationAPI object is + no longer needed. LocationAPI* returned from createInstance will no longer valid + after destroy is called */ + void destroy(); + + /* updates/changes the callbacks that will be called. + mandatory callbacks must be present for callbacks to be successfully updated + no return value */ + void updateCallbacks(LocationCallbacks&); + + /* ================================== TRACKING ================================== */ + + /* startTracking starts a tracking session, which returns a session id that will be + used by the other tracking APIs and also in the responseCallback to match command + with response. locations are reported on the trackingCallback passed in createInstance + periodically according to LocationOptions. + responseCallback returns: + LOCATION_ERROR_SUCCESS if session was successfully started + LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress + LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed in createInstance + LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */ + uint32_t startTracking(LocationOptions&); // returns session id + + /* stopTracking stops a tracking session associated with id parameter. + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */ + void stopTracking(uint32_t id); + + /* updateTrackingOptions changes the LocationOptions of a tracking session associated with id + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */ + void updateTrackingOptions(uint32_t id, LocationOptions&); + + /* ================================== BATCHING ================================== */ + + /* startBatching starts a batching session, which returns a session id that will be + used by the other batching APIs and also in the responseCallback to match command + with response. locations are reported on the batchingCallback passed in createInstance + periodically according to LocationOptions. A batching session starts tracking on + the low power processor and delivers them in batches by the batchingCallback when + the batch is full or when getBatchedLocations is called. This allows for the processor + that calls this API to sleep when the low power processor can batch locations in the + backgroup and wake up the processor calling the API only when the batch is full, thus + saving power + responseCallback returns: + LOCATION_ERROR_SUCCESS if session was successful + LOCATION_ERROR_ALREADY_STARTED if a startBatching session is already in progress + LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance + LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid + LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */ + uint32_t startBatching(LocationOptions&); // returns session id + + /* stopBatching stops a batching session associated with id parameter. + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with batching session */ + void stopBatching(uint32_t id); + + /* updateBatchingOptions changes the LocationOptions of a batching session associated with id + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */ + void updateBatchingOptions(uint32_t id, LocationOptions&); + + /* getBatchedLocations gets a number of locations that are currently stored/batched + on the low power processor, delivered by the batchingCallback passed in createInstance. + Location are then deleted from the batch stored on the low power processor. + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful, will be followed by batchingCallback call + LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */ + void getBatchedLocations(uint32_t id, size_t count); + + /* ================================== GEOFENCE ================================== */ + + /* addGeofences adds any number of geofences and returns an array of geofence ids that + will be used by the other geofence APIs and also in the collectiveResponseCallback to + match command with response. The geofenceBreachCallback will deliver the status of each + geofence according to the GeofenceOption for each. The geofence id array returned will + be valid until the collectiveResponseCallback is called and has returned. + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if session was successful + LOCATION_ERROR_CALLBACK_MISSING if no geofenceBreachCallback + LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid + LOCATION_ERROR_NOT_SUPPORTED if geofence is not supported */ + uint32_t* addGeofences(size_t count, GeofenceOption*, GeofenceInfo*); // returns id array + + /* removeGeofences removes any number of geofences. Caller should delete ids array after + removeGeofences returneds. + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ + void removeGeofences(size_t count, uint32_t* ids); + + /* modifyGeofences modifies any number of geofences. Caller should delete ids array after + modifyGeofences returns. + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session + LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid */ + void modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options); + + /* pauseGeofences pauses any number of geofences, which is similar to removeGeofences, + only that they can be resumed at any time. Caller should delete ids array after + pauseGeofences returns. + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ + void pauseGeofences(size_t count, uint32_t* ids); + + /* resumeGeofences resumes any number of geofences that are currently paused. Caller should + delete ids array after resumeGeofences returns. + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ + void resumeGeofences(size_t count, uint32_t* ids); + + /* ================================== GNSS ====================================== */ + + /* gnssNiResponse is called in response to a gnssNiCallback. + responseCallback returns: + LOCATION_ERROR_SUCCESS if session was successful + LOCATION_ERROR_INVALID_PARAMETER if any parameters in GnssNiResponse are invalid + LOCATION_ERROR_ID_UNKNOWN if id does not match a gnssNiCallback */ + void gnssNiResponse(uint32_t id, GnssNiResponse response); +}; + +typedef struct { + size_t size; // set to sizeof(LocationControlCallbacks) + responseCallback responseCb; // mandatory + collectiveResponseCallback collectiveResponseCb; // mandatory +} LocationControlCallbacks; + +class LocationControlAPI +{ +private: + LocationControlAPI(); + ~LocationControlAPI(); + +public: + /* creates an instance to LocationControlAPI object. + Will return NULL if mandatory parameters are invalid or if the maximum number + of instances have been reached. Only once instance allowed */ + static LocationControlAPI* createInstance(LocationControlCallbacks&); + + /* destroy/cleans up the instance, which should be called when LocationControlAPI object is + no longer needed. LocationControlAPI* returned from createInstance will no longer valid + after destroy is called */ + void destroy(); + + /* enable will enable specific location technology to be used for calculation locations and + will effectively start a control session if call is successful, which returns a session id + that will be returned in responseCallback to match command with response. The session id is + also needed to call the disable command. + This effect is global for all clients of LocationAPI + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ALREADY_STARTED if an enable was already called for this techType + LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid + LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ + uint32_t enable(LocationTechnologyType techType); + + /* disable will disable specific location technology to be used for calculation locations and + effectively ends the control session if call is successful. + id parameter is the session id that was returned in enable responseCallback for techType. + The session id is no longer valid after disable's responseCallback returns success. + This effect is global for all clients of LocationAPI + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_ID_UNKNOWN if id was not returned from responseCallback from enable + LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ + void disable(uint32_t id); + + /* gnssUpdateConfig updates the gnss specific configuration, which returns a session id array + with an id for each of the bits set in GnssConfig.flags, order from low bits to high bits. + The response for each config that is set will be returned in collectiveResponseCallback. + The session id array returned will be valid until the collectiveResponseCallback is called + and has returned. This effect is global for all clients of LocationAPI + collectiveResponseCallback returns: + LOCATION_ERROR_SUCCESS if session was successful + LOCATION_ERROR_INVALID_PARAMETER if any other parameters are invalid + LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ + uint32_t* gnssUpdateConfig(GnssConfig config); + + /* delete specific gnss aiding data for testing, which returns a session id + that will be returned in responseCallback to match command with response. + Only allowed in userdebug builds. This effect is global for all clients of LocationAPI + responseCallback returns: + LOCATION_ERROR_SUCCESS if successful + LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid + LOCATION_ERROR_NOT_SUPPORTED if build is not userdebug */ + uint32_t gnssDeleteAidingData(GnssAidingData& data); +}; + +#endif /* LOCATION_H */ diff --git a/location/LocationAPIClientBase.cpp b/location/LocationAPIClientBase.cpp new file mode 100644 index 00000000..3413d3ef --- /dev/null +++ b/location/LocationAPIClientBase.cpp @@ -0,0 +1,769 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#define LOG_NDDEBUG 0 +#define LOG_TAG "LocSvc_APIClientBase" + +#include +#include +#include "LocationAPIClientBase.h" + +#define FLP_CONF_FILE "/etc/flp.conf" + +LocationAPIClientBase::LocationAPIClientBase() : + mTrackingCallback(nullptr), + mBatchingCallback(nullptr), + mGeofenceBreachCallback(nullptr), + mLocationAPI(nullptr), + mLocationControlAPI(nullptr), + mBatchSize(-1) +{ + + // use recursive mutex, in case callback come from the same thread + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mMutex, &attr); + + for (int i = 0; i < REQUEST_MAX; i++) { + mRequestQueues[i] = nullptr; + } + + memset(&mConfig, 0, sizeof(GnssConfig)); +} + +void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallbacks) +{ + if (locationCallbacks.geofenceBreachCb != nullptr) { + mGeofenceBreachCallback = locationCallbacks.geofenceBreachCb; + locationCallbacks.geofenceBreachCb = + [this](GeofenceBreachNotification geofenceBreachNotification) { + beforeGeofenceBreachCb(geofenceBreachNotification); + }; + } + + locationCallbacks.capabilitiesCb = + [this](LocationCapabilitiesMask capabilitiesMask) { + onCapabilitiesCb(capabilitiesMask); + }; + locationCallbacks.responseCb = [this](LocationError error, uint32_t id) { + onResponseCb(error, id); + }; + locationCallbacks.collectiveResponseCb = + [this](size_t count, LocationError* errors, uint32_t* ids) { + onCollectiveResponseCb(count, errors, ids); + }; + + if (mLocationAPI == nullptr ) { + mLocationAPI = LocationAPI::createInstance(locationCallbacks); + } else { + mLocationAPI->updateCallbacks(locationCallbacks); + } + + if (mLocationControlAPI == nullptr) { + LocationControlCallbacks locationControlCallbacks; + locationControlCallbacks.size = sizeof(LocationControlCallbacks); + + locationControlCallbacks.responseCb = + [this](LocationError error, uint32_t id) { + onCtrlResponseCb(error, id); + }; + locationControlCallbacks.collectiveResponseCb = + [this](size_t count, LocationError* errors, uint32_t* ids) { + onCtrlCollectiveResponseCb(count, errors, ids); + }; + + mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks); + } +} + +LocationAPIClientBase::~LocationAPIClientBase() +{ + if (mLocationAPI) { + mLocationAPI->destroy(); + mLocationAPI = nullptr; + } + if (mLocationControlAPI) { + mLocationControlAPI->destroy(); + mLocationControlAPI = nullptr; + } + + pthread_mutex_lock(&mMutex); + for (int i = 0; i < REQUEST_MAX; i++) { + if (mRequestQueues[i]) { + delete mRequestQueues[i]; + mRequestQueues[i] = nullptr; + } + } + pthread_mutex_unlock(&mMutex); + + pthread_mutex_destroy(&mMutex); +} + +uint32_t LocationAPIClientBase::locAPIStartTracking(LocationOptions& options) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + delete requests; + } + uint32_t session = mLocationAPI->startTracking(options); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session); + // onResponseCb might be called from other thread immediately after + // startTracking returns, so we are not going to unlock mutex + // until StartTrackingRequest is pushed into mRequestQueues[REQUEST_TRACKING] + requests = new RequestQueue(session); + requests->push(new StartTrackingRequest(*this)); + mRequestQueues[REQUEST_TRACKING] = requests; + pthread_mutex_unlock(&mMutex); + + retVal = LOCATION_ERROR_SUCCESS; + } + + return retVal; +} + +void LocationAPIClientBase::locAPIStopTracking() +{ + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + uint32_t session = -1; + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + session = requests->getSession(); + requests->push(new StopTrackingRequest(*this)); + mLocationAPI->stopTracking(session); + } + pthread_mutex_unlock(&mMutex); + } +} + +void LocationAPIClientBase::locAPIUpdateTrackingOptions(LocationOptions& options) +{ + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + uint32_t session = -1; + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + session = requests->getSession(); + requests->push(new UpdateTrackingOptionsRequest(*this)); + mLocationAPI->updateTrackingOptions(session, options); + } + pthread_mutex_unlock(&mMutex); + } +} + +int32_t LocationAPIClientBase::locAPIGetBatchSize() +{ + if (mBatchSize == -1) { + const loc_param_s_type flp_conf_param_table[] = + { + {"BATCH_SIZE", &mBatchSize, nullptr, 'n'}, + }; + UTIL_READ_CONF(FLP_CONF_FILE, flp_conf_param_table); + if (mBatchSize < 0) { + // set mBatchSize to 0 if we got an illegal value from config file + mBatchSize = 0; + } + } + return mBatchSize; +} + + +uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t sessionMode, + LocationOptions& options) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + + if (mSessionMap.find(id) != mSessionMap.end()) { + LOC_LOGE("%s:%d] session %d has already started.", __FUNCTION__, __LINE__, id); + retVal = LOCATION_ERROR_ALREADY_STARTED; + } else { + uint32_t trackingSession = 0; + uint32_t batchingSession = 0; + + if (sessionMode == SESSION_MODE_ON_FIX) { + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + delete requests; + } + trackingSession = mLocationAPI->startTracking(options); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession); + requests = new RequestQueue(trackingSession); + requests->push(new StartTrackingRequest(*this)); + mRequestQueues[REQUEST_TRACKING] = requests; + } else if (sessionMode == SESSION_MODE_ON_FULL) { + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + delete requests; + } + batchingSession = mLocationAPI->startBatching(options); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, batchingSession); + requests = new RequestQueue(batchingSession); + requests->push(new StartBatchingRequest(*this)); + mRequestQueues[REQUEST_BATCHING] = requests; + } + + SessionEntity entity; + entity.id = id; + entity.trackingSession = trackingSession; + entity.batchingSession = batchingSession; + entity.sessionMode = sessionMode; + mSessionMap[id] = entity; + + retVal = LOCATION_ERROR_SUCCESS; + } + + pthread_mutex_unlock(&mMutex); + } + + return retVal; +} + +uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + + if (mSessionMap.find(id) != mSessionMap.end()) { + SessionEntity entity = mSessionMap[id]; + + uint32_t trackingSession = entity.trackingSession; + uint32_t batchingSession = entity.batchingSession; + uint32_t sMode = entity.sessionMode; + + mSessionMap.erase(id); + + if (sMode == SESSION_MODE_ON_FIX) { + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + requests->push(new StopTrackingRequest(*this)); + mLocationAPI->stopTracking(trackingSession); + } + } else if (sMode == SESSION_MODE_ON_FULL) { + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + requests->push(new StopBatchingRequest(*this)); + mLocationAPI->stopBatching(batchingSession); + } + } + + retVal = LOCATION_ERROR_SUCCESS; + } else { + retVal = LOCATION_ERROR_ID_UNKNOWN; + LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id); + } + + pthread_mutex_unlock(&mMutex); + } + return retVal; +} + +uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode, + LocationOptions& options) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + + if (mSessionMap.find(id) != mSessionMap.end()) { + SessionEntity& entity = mSessionMap[id]; + + uint32_t trackingSession = entity.trackingSession; + uint32_t batchingSession = entity.batchingSession; + uint32_t sMode = entity.sessionMode; + + if (sessionMode == SESSION_MODE_ON_FIX) { + if (sMode == SESSION_MODE_ON_FIX) { + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + requests->push(new UpdateTrackingOptionsRequest(*this)); + mLocationAPI->updateTrackingOptions(trackingSession, options); + } + } else if (sMode == SESSION_MODE_ON_FULL) { + // stop batching + { + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + requests->push(new StopBatchingRequest(*this)); + mLocationAPI->stopBatching(batchingSession); + batchingSession = 0; + } + } + // start tracking + { + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + delete requests; + } + trackingSession = mLocationAPI->startTracking(options); + LOC_LOGI("%s:%d] start new session: %d", + __FUNCTION__, __LINE__, trackingSession); + requests = new RequestQueue(trackingSession); + requests->push(new StartTrackingRequest(*this)); + mRequestQueues[REQUEST_TRACKING] = requests; + } + } + } else if (sessionMode == SESSION_MODE_ON_FULL) { + if (sMode == SESSION_MODE_ON_FIX) { + // stop tracking + { + RequestQueue* requests = mRequestQueues[REQUEST_TRACKING]; + if (requests) { + requests->push(new StopTrackingRequest(*this)); + mLocationAPI->stopTracking(trackingSession); + trackingSession = 0; + } + } + // start batching + { + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + delete requests; + } + batchingSession = mLocationAPI->startBatching(options); + LOC_LOGI("%s:%d] start new session: %d", + __FUNCTION__, __LINE__, batchingSession); + requests = new RequestQueue(batchingSession); + requests->push(new StartBatchingRequest(*this)); + mRequestQueues[REQUEST_BATCHING] = requests; + } + } else if (sMode == SESSION_MODE_ON_FULL) { + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + requests->push(new UpdateBatchingOptionsRequest(*this)); + mLocationAPI->updateBatchingOptions(batchingSession, options); + } + } + } + + entity.trackingSession = trackingSession; + entity.batchingSession = batchingSession; + entity.sessionMode = sessionMode; + + retVal = LOCATION_ERROR_SUCCESS; + } else { + retVal = LOCATION_ERROR_ID_UNKNOWN; + LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id); + } + + pthread_mutex_unlock(&mMutex); + } + return retVal; +} + +void LocationAPIClientBase::locAPIGetBatchedLocations(size_t count) +{ + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + uint32_t session = -1; + RequestQueue* requests = mRequestQueues[REQUEST_BATCHING]; + if (requests) { + session = requests->getSession(); + requests->push(new GetBatchedLocationsRequest(*this)); + mLocationAPI->getBatchedLocations(session, count); + } + pthread_mutex_unlock(&mMutex); + } +} + +uint32_t LocationAPIClientBase::locAPIAddGeofences( + size_t count, uint32_t* ids, GeofenceOption* options, GeofenceInfo* data) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + delete requests; + } + uint32_t* sessions = mLocationAPI->addGeofences(count, options, data); + LOC_LOGI("%s:%d] start new sessions: %p", __FUNCTION__, __LINE__, sessions); + requests = new RequestQueue(-1); + requests->push(new AddGeofencesRequest(*this)); + mRequestQueues[REQUEST_GEOFENCE] = requests; + + for (size_t i = 0; i < count; i++) { + mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask); + } + pthread_mutex_unlock(&mMutex); + + retVal = LOCATION_ERROR_SUCCESS; + } + + return retVal; +} + +void LocationAPIClientBase::locAPIRemoveGeofences(size_t count, uint32_t* ids) +{ + if (mLocationAPI) { + uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count); + + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + for (size_t i = 0; i < count; i++) { + sessions[i] = mGeofenceBiDict.getSession(ids[i]); + } + requests->push(new RemoveGeofencesRequest(*this)); + mLocationAPI->removeGeofences(count, sessions); + } + pthread_mutex_unlock(&mMutex); + + free(sessions); + } +} + +void LocationAPIClientBase::locAPIModifyGeofences( + size_t count, uint32_t* ids, GeofenceOption* options) +{ + if (mLocationAPI) { + uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count); + + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + for (size_t i = 0; i < count; i++) { + sessions[i] = mGeofenceBiDict.getSession(ids[i]); + mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask); + } + requests->push(new ModifyGeofencesRequest(*this)); + mLocationAPI->modifyGeofences(count, sessions, options); + } + pthread_mutex_unlock(&mMutex); + + free(sessions); + } +} + +void LocationAPIClientBase::locAPIPauseGeofences(size_t count, uint32_t* ids) +{ + if (mLocationAPI) { + uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count); + + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + for (size_t i = 0; i < count; i++) { + sessions[i] = mGeofenceBiDict.getSession(ids[i]); + } + requests->push(new PauseGeofencesRequest(*this)); + mLocationAPI->pauseGeofences(count, sessions); + } + pthread_mutex_unlock(&mMutex); + + free(sessions); + } +} + +void LocationAPIClientBase::locAPIResumeGeofences( + size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask) +{ + if (mLocationAPI) { + uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count); + + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + for (size_t i = 0; i < count; i++) { + sessions[i] = mGeofenceBiDict.getSession(ids[i]); + if (mask) { + mGeofenceBiDict.set(ids[i], sessions[i], mask[i]); + } + } + requests->push(new ResumeGeofencesRequest(*this)); + mLocationAPI->resumeGeofences(count, sessions); + } + pthread_mutex_unlock(&mMutex); + + free(sessions); + } +} + +void LocationAPIClientBase::locAPIRemoveAllGeofences() +{ + if (mLocationAPI) { + std::vector sessionsVec = mGeofenceBiDict.getAllSessions(); + size_t count = sessionsVec.size(); + uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count); + + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE]; + if (requests) { + for (size_t i = 0; i < count; i++) { + sessions[i] = sessionsVec[i]; + } + requests->push(new RemoveGeofencesRequest(*this)); + mLocationAPI->removeGeofences(count, sessions); + } + pthread_mutex_unlock(&mMutex); + + free(sessions); + } +} + +void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse response) +{ + uint32_t session = 0; + if (mLocationAPI) { + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_NIRESPONSE]; + if (requests) { + delete requests; + } + uint32_t session = id; + mLocationAPI->gnssNiResponse(id, response); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session); + requests = new RequestQueue(session); + requests->push(new GnssNiResponseRequest(*this)); + mRequestQueues[REQUEST_NIRESPONSE] = requests; + pthread_mutex_unlock(&mMutex); + } +} + +uint32_t LocationAPIClientBase::locAPIGnssDeleteAidingData(GnssAidingData& data) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationControlAPI) { + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_DELETEAIDINGDATA]; + if (requests) { + delete requests; + } + uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session); + requests = new RequestQueue(session); + requests->push(new GnssDeleteAidingDataRequest(*this)); + mRequestQueues[REQUEST_DELETEAIDINGDATA] = requests; + pthread_mutex_unlock(&mMutex); + + retVal = LOCATION_ERROR_SUCCESS; + } + + return retVal; +} + +uint32_t LocationAPIClientBase::locAPIEnable(LocationTechnologyType techType) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (mLocationControlAPI) { + pthread_mutex_lock(&mMutex); + RequestQueue* requests = mRequestQueues[REQUEST_CONTROL]; + if (requests) { + delete requests; + } + uint32_t session = mLocationControlAPI->enable(techType); + LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session); + requests = new RequestQueue(session); + requests->push(new EnableRequest(*this)); + mRequestQueues[REQUEST_CONTROL] = requests; + pthread_mutex_unlock(&mMutex); + + retVal = LOCATION_ERROR_SUCCESS; + } + + return retVal; +} + +void LocationAPIClientBase::locAPIDisable() +{ + if (mLocationControlAPI) { + pthread_mutex_lock(&mMutex); + uint32_t session = -1; + RequestQueue* requests = mRequestQueues[REQUEST_CONTROL]; + if (requests) { + session = requests->getSession(); + requests->push(new DisableRequest(*this)); + mLocationControlAPI->disable(session); + } + pthread_mutex_unlock(&mMutex); + } +} + +uint32_t LocationAPIClientBase::locAPIGnssUpdateConfig(GnssConfig config) +{ + uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE; + if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) { + LOC_LOGE("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__); + return retVal; + } + + if (mLocationControlAPI) { + pthread_mutex_lock(&mMutex); + + memcpy(&mConfig, &config, sizeof(GnssConfig)); + + uint32_t session = -1; + RequestQueue* requests = mRequestQueues[REQUEST_CONTROL]; + if (requests) { + session = requests->getSession(); + requests->push(new GnssUpdateConfigRequest(*this)); + uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config); + LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray); + } + pthread_mutex_unlock(&mMutex); + + retVal = LOCATION_ERROR_SUCCESS; + } + return retVal; +} + +void LocationAPIClientBase::beforeGeofenceBreachCb( + GeofenceBreachNotification geofenceBreachNotification) +{ + if (mGeofenceBreachCallback == nullptr) + return; + uint32_t* ids = (uint32_t*)malloc(sizeof(uint32_t) * geofenceBreachNotification.count); + uint32_t* backup = geofenceBreachNotification.ids; + size_t n = geofenceBreachNotification.count; + + size_t count = 0; + for (size_t i = 0; i < n; i++) { + uint32_t id = mGeofenceBiDict.getId(geofenceBreachNotification.ids[i]); + GeofenceBreachTypeMask type = mGeofenceBiDict.getType(geofenceBreachNotification.ids[i]); + if ((geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER && + (type & GEOFENCE_BREACH_ENTER_BIT)) || + (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT && + (type & GEOFENCE_BREACH_EXIT_BIT)) + ) { + ids[count] = id; + count++; + } + } + geofenceBreachNotification.count = count; + geofenceBreachNotification.ids = ids; + mGeofenceBreachCallback(geofenceBreachNotification); + + // restore ids + geofenceBreachNotification.ids = backup; + geofenceBreachNotification.count = n; + free(ids); +} + +void LocationAPIClientBase::onResponseCb(LocationError error, uint32_t id) +{ + if (error != LOCATION_ERROR_SUCCESS) { + LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id); + } else { + LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id); + } + LocationAPIRequest* request = getRequestBySession(id); + if (request) { + request->onResponse(error); + delete request; + } +} + +void LocationAPIClientBase::onCollectiveResponseCb( + size_t count, LocationError* errors, uint32_t* ids) +{ + for (size_t i = 0; i < count; i++) { + if (errors[i] != LOCATION_ERROR_SUCCESS) { + LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]); + } else { + LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]); + } + } + LocationAPIRequest* request = nullptr; + if (count > 0 && ids) + request = getRequestBySession(ids[0]); + if (!request) + request = getGeofencesRequest(); + if (request) { + request->onCollectiveResponse(count, errors, ids); + delete request; + } +} + +void LocationAPIClientBase::onCtrlResponseCb(LocationError error, uint32_t id) +{ + if (error != LOCATION_ERROR_SUCCESS) { + LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id); + } else { + LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id); + } + LocationAPIRequest* request = getRequestBySession(id); + if (request) { + request->onResponse(error); + delete request; + } +} + +void LocationAPIClientBase::onCtrlCollectiveResponseCb( + size_t count, LocationError* errors, uint32_t* ids) +{ + for (size_t i = 0; i < count; i++) { + if (errors[i] != LOCATION_ERROR_SUCCESS) { + LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]); + } else { + LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]); + } + } + LocationAPIRequest* request = nullptr; + if (count > 0 && ids) + request = getRequestBySession(ids[0]); + if (request) { + request->onCollectiveResponse(count, errors, ids); + delete request; + } +} + +LocationAPIClientBase::LocationAPIRequest* +LocationAPIClientBase::getRequestBySession(uint32_t session) +{ + pthread_mutex_lock(&mMutex); + LocationAPIRequest* request = nullptr; + for (int i = 0; i < REQUEST_MAX; i++) { + if (i != REQUEST_GEOFENCE && + mRequestQueues[i] && + mRequestQueues[i]->getSession() == session) { + request = mRequestQueues[i]->pop(); + break; + } + } + pthread_mutex_unlock(&mMutex); + return request; +} + +LocationAPIClientBase::LocationAPIRequest* +LocationAPIClientBase::getGeofencesRequest() +{ + pthread_mutex_lock(&mMutex); + LocationAPIRequest* request = nullptr; + if (mRequestQueues[REQUEST_GEOFENCE]) { + request = mRequestQueues[REQUEST_GEOFENCE]->pop(); + } + pthread_mutex_unlock(&mMutex); + return request; +} diff --git a/location/LocationAPIClientBase.h b/location/LocationAPIClientBase.h new file mode 100644 index 00000000..8bbaa3dc --- /dev/null +++ b/location/LocationAPIClientBase.h @@ -0,0 +1,457 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LOCATION_API_CLINET_BASE_H +#define LOCATION_API_CLINET_BASE_H + +#include +#include +#include +#include +#include + +#include "LocationAPI.h" + +enum SESSION_MODE { + SESSION_MODE_NONE = 0, + SESSION_MODE_ON_FULL, + SESSION_MODE_ON_FIX, +}; + +enum REQUEST_TYPE { + REQUEST_TRACKING = 0, + REQUEST_BATCHING, + REQUEST_GEOFENCE, + REQUEST_NIRESPONSE, + REQUEST_DELETEAIDINGDATA, + REQUEST_CONTROL, + REQUEST_MAX, +}; + +class LocationAPIClientBase +{ +public: + LocationAPIClientBase(); + virtual ~LocationAPIClientBase(); + LocationAPIClientBase(const LocationAPIClientBase&) = delete; + LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete; + + void locAPISetCallbacks(LocationCallbacks& locationCallbacks); + + // LocationAPI + uint32_t locAPIStartTracking(LocationOptions& options); + void locAPIStopTracking(); + void locAPIUpdateTrackingOptions(LocationOptions& options); + + int32_t locAPIGetBatchSize(); + uint32_t locAPIStartSession(uint32_t id, uint32_t sessionMode, + LocationOptions& options); + uint32_t locAPIStopSession(uint32_t id); + uint32_t locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode, + LocationOptions& options); + void locAPIGetBatchedLocations(size_t count); + + uint32_t locAPIAddGeofences(size_t count, uint32_t* ids, + GeofenceOption* options, GeofenceInfo* data); + void locAPIRemoveGeofences(size_t count, uint32_t* ids); + void locAPIModifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options); + void locAPIPauseGeofences(size_t count, uint32_t* ids); + void locAPIResumeGeofences(size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask); + void locAPIRemoveAllGeofences(); + + void locAPIGnssNiResponse(uint32_t id, GnssNiResponse response); + uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data); + + uint32_t locAPIEnable(LocationTechnologyType techType); + void locAPIDisable(); + uint32_t locAPIGnssUpdateConfig(GnssConfig config); + + // callbacks + void onResponseCb(LocationError error, uint32_t id); + void onCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids); + + void onCtrlResponseCb(LocationError error, uint32_t id); + void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids); + + void beforeGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification); + + inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {} + inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {} + inline virtual void onGnssMeasurementsCb( + GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {} + + inline virtual void onTrackingCb(Location /*location*/) {} + inline virtual void onGnssSvCb(GnssSvNotification /*gnssSvNotification*/) {} + inline virtual void onStartTrackingCb(LocationError /*error*/) {} + inline virtual void onStopTrackingCb(LocationError /*error*/) {} + inline virtual void onUpdateTrackingOptionsCb(LocationError /*error*/) {} + + inline virtual void onGnssLocationInfoCb( + GnssLocationInfoNotification /*gnssLocationInfoNotification*/) {} + + inline virtual void onBatchingCb(size_t /*count*/, Location* /*location*/) {} + inline virtual void onStartBatchingCb(LocationError /*error*/) {} + inline virtual void onStopBatchingCb(LocationError /*error*/) {} + inline virtual void onUpdateBatchingOptionsCb(LocationError /*error*/) {} + inline virtual void onGetBatchedLocationsCb(LocationError /*error*/) {} + + inline virtual void onGeofenceBreachCb( + GeofenceBreachNotification /*geofenceBreachNotification*/) {} + inline virtual void onGeofenceStatusCb( + GeofenceStatusNotification /*geofenceStatusNotification*/) {} + inline virtual void onAddGeofencesCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + inline virtual void onRemoveGeofencesCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + inline virtual void onModifyGeofencesCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + inline virtual void onPauseGeofencesCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + inline virtual void onResumeGeofencesCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + + inline virtual void onGnssNiCb(uint32_t /*id*/, GnssNiNotification /*gnssNiNotification*/) {} + inline virtual void onGnssNiResponseCb(LocationError /*error*/) {} + inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {} + + inline virtual void onEnableCb(LocationError /*error*/) {} + inline virtual void onDisableCb(LocationError /*error*/) {} + inline virtual void onGnssUpdateConfigCb( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {} + +private: + // private inner classes + typedef struct { + uint32_t id; + uint32_t trackingSession; + uint32_t batchingSession; + uint32_t sessionMode; + } SessionEntity; + + class BiDict { + public: + BiDict() { + pthread_mutex_init(&mBiDictMutex, nullptr); + } + ~BiDict() { + pthread_mutex_destroy(&mBiDictMutex); + } + bool hasId(uint32_t id) { + pthread_mutex_lock(&mBiDictMutex); + bool ret = (mForwardMap.find(id) != mForwardMap.end()); + pthread_mutex_unlock(&mBiDictMutex); + return ret; + } + void set(uint32_t id, uint32_t session, uint32_t type) { + pthread_mutex_lock(&mBiDictMutex); + mForwardMap[id] = session; + mBackwardMap[session] = id; + mTypeMap[session] = type; + pthread_mutex_unlock(&mBiDictMutex); + } + void clear() { + pthread_mutex_lock(&mBiDictMutex); + mForwardMap.clear(); + mBackwardMap.clear(); + mTypeMap.clear(); + pthread_mutex_unlock(&mBiDictMutex); + } + void rmById(uint32_t id) { + pthread_mutex_lock(&mBiDictMutex); + mBackwardMap.erase(mForwardMap[id]); + mTypeMap.erase(mForwardMap[id]); + mForwardMap.erase(id); + pthread_mutex_unlock(&mBiDictMutex); + } + void rmBySession(uint32_t session) { + pthread_mutex_lock(&mBiDictMutex); + mForwardMap.erase(mBackwardMap[session]); + mBackwardMap.erase(session); + mTypeMap.erase(session); + pthread_mutex_unlock(&mBiDictMutex); + } + uint32_t getId(uint32_t session) { + pthread_mutex_lock(&mBiDictMutex); + uint32_t ret = mBackwardMap[session]; + pthread_mutex_unlock(&mBiDictMutex); + return ret; + } + uint32_t getSession(uint32_t id) { + pthread_mutex_lock(&mBiDictMutex); + uint32_t ret = mForwardMap[id]; + pthread_mutex_unlock(&mBiDictMutex); + return ret; + } + uint32_t getType(uint32_t session) { + pthread_mutex_lock(&mBiDictMutex); + uint32_t ret = mTypeMap[session]; + pthread_mutex_unlock(&mBiDictMutex); + return ret; + } + std::vector getAllSessions() { + std::vector ret; + pthread_mutex_lock(&mBiDictMutex); + for (auto it = mBackwardMap.begin(); it != mBackwardMap.end(); it++) { + ret.push_back(it->first); + } + pthread_mutex_unlock(&mBiDictMutex); + return ret; + } + private: + pthread_mutex_t mBiDictMutex; + // mForwarMap mapping id->session + std::map mForwardMap; + // mBackwardMap mapping session->id + std::map mBackwardMap; + // mTypeMap mapping session->type + std::map mTypeMap; + }; + + class LocationAPIRequest { + public: + LocationAPIRequest(LocationAPIClientBase& API) : mAPI(API) {} + virtual ~LocationAPIRequest() {} + virtual void onResponse(LocationError /*error*/) {}; + virtual void onCollectiveResponse( + size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}; + LocationAPIClientBase& mAPI; + }; + + class StartTrackingRequest : public LocationAPIRequest { + public: + StartTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onStartTrackingCb(error); + } + }; + + class StopTrackingRequest : public LocationAPIRequest { + public: + StopTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onStopTrackingCb(error); + } + }; + + class UpdateTrackingOptionsRequest : public LocationAPIRequest { + public: + UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onUpdateTrackingOptionsCb(error); + } + }; + + class StartBatchingRequest : public LocationAPIRequest { + public: + StartBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onStartBatchingCb(error); + } + }; + + class StopBatchingRequest : public LocationAPIRequest { + public: + StopBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onStopBatchingCb(error); + } + }; + + class UpdateBatchingOptionsRequest : public LocationAPIRequest { + public: + UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onUpdateBatchingOptionsCb(error); + } + }; + + class GetBatchedLocationsRequest : public LocationAPIRequest { + public: + GetBatchedLocationsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onGetBatchedLocationsCb(error); + } + }; + + class AddGeofencesRequest : public LocationAPIRequest { + public: + AddGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) { + uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count); + for (size_t i = 0; i < count; i++) { + ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]); + } + mAPI.onAddGeofencesCb(count, errors, ids); + free(ids); + } + }; + + class RemoveGeofencesRequest : public LocationAPIRequest { + public: + RemoveGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) { + uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count); + for (size_t i = 0; i < count; i++) { + ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]); + mAPI.mGeofenceBiDict.rmBySession(sessions[i]); + } + mAPI.onRemoveGeofencesCb(count, errors, ids); + free(ids); + } + }; + + class ModifyGeofencesRequest : public LocationAPIRequest { + public: + ModifyGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) { + uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count); + for (size_t i = 0; i < count; i++) { + ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]); + } + mAPI.onModifyGeofencesCb(count, errors, ids); + free(ids); + } + }; + + class PauseGeofencesRequest : public LocationAPIRequest { + public: + PauseGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) { + uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count); + for (size_t i = 0; i < count; i++) { + ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]); + } + mAPI.onPauseGeofencesCb(count, errors, ids); + free(ids); + } + }; + + class ResumeGeofencesRequest : public LocationAPIRequest { + public: + ResumeGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) { + uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count); + for (size_t i = 0; i < count; i++) { + ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]); + } + mAPI.onResumeGeofencesCb(count, errors, ids); + free(ids); + } + }; + + class GnssNiResponseRequest : public LocationAPIRequest { + public: + GnssNiResponseRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onGnssNiResponseCb(error); + } + }; + + class GnssDeleteAidingDataRequest : public LocationAPIRequest { + public: + GnssDeleteAidingDataRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onGnssDeleteAidingDataCb(error); + } + }; + + class EnableRequest : public LocationAPIRequest { + public: + EnableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onEnableCb(error); + } + }; + + class DisableRequest : public LocationAPIRequest { + public: + DisableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onResponse(LocationError error) { + mAPI.onDisableCb(error); + } + }; + + class GnssUpdateConfigRequest : public LocationAPIRequest { + public: + GnssUpdateConfigRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {} + inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) { + mAPI.onGnssUpdateConfigCb(count, errors, ids); + } + }; + + class RequestQueue { + public: + RequestQueue(uint32_t session): mSession(session) { + } + ~RequestQueue() { + LocationAPIRequest* request = nullptr; + while (!mQueue.empty()) { + request = mQueue.front(); + mQueue.pop(); + delete request; + } + } + void push(LocationAPIRequest* request) { + mQueue.push(request); + } + LocationAPIRequest* pop() { + LocationAPIRequest* request = nullptr; + if (!mQueue.empty()) { + request = mQueue.front(); + mQueue.pop(); + } + return request; + } + uint32_t getSession() { return mSession; } + private: + uint32_t mSession; + std::queue mQueue; + }; + + LocationAPIRequest* getRequestBySession(uint32_t session); + LocationAPIRequest* getGeofencesRequest(); + +private: + pthread_mutex_t mMutex; + + trackingCallback mTrackingCallback; + batchingCallback mBatchingCallback; + geofenceBreachCallback mGeofenceBreachCallback; + + LocationAPI* mLocationAPI; + LocationControlAPI* mLocationControlAPI; + + BiDict mGeofenceBiDict; + RequestQueue* mRequestQueues[REQUEST_MAX]; + std::map mSessionMap; + int32_t mBatchSize; + + GnssConfig mConfig; +}; + +#endif /* LOCATION_API_CLINET_BASE_H */ diff --git a/location/location_interface.h b/location/location_interface.h new file mode 100644 index 00000000..b726931d --- /dev/null +++ b/location/location_interface.h @@ -0,0 +1,86 @@ +/* Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LOCATION_INTERFACE_H +#define LOCATION_INTERFACE_H + +#include + +struct GnssInterface { + size_t size; + void (*initialize)(void); + void (*deinitialize)(void); + void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks); + void (*removeClient)(LocationAPI* client); + void (*requestCapabilities)(LocationAPI* client); + uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options); + void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options); + void (*stopTracking)(LocationAPI* client, uint32_t id); + void (*gnssNiResponse)(LocationAPI* client, uint32_t id, GnssNiResponse response); + void (*setControlCallbacks)(LocationControlCallbacks& controlCallbacks); + uint32_t (*enable)(LocationTechnologyType techType); + void (*disable)(uint32_t id); + uint32_t* (*gnssUpdateConfig)(GnssConfig config); + uint32_t (*gnssDeleteAidingData)(GnssAidingData& data); + void (*injectLocation)(double latitude, double longitude, float accuracy); + void (*injectTime)(int64_t time, int64_t timeReference, int32_t uncertainty); +}; + +struct FlpInterface { + size_t size; + void (*initialize)(void); + void (*deinitialize)(void); + void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks); + void (*removeClient)(LocationAPI* client); + void (*requestCapabilities)(LocationAPI* client); + uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options); + void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options); + void (*stopTracking)(LocationAPI* client, uint32_t id); + uint32_t (*startBatching)(LocationAPI* client, LocationOptions&); + void (*stopBatching)(LocationAPI* client, uint32_t id); + void (*updateBatchingOptions)(LocationAPI* client, uint32_t id, LocationOptions&); + void (*getBatchedLocations)(LocationAPI* client, uint32_t id, size_t count); + void (*getPowerStateChanges)(void* powerStateCb); +}; + +struct GeofenceInterface { + size_t size; + void (*initialize)(void); + void (*deinitialize)(void); + void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks); + void (*removeClient)(LocationAPI* client); + void (*requestCapabilities)(LocationAPI* client); + uint32_t* (*addGeofences)(LocationAPI* client, size_t count, GeofenceOption*, GeofenceInfo*); + void (*removeGeofences)(LocationAPI* client, size_t count, uint32_t* ids); + void (*modifyGeofences)(LocationAPI* client, size_t count, uint32_t* ids, + GeofenceOption* options); + void (*pauseGeofences)(LocationAPI* client, size_t count, uint32_t* ids); + void (*resumeGeofences)(LocationAPI* client, size_t count, uint32_t* ids); +}; + +#endif /* LOCATION_INTERFACE_H */ diff --git a/utils/MsgTask.cpp b/utils/MsgTask.cpp index 78a3fe00..21635115 100644 --- a/utils/MsgTask.cpp +++ b/utils/MsgTask.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013,2015 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2013, 2015, 2017The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -82,7 +82,6 @@ void MsgTask::prerun() { } bool MsgTask::run() { - LOC_LOGV("MsgTask::loop() listening ...\n"); LocMsg* msg; msq_q_err_type result = msg_q_rcv((void*)mQ, (void **)&msg); if (eMSG_Q_SUCCESS != result) { diff --git a/utils/linked_list.c b/utils/linked_list.c index acec5b1f..33185d0b 100644 --- a/utils/linked_list.c +++ b/utils/linked_list.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011, 2014, 2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -108,7 +108,6 @@ linked_list_err_type linked_list_destroy(void** list_data) ===========================================================================*/ linked_list_err_type linked_list_add(void* list_data, void *data_obj, void (*dealloc)(void*)) { - LOC_LOGV("%s: Adding to list data_obj = 0x%08X\n", __FUNCTION__, data_obj); if( list_data == NULL ) { LOC_LOGE("%s: Invalid list parameter!\n", __FUNCTION__); @@ -160,7 +159,6 @@ linked_list_err_type linked_list_add(void* list_data, void *data_obj, void (*dea ===========================================================================*/ linked_list_err_type linked_list_remove(void* list_data, void **data_obj) { - LOC_LOGV("%s: Removing from list\n", __FUNCTION__); if( list_data == NULL ) { LOC_LOGE("%s: Invalid list parameter!\n", __FUNCTION__); @@ -267,7 +265,6 @@ linked_list_err_type linked_list_search(void* list_data, void **data_p, bool (*equal)(void* data_0, void* data), void* data_0, bool rm_if_found) { - LOC_LOGV("%s: Search the list\n", __FUNCTION__); if( list_data == NULL || NULL == equal ) { LOC_LOGE("%s: Invalid list parameter! list_data %p equal %p\n", diff --git a/utils/msg_q.c b/utils/msg_q.c index e412e781..10c4e485 100644 --- a/utils/msg_q.c +++ b/utils/msg_q.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2012, 2014, 2017 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -241,8 +241,6 @@ msq_q_err_type msg_q_rcv(void* msg_q_data, void** msg_obj) msg_q* p_msg_q = (msg_q*)msg_q_data; - LOC_LOGV("%s: Waiting on message\n", __FUNCTION__); - pthread_mutex_lock(&p_msg_q->list_mutex); if( p_msg_q->unblocked )