From 4996c5e9551705645bb9e41b40973e096e78c8f6 Mon Sep 17 00:00:00 2001 From: Tushar Janefalkar Date: Wed, 11 Dec 2013 15:38:42 -0800 Subject: [PATCH] Remove unused code under libloc_api This folder of sources is no longer used and is removed Change-Id: I0b02f56e27346f20f890bc8105e77995e63c0350 CRs-fixed: 566508 --- loc_api/libloc_api/Android.mk | 40 - loc_api/libloc_api/gps.c | 68 -- loc_api/libloc_api/loc_eng.cpp | 1533 -------------------------- loc_api/libloc_api/loc_eng.h | 115 -- loc_api/libloc_api/loc_eng_ioctl.cpp | 354 ------ loc_api/libloc_api/loc_eng_ioctl.h | 69 -- loc_api/libloc_api/loc_eng_ni.cpp | 609 ---------- loc_api/libloc_api/loc_eng_ni.h | 56 - loc_api/libloc_api/loc_eng_xtra.cpp | 180 --- loc_api/libloc_api/loc_eng_xtra.h | 45 - 10 files changed, 3069 deletions(-) delete mode 100644 loc_api/libloc_api/Android.mk delete mode 100644 loc_api/libloc_api/gps.c delete mode 100644 loc_api/libloc_api/loc_eng.cpp delete mode 100644 loc_api/libloc_api/loc_eng.h delete mode 100644 loc_api/libloc_api/loc_eng_ioctl.cpp delete mode 100644 loc_api/libloc_api/loc_eng_ioctl.h delete mode 100644 loc_api/libloc_api/loc_eng_ni.cpp delete mode 100644 loc_api/libloc_api/loc_eng_ni.h delete mode 100644 loc_api/libloc_api/loc_eng_xtra.cpp delete mode 100644 loc_api/libloc_api/loc_eng_xtra.h diff --git a/loc_api/libloc_api/Android.mk b/loc_api/libloc_api/Android.mk deleted file mode 100644 index 2922a4ab..00000000 --- a/loc_api/libloc_api/Android.mk +++ /dev/null @@ -1,40 +0,0 @@ -#Compile the old library version from Google push for Passion builds with old modem image -ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001) -LOCAL_PATH := $(call my-dir) -include $(CLEAR_VARS) - -LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE) -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -LOCAL_STATIC_LIBRARIES:= \ - libloc_api-rpc - -LOCAL_SHARED_LIBRARIES := \ - librpc \ - libutils \ - libcutils - -LOCAL_SRC_FILES += \ - loc_eng.cpp \ - loc_eng_ioctl.cpp \ - loc_eng_xtra.cpp \ - loc_eng_ni.cpp \ - gps.c - -LOCAL_CFLAGS += \ - -fno-short-enums \ - -DAMSS_VERSION=$(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION) - -LOCAL_C_INCLUDES:= \ - $(TARGET_OUT_HEADERS)/libloc_api-rpc \ - $(TARGET_OUT_HEADERS)/libloc_api-rpc/inc \ - $(TARGET_OUT_HEADERS)/libcommondefs-rpc/inc \ - $(TARGET_OUT_HEADERS)/librpc - - -LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw - -include $(BUILD_SHARED_LIBRARY) -endif #BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION = 50001 diff --git a/loc_api/libloc_api/gps.c b/loc_api/libloc_api/gps.c deleted file mode 100644 index 36bfcb63..00000000 --- a/loc_api/libloc_api/gps.c +++ /dev/null @@ -1,68 +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. - * - */ - -#include - -#include - -extern const GpsInterface* get_gps_interface(); - -const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev) -{ - return get_gps_interface(); -} - -static int open_gps(const struct hw_module_t* module, char const* name, - struct hw_device_t** device) -{ - struct gps_device_t *dev = malloc(sizeof(struct gps_device_t)); - memset(dev, 0, sizeof(*dev)); - - dev->common.tag = HARDWARE_DEVICE_TAG; - dev->common.version = 0; - dev->common.module = (struct hw_module_t*)module; - dev->get_gps_interface = gps__get_gps_interface; - - *device = (struct hw_device_t*)dev; - return 0; -} - -static struct hw_module_methods_t gps_module_methods = { - .open = open_gps -}; - -const struct hw_module_t HAL_MODULE_INFO_SYM = { - .tag = HARDWARE_MODULE_TAG, - .version_major = 1, - .version_minor = 0, - .id = GPS_HARDWARE_MODULE_ID, - .name = "loc_api GPS Module", - .author = "Qualcomm USA, Inc.", - .methods = &gps_module_methods, -}; diff --git a/loc_api/libloc_api/loc_eng.cpp b/loc_api/libloc_api/loc_eng.cpp deleted file mode 100644 index 3b286303..00000000 --- a/loc_api/libloc_api/loc_eng.cpp +++ /dev/null @@ -1,1533 +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. - * - */ - -#define LOG_NDDEBUG 0 - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include "loc_api_rpc_glue.h" -#include "loc_apicb_appinit.h" - -#include -#include -#include - -#include -#include - -#define LOG_TAG "lib_locapi" -#include - -// comment this out to enable logging -// #undef LOGD -// #define LOGD(...) {} - -#define DEBUG_MOCK_NI 0 - -// Function declarations for sLocEngInterface -static int loc_eng_init(GpsCallbacks* callbacks); -static int loc_eng_start(); -static int loc_eng_stop(); -static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence, - uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time); -static void loc_eng_cleanup(); -static int loc_eng_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty); -static int loc_eng_inject_location(double latitude, double longitude, float accuracy); -static void loc_eng_delete_aiding_data (GpsAidingData f); -static const void* loc_eng_get_extension(const char* name); - -// Function declarations for sLocEngAGpsInterface -static void loc_eng_agps_init(AGpsCallbacks* callbacks); -static int loc_eng_agps_data_conn_open(const char* apn); -static int loc_eng_agps_data_conn_closed(); -static int loc_eng_agps_data_conn_failed(); -static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port); - - -static int32 loc_event_cb (rpc_loc_client_handle_type client_handle, - rpc_loc_event_mask_type loc_event, - const rpc_loc_event_payload_u_type* loc_event_payload); -static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr); -static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr); -static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_report_ptr); -static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr); -static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr); - -static void loc_eng_process_deferred_action (void* arg); -static void loc_eng_process_atl_deferred_action (int flags); -static void loc_eng_delete_aiding_data_deferred_action (void); - -static int set_agps_server(); - -// Defines the GpsInterface in gps.h -static const GpsInterface sLocEngInterface = -{ - sizeof(GpsInterface), - loc_eng_init, - loc_eng_start, - loc_eng_stop, - loc_eng_cleanup, - loc_eng_inject_time, - loc_eng_inject_location, - loc_eng_delete_aiding_data, - loc_eng_set_position_mode, - loc_eng_get_extension, -}; - -static const AGpsInterface sLocEngAGpsInterface = -{ - sizeof(AGpsInterface), - loc_eng_agps_init, - loc_eng_agps_data_conn_open, - loc_eng_agps_data_conn_closed, - loc_eng_agps_data_conn_failed, - loc_eng_agps_set_server, -}; - -// Global data structure for location engine -loc_eng_data_s_type loc_eng_data; - -/*=========================================================================== -FUNCTION gps_get_hardware_interface - -DESCRIPTION - Returns the GPS hardware interaface based on LOC API - if GPS is enabled. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -const GpsInterface* gps_get_hardware_interface () -{ - char propBuf[PROPERTY_VALUE_MAX]; - - // check to see if GPS should be disabled - property_get("gps.disable", propBuf, ""); - if (propBuf[0] == '1') - { - LOGD("gps_get_interface returning NULL because gps.disable=1\n"); - return NULL; - } - - return &sLocEngInterface; -} - -/*=========================================================================== -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 - -===========================================================================*/ - -// fully shutting down the GPS is temporarily disabled to avoid intermittent BP crash -#define DISABLE_CLEANUP 1 - -static int loc_eng_init(GpsCallbacks* callbacks) -{ -#if DISABLE_CLEANUP - if (loc_eng_data.deferred_action_thread) { - // already initialized - return 0; - } -#endif - // Start the LOC api RPC service - loc_api_glue_init (); - - callbacks->set_capabilities_cb(GPS_CAPABILITY_SCHEDULING | GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB); - - memset (&loc_eng_data, 0, sizeof (loc_eng_data_s_type)); - - // LOC ENG module data initialization - 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.acquire_wakelock_cb = callbacks->acquire_wakelock_cb; - loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb; - - rpc_loc_event_mask_type event = RPC_LOC_EVENT_PARSED_POSITION_REPORT | - RPC_LOC_EVENT_SATELLITE_REPORT | - RPC_LOC_EVENT_LOCATION_SERVER_REQUEST | - RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST | - RPC_LOC_EVENT_IOCTL_REPORT | - RPC_LOC_EVENT_STATUS_REPORT | - RPC_LOC_EVENT_NMEA_POSITION_REPORT | - RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST; - - loc_eng_data.client_handle = loc_open (event, loc_event_cb); - - pthread_mutex_init (&(loc_eng_data.deferred_action_mutex), NULL); - pthread_cond_init (&(loc_eng_data.deferred_action_cond) , NULL); - pthread_mutex_init (&(loc_eng_data.deferred_stop_mutex), NULL); - - loc_eng_data.loc_event = 0; - loc_eng_data.deferred_action_flags = 0; - memset (loc_eng_data.apn_name, 0, sizeof (loc_eng_data.apn_name)); - - loc_eng_data.aiding_data_for_deletion = 0; - loc_eng_data.engine_status = GPS_STATUS_NONE; - - // XTRA module data initialization - loc_eng_data.xtra_module_data.download_request_cb = NULL; - - // IOCTL module data initialization - loc_eng_data.ioctl_data.cb_is_selected = FALSE; - loc_eng_data.ioctl_data.cb_is_waiting = FALSE; - loc_eng_data.ioctl_data.client_handle = RPC_LOC_CLIENT_HANDLE_INVALID; - memset (&(loc_eng_data.ioctl_data.cb_payload), - 0, - sizeof (rpc_loc_ioctl_callback_s_type)); - - pthread_mutex_init (&(loc_eng_data.ioctl_data.cb_data_mutex), NULL); - pthread_cond_init(&loc_eng_data.ioctl_data.cb_arrived_cond, NULL); - - loc_eng_data.deferred_action_thread = callbacks->create_thread_cb("loc_api", - loc_eng_process_deferred_action, NULL); - - LOGD ("loc_eng_init called, client id = %d\n", (int32) loc_eng_data.client_handle); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_cleanup - -DESCRIPTION - Cleans location engine. The location client handle will be released. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_cleanup() -{ -#if DISABLE_CLEANUP - return; -#else - if (loc_eng_data.deferred_action_thread) - { - /* Terminate deferred action working thread */ - pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_QUIT; - pthread_cond_signal(&loc_eng_data.deferred_action_cond); - pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); - - void* ignoredValue; - pthread_join(loc_eng_data.deferred_action_thread, &ignoredValue); - loc_eng_data.deferred_action_thread = NULL; - } - - // clean up - (void) loc_close (loc_eng_data.client_handle); - - pthread_mutex_destroy (&loc_eng_data.deferred_action_mutex); - pthread_cond_destroy (&loc_eng_data.deferred_action_cond); - - pthread_mutex_destroy (&loc_eng_data.ioctl_data.cb_data_mutex); - pthread_cond_destroy (&loc_eng_data.ioctl_data.cb_arrived_cond); - -// Do not call this as it can result in the ARM9 crashing if it sends events while we are disabled -// loc_apicb_app_deinit(); -#endif -} - - -/*=========================================================================== -FUNCTION loc_eng_start - -DESCRIPTION - Starts the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_eng_start() -{ - int ret_val; - LOGD ("loc_eng_start\n"); - - if (loc_eng_data.position_mode != GPS_POSITION_MODE_STANDALONE && - loc_eng_data.agps_server_host[0] != 0 && - loc_eng_data.agps_server_port != 0) { - int result = set_agps_server(); - LOGD ("set_agps_server returned = %d\n", result); - } - - ret_val = loc_start_fix (loc_eng_data.client_handle); - - if (ret_val != RPC_LOC_API_SUCCESS) - { - LOGD ("loc_eng_start returned error = %d\n", ret_val); - } - - return 0; -} - - -/*=========================================================================== -FUNCTION loc_eng_stop - -DESCRIPTION - Stops the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_eng_stop() -{ - int ret_val; - - LOGD ("loc_eng_stop\n"); - - pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex)); - // work around problem with loc_eng_stop when AGPS requests are pending - // we defer stopping the engine until the AGPS request is done - if (loc_eng_data.agps_request_pending) - { - loc_eng_data.stop_request_pending = true; - LOGD ("deferring stop until AGPS data call is finished\n"); - pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex)); - return 0; - } - pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex)); - - ret_val = loc_stop_fix (loc_eng_data.client_handle); - if (ret_val != RPC_LOC_API_SUCCESS) - { - LOGD ("loc_eng_stop returned error = %d\n", ret_val); - } - - return 0; -} - -static int loc_eng_set_gps_lock(rpc_loc_lock_e_type lock_type) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - boolean ret_val; - - LOGD ("loc_eng_set_gps_lock mode, client = %d, lock_type = %d\n", - (int32) loc_eng_data.client_handle, lock_type); - - ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = lock_type; - 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*/); - - if (ret_val != TRUE) - { - LOGD ("loc_eng_set_gps_lock mode failed\n"); - } - - return 0; -} - -/*=========================================================================== -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 - -===========================================================================*/ -static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence, - uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_fix_criteria_s_type *fix_criteria_ptr; - boolean ret_val; - - LOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n", - (int32) loc_eng_data.client_handle, min_interval, mode); - - loc_eng_data.position_mode = mode; - ioctl_data.disc = RPC_LOC_IOCTL_SET_FIX_CRITERIA; - - fix_criteria_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria); - fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE | - RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE; - - switch (mode) { - case GPS_POSITION_MODE_MS_BASED: - fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSB; - break; - case GPS_POSITION_MODE_MS_ASSISTED: - fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSA; - break; - case GPS_POSITION_MODE_STANDALONE: - default: - fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_STANDALONE; - break; - } - if (min_interval > 0) { - fix_criteria_ptr->min_interval = min_interval; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL; - } - if (preferred_accuracy > 0) { - fix_criteria_ptr->preferred_accuracy = preferred_accuracy; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY; - } - if (preferred_time > 0) { - fix_criteria_ptr->preferred_response_time = preferred_time; - fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME; - } - - switch (recurrence) { - case GPS_POSITION_RECURRENCE_SINGLE: - fix_criteria_ptr->recurrence_type = RPC_LOC_SINGLE_FIX; - break; - case GPS_POSITION_RECURRENCE_PERIODIC: - default: - fix_criteria_ptr->recurrence_type = RPC_LOC_PERIODIC_FIX; - break; - } - - ret_val = loc_eng_ioctl(loc_eng_data.client_handle, - RPC_LOC_IOCTL_SET_FIX_CRITERIA, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - if (ret_val != TRUE) - { - LOGD ("loc_eng_set_position mode failed\n"); - } - - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_inject_time - -DESCRIPTION - This is used by Java native function to do time injection. - -DEPENDENCIES - None - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_eng_inject_time (GpsUtcTime time, int64_t timeReference, int uncertainty) -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_assist_data_time_s_type *time_info_ptr; - boolean ret_val; - - LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty); - - ioctl_data.disc = RPC_LOC_IOCTL_INJECT_UTC_TIME; - - 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)(android::elapsedRealtime() - timeReference); - time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms - - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_INJECT_UTC_TIME, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - if (ret_val != TRUE) - { - LOGD ("loc_eng_inject_time failed\n"); - } - - return 0; -} - -static int loc_eng_inject_location (double latitude, double longitude, float accuracy) -{ - /* not yet implemented */ - 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 GpsAidingData matches with - LOC API specification. - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_delete_aiding_data (GpsAidingData f) -{ - pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); - - // Currently, LOC API only support deletion of all aiding data, - if (f) - loc_eng_data.aiding_data_for_deletion = GPS_DELETE_ALL; - - if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) && - (loc_eng_data.aiding_data_for_deletion != 0)) - { - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING; - pthread_cond_signal(&(loc_eng_data.deferred_action_cond)); - - // In case gps engine is ON, the assistance data will be deleted when the engine is OFF - } - - pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); -} - -/*=========================================================================== -FUNCTION loc_eng_get_extension - -DESCRIPTION - Get the gps extension to support XTRA. - -DEPENDENCIES - N/A - -RETURN VALUE - The GPS extension interface. - -SIDE EFFECTS - N/A - -===========================================================================*/ -static const void* loc_eng_get_extension(const char* name) -{ - if (strcmp(name, GPS_XTRA_INTERFACE) == 0) - { - return &sLocEngXTRAInterface; - } - else if (strcmp(name, AGPS_INTERFACE) == 0) - { - return &sLocEngAGpsInterface; - } - else if (strcmp(name, GPS_NI_INTERFACE) == 0) - { - return &sLocEngNiInterface; - } - - return NULL; -} - -#if DEBUG_MOCK_NI == 1 -/*=========================================================================== -FUNCTION mock_ni - -DESCRIPTION - DEBUG tool: simulate an NI request - -DEPENDENCIES - N/A - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void* mock_ni(void* arg) -{ - static int busy = 0; - - if (busy) return NULL; - - busy = 1; - - sleep(5); - - rpc_loc_client_handle_type client_handle; - rpc_loc_event_mask_type loc_event; - rpc_loc_event_payload_u_type payload; - rpc_loc_ni_event_s_type *ni_req; - rpc_loc_ni_supl_notify_verify_req_s_type *supl_req; - - client_handle = (rpc_loc_client_handle_type) arg; - - loc_event = RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST; - payload.disc = loc_event; - - ni_req = &payload.rpc_loc_event_payload_u_type_u.ni_request; - ni_req->event = RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ; - supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req; - - // Encodings for Spirent Communications - char client_name[80] = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77, - 0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03}; - char requestor_id[80] = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77, - 0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03}; - - supl_req->flags = RPC_LOC_NI_CLIENT_NAME_PRESENT | - RPC_LOC_NI_REQUESTOR_ID_PRESENT | - RPC_LOC_NI_ENCODING_TYPE_PRESENT; - - supl_req->datacoding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT; - - supl_req->client_name.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT; // no coding - supl_req->client_name.client_name_string.client_name_string_len = strlen(client_name); - supl_req->client_name.client_name_string.client_name_string_val = client_name; - supl_req->client_name.string_len = strlen(client_name); - - supl_req->requestor_id.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT; - supl_req->requestor_id.requestor_id_string.requestor_id_string_len = strlen(requestor_id); - supl_req->requestor_id.requestor_id_string.requestor_id_string_val = requestor_id; - supl_req->requestor_id.string_len = strlen(requestor_id); - - supl_req->notification_priv_type = RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP; - supl_req->user_response_timer = 10; - - loc_event_cb(client_handle, loc_event, &payload); - - busy = 0; - - return NULL; -} -#endif // DEBUG_MOCK_NI - -/*=========================================================================== -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( - rpc_loc_client_handle_type client_handle, - rpc_loc_event_mask_type loc_event, - const rpc_loc_event_payload_u_type* loc_event_payload - ) -{ - LOGV ("loc_event_cb, client = %d, loc_event = 0x%x", (int32) client_handle, (uint32) loc_event); - if (client_handle == loc_eng_data.client_handle) - { - pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); - loc_eng_data.loc_event = loc_event; - memcpy(&loc_eng_data.loc_event_payload, loc_event_payload, sizeof(*loc_event_payload)); - - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_EVENT; - pthread_cond_signal(&loc_eng_data.deferred_action_cond); - pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); - } - else - { - LOGD ("loc client mismatch: received = %d, expected = %d \n", (int32) client_handle, (int32) loc_eng_data.client_handle); - } - - return RPC_LOC_API_SUCCESS; -} - -/*=========================================================================== -FUNCTION loc_eng_report_position - -DESCRIPTION - Reports position information to the Java layer. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr) -{ - UlpLocation location; - - LOGV ("loc_eng_report_position: location report, valid mask = 0x%x, sess status = %d\n", - (uint32) location_report_ptr->valid_mask, location_report_ptr->session_status); - - memset (&location, 0, sizeof(location)); - location.size = sizeof(location); - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS) - { - // Not a position report, return - if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS) - { - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC) - { - location.timestamp = location_report_ptr->timestamp_utc; - } - - if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) && - (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE)) - { - location.flags |= GPS_LOCATION_HAS_LAT_LONG; - location.latitude = location_report_ptr->latitude; - location.longitude = location_report_ptr->longitude; - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID ) - { - location.flags |= GPS_LOCATION_HAS_ALTITUDE; - location.altitude = location_report_ptr->altitude_wrt_ellipsoid; - } - - if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) && - (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_VERTICAL)) - { - location.flags |= GPS_LOCATION_HAS_SPEED; - location.speed = sqrt(location_report_ptr->speed_horizontal * location_report_ptr->speed_horizontal + - location_report_ptr->speed_vertical * location_report_ptr->speed_vertical); - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HEADING) - { - location.flags |= GPS_LOCATION_HAS_BEARING; - location.bearing = location_report_ptr->heading; - } - - if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR) - { - location.flags |= GPS_LOCATION_HAS_ACCURACY; - location.accuracy = location_report_ptr->hor_unc_circular; - } - - if (loc_eng_data.location_cb != NULL) - { - LOGV ("loc_eng_report_position: fire callback\n"); - loc_eng_data.location_cb (&location); - } - } - else - { - LOGV ("loc_eng_report_position: ignore position report when session status = %d\n", location_report_ptr->session_status); - } - } - else - { - LOGV ("loc_eng_report_position: ignore position report when session status is not set\n"); - } -} - -/*=========================================================================== -FUNCTION loc_eng_report_sv - -DESCRIPTION - Reports GPS satellite information to the Java layer. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr) -{ - GpsSvStatus SvStatus; - int num_svs_max, i; - const rpc_loc_sv_info_s_type *sv_info_ptr; - - LOGV ("loc_eng_report_sv: valid_mask = 0x%x, num of sv = %d\n", - (uint32) gnss_report_ptr->valid_mask, - gnss_report_ptr->sv_count); - - num_svs_max = 0; - memset (&SvStatus, 0, sizeof (GpsSvStatus)); - 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 > GPS_MAX_SVS) - { - num_svs_max = GPS_MAX_SVS; - } - } - - if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST) - { - SvStatus.num_svs = 0; - - for (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(GpsSvStatus); - 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.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) - { - 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++; - } - } - - LOGV ("num_svs = %d, eph mask = %d, alm mask = %d\n", SvStatus.num_svs, SvStatus.ephemeris_mask, SvStatus.almanac_mask ); - if ((SvStatus.num_svs != 0) && (loc_eng_data.sv_status_cb != NULL)) - { - loc_eng_data.sv_status_cb(&SvStatus); - } -} - -/*=========================================================================== -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 (const rpc_loc_status_event_s_type *status_report_ptr) -{ - GpsStatus status; - - LOGV ("loc_eng_report_status: event = %d\n", status_report_ptr->event); - - memset (&status, 0, sizeof(status)); - status.size = sizeof(status); - status.status = GPS_STATUS_NONE; - 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) - { - // GPS_STATUS_SESSION_BEGIN implies GPS_STATUS_ENGINE_ON - status.status = GPS_STATUS_SESSION_BEGIN; - loc_eng_data.status_cb(&status); - } - else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF) - { - // GPS_STATUS_SESSION_END implies GPS_STATUS_ENGINE_OFF - status.status = GPS_STATUS_ENGINE_OFF; - loc_eng_data.status_cb(&status); - } - } - - pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); - loc_eng_data.engine_status = status.status; - - // Wake up the thread for aiding data deletion. - if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) && - (loc_eng_data.aiding_data_for_deletion != 0)) - { - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING; - pthread_cond_signal(&(loc_eng_data.deferred_action_cond)); - // In case gps engine is ON, the assistance data will be deleted when the engine is OFF - } - - pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); -} - -static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr) -{ - if (loc_eng_data.nmea_cb != NULL) - { - struct timeval tv; - - gettimeofday(&tv, (struct timezone *) NULL); - long long now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; - -#if (AMSS_VERSION==3200) - loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences.nmea_sentences_val, - nmea_report_ptr->nmea_sentences.nmea_sentences_len); -#else - loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences, nmea_report_ptr->length); -#endif - } -} - -/*=========================================================================== -FUNCTION loc_eng_process_conn_request - -DESCRIPTION - Requests data connection to be brought up/tore down with the location server. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr) -{ - LOGD ("loc_event_cb: get loc event location server request, event = %d\n", server_request_ptr->event); - - // Signal DeferredActionThread to send the APN name - pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); - - // This implemenation is based on the fact that modem now at any time has only one data connection for AGPS at any given time - if (server_request_ptr->event == RPC_LOC_SERVER_REQUEST_OPEN) - { - loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle; - loc_eng_data.agps_status = GPS_REQUEST_AGPS_DATA_CONN; - loc_eng_data.agps_request_pending = true; - } - else - { - loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle; - loc_eng_data.agps_status = GPS_RELEASE_AGPS_DATA_CONN; - loc_eng_data.agps_request_pending = false; - } - - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_STATUS; - pthread_cond_signal(&loc_eng_data.deferred_action_cond); - pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); -} - -/*=========================================================================== -FUNCTION loc_eng_agps_init - -DESCRIPTION - - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_agps_init(AGpsCallbacks* callbacks) -{ - LOGV("loc_eng_agps_init\n"); - loc_eng_data.agps_status_cb = callbacks->status_cb; -} - -static int loc_eng_agps_data_conn_open(const char* apn) -{ - int apn_len; - LOGD("loc_eng_agps_data_conn_open: %s\n", apn); - - pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); - - if (apn != NULL) - { - apn_len = strlen (apn); - - if (apn_len >= sizeof(loc_eng_data.apn_name)) - { - LOGD ("loc_eng_set_apn: error, apn name exceeds maximum lenght of 100 chars\n"); - apn_len = sizeof(loc_eng_data.apn_name) - 1; - } - - memcpy (loc_eng_data.apn_name, apn, apn_len); - loc_eng_data.apn_name[apn_len] = '\0'; - } - - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_SUCCESS; - pthread_cond_signal(&(loc_eng_data.deferred_action_cond)); - pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); - return 0; -} - -static int loc_eng_agps_data_conn_closed() -{ - LOGD("loc_eng_agps_data_conn_closed\n"); - pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_CLOSED; - pthread_cond_signal(&(loc_eng_data.deferred_action_cond)); - pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); - return 0; -} - -static int loc_eng_agps_data_conn_failed() -{ - LOGD("loc_eng_agps_data_conn_failed\n"); - - pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); - /* hold a wake lock while events are pending for deferred_action_thread */ - loc_eng_data.acquire_wakelock_cb(); - loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_FAILED; - pthread_cond_signal(&(loc_eng_data.deferred_action_cond)); - pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); - return 0; -} - -static int set_agps_server() -{ - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_server_info_s_type *server_info_ptr; - boolean ret_val; - uint16 port_temp; - unsigned char *b_ptr; - - if (loc_eng_data.agps_server_host[0] == 0 || loc_eng_data.agps_server_port == 0) - return -1; - - if (loc_eng_data.agps_server_address == 0) { - struct hostent* he = gethostbyname(loc_eng_data.agps_server_host); - if (he) - loc_eng_data.agps_server_address = *(uint32_t *)he->h_addr_list[0]; - } - if (loc_eng_data.agps_server_address == 0) - return -1; - - b_ptr = (unsigned char*) (&loc_eng_data.agps_server_address); - - - server_info_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr); - ioctl_data.disc = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR; - server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL; - server_info_ptr->addr_info.disc = RPC_LOC_SERVER_ADDR_URL; - -#if (AMSS_VERSION==3200) - char url[24]; - memset(url, 0, sizeof(url)); - snprintf(url, sizeof(url) - 1, "%d.%d.%d.%d:%d", - (*(b_ptr + 0) & 0x000000ff), (*(b_ptr+1) & 0x000000ff), - (*(b_ptr + 2) & 0x000000ff), (*(b_ptr+3) & 0x000000ff), - (loc_eng_data.agps_server_port & (0x0000ffff))); - - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = url; - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len = strlen(url); - LOGD ("set_agps_server, addr = %s\n", server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val); -#else - char* buf = server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr; - int buf_len = sizeof(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr); - memset(buf, 0, buf_len); - snprintf(buf, buf_len - 1, "%d.%d.%d.%d:%d", - (*(b_ptr + 0) & 0x000000ff), (*(b_ptr+1) & 0x000000ff), - (*(b_ptr + 2) & 0x000000ff), (*(b_ptr+3) & 0x000000ff), - (loc_eng_data.agps_server_port & (0x0000ffff))); - - server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = buf_len; - LOGD ("set_agps_server, addr = %s\n", buf); -#endif - - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - - if (ret_val != TRUE) - { - LOGD ("set_agps_server failed\n"); - return -1; - } - else - { - LOGV ("set_agps_server successful\n"); - return 0; - } -} - -static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port) -{ - LOGD ("loc_eng_set_default_agps_server, type = %d, hostname = %s, port = %d\n", type, hostname, port); - - if (type != AGPS_TYPE_SUPL) - return -1; - - strncpy(loc_eng_data.agps_server_host, hostname, sizeof(loc_eng_data.agps_server_host) - 1); - loc_eng_data.agps_server_port = port; - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_delete_aiding_data_deferred_action - -DESCRIPTION - This is used to remove the aiding data when GPS engine is off. - -DEPENDENCIES - Assumes the aiding data type specified in GpsAidingData matches with - LOC API specification. - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_delete_aiding_data_deferred_action (void) -{ - // Currently, we only support deletion of all aiding data, - // since the Android defined aiding data mask matches with modem, - // so just pass them down without any translation - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_assist_data_delete_s_type *assist_data_ptr; - boolean ret_val; - - ioctl_data.disc = RPC_LOC_IOCTL_DELETE_ASSIST_DATA; - assist_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete); - assist_data_ptr->type = loc_eng_data.aiding_data_for_deletion; - loc_eng_data.aiding_data_for_deletion = 0; - - memset (&(assist_data_ptr->reserved), 0, sizeof (assist_data_ptr->reserved)); - - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_DELETE_ASSIST_DATA , - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL); - - LOGD("loc_eng_ioctl for aiding data deletion returned %d, 1 for success\n", ret_val); -} - -/*=========================================================================== -FUNCTION loc_eng_process_atl_deferred_action - -DESCRIPTION - This is used to inform the location engine of the processing status for - data connection open/close request. - -DEPENDENCIES - None - -RETURN VALUE - RPC_LOC_API_SUCCESS - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_process_atl_deferred_action (int flags) -{ - rpc_loc_server_open_status_s_type *conn_open_status_ptr; - rpc_loc_server_close_status_s_type *conn_close_status_ptr; - rpc_loc_ioctl_data_u_type ioctl_data; - boolean ret_val; - int agps_status = -1; - - LOGV("loc_eng_process_atl_deferred_action, agps_status = %d\n", loc_eng_data.agps_status); - - memset (&ioctl_data, 0, sizeof (rpc_loc_ioctl_data_u_type)); - - if (flags & DEFERRED_ACTION_AGPS_DATA_CLOSED) - { - ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS; - conn_close_status_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status); - conn_close_status_ptr->conn_handle = loc_eng_data.conn_handle; - conn_close_status_ptr->close_status = RPC_LOC_SERVER_CLOSE_SUCCESS; - } - else - { - ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS; - conn_open_status_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status; - conn_open_status_ptr->conn_handle = loc_eng_data.conn_handle; - if (flags & DEFERRED_ACTION_AGPS_DATA_SUCCESS) - { - conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_SUCCESS; - // Both buffer are of the same maximum size, and the source is null terminated - // strcpy (&(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status.apn_name), &(loc_eng_data.apn_name)); -#if (AMSS_VERSION==3200) - conn_open_status_ptr->apn_name = loc_eng_data.apn_name; -#else - memset(conn_open_status_ptr->apn_name, 0, sizeof(conn_open_status_ptr->apn_name)); - strncpy(conn_open_status_ptr->apn_name, loc_eng_data.apn_name, - sizeof(conn_open_status_ptr->apn_name) - 1); -#endif - // Delay this so that PDSM ATL module will behave properly - sleep (1); - LOGD("loc_eng_ioctl for ATL with apn_name = %s\n", conn_open_status_ptr->apn_name); - } - else // data_connection_failed - { - conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_FAIL; - } - // Delay this so that PDSM ATL module will behave properly - sleep (1); - } - - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - ioctl_data.disc, - &ioctl_data, - LOC_IOCTL_DEFAULT_TIMEOUT, - NULL); - - LOGD("loc_eng_ioctl for ATL returned %d (1 for success)\n", ret_val); -} - -/*=========================================================================== -FUNCTION loc_eng_process_loc_event - -DESCRIPTION - This is used to process events received from the location engine. - -DEPENDENCIES - None - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_process_loc_event (rpc_loc_event_mask_type loc_event, - rpc_loc_event_payload_u_type* loc_event_payload) -{ - if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT) - { - loc_eng_report_position (&(loc_event_payload->rpc_loc_event_payload_u_type_u.parsed_location_report)); - } - - if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT) - { - loc_eng_report_sv (&(loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report)); - } - - if (loc_event & RPC_LOC_EVENT_STATUS_REPORT) - { - loc_eng_report_status (&(loc_event_payload->rpc_loc_event_payload_u_type_u.status_report)); - } - - if (loc_event & RPC_LOC_EVENT_NMEA_POSITION_REPORT) - { - loc_eng_report_nmea (&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report)); - } - - // Android XTRA interface 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) - { - LOGD ("loc_event_cb: xtra download requst"); - - // Call Registered callback - if (loc_eng_data.xtra_module_data.download_request_cb != NULL) - { - loc_eng_data.xtra_module_data.download_request_cb (); - } - } - } - - if (loc_event & RPC_LOC_EVENT_IOCTL_REPORT) - { - // Process the received RPC_LOC_EVENT_IOCTL_REPORT - (void) loc_eng_ioctl_process_cb (loc_eng_data.client_handle, - &(loc_event_payload->rpc_loc_event_payload_u_type_u.ioctl_report)); - } - - if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST) - { - loc_eng_process_conn_request (&(loc_event_payload->rpc_loc_event_payload_u_type_u.loc_server_request)); - } - - loc_eng_ni_callback(loc_event, loc_event_payload); - -#if DEBUG_MOCK_NI == 1 - // DEBUG only - if ((loc_event & RPC_LOC_EVENT_STATUS_REPORT) && - loc_event_payload->rpc_loc_event_payload_u_type_u.status_report. - payload.rpc_loc_status_event_payload_u_type_u.engine_state - == RPC_LOC_ENGINE_STATE_OFF) - { - // Mock an NI request - pthread_t th; - pthread_create (&th, NULL, mock_ni, (void*) client_handle); - } -#endif /* DEBUG_MOCK_NI == 1 */ -} - -/*=========================================================================== -FUNCTION loc_eng_process_deferred_action - -DESCRIPTION - Main routine for the thread to execute certain commands - that are not safe to be done from within an RPC callback. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_process_deferred_action (void* arg) -{ - AGpsExtStatus status; - status.size = sizeof(status); - status.type = AGPS_TYPE_SUPL; - - LOGD("loc_eng_process_deferred_action started\n"); - - // make sure we do not run in background scheduling group - set_sched_policy(gettid(), SP_FOREGROUND); - - // disable the GPS lock - LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n"); - loc_eng_set_gps_lock(RPC_LOC_LOCK_NONE); - - while (1) - { - GpsAidingData aiding_data_for_deletion; - GpsStatusValue engine_status; - - rpc_loc_event_mask_type loc_event; - rpc_loc_event_payload_u_type loc_event_payload; - - // Wait until we are signalled to do a deferred action, or exit - pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); - - // If we have an event we should process it immediately, - // otherwise wait until we are signalled - if (loc_eng_data.deferred_action_flags == 0) { - // do not hold a wake lock while waiting for an event... - loc_eng_data.release_wakelock_cb(); - pthread_cond_wait(&loc_eng_data.deferred_action_cond, - &loc_eng_data.deferred_action_mutex); - // but after we are signalled reacquire the wake lock - // until we are done processing the event. - loc_eng_data.acquire_wakelock_cb(); - } - - if (loc_eng_data.deferred_action_flags & DEFERRED_ACTION_QUIT) - { - pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); - break; - } - - // copy anything we need before releasing the mutex - loc_event = loc_eng_data.loc_event; - if (loc_event != 0) { - memcpy(&loc_event_payload, &loc_eng_data.loc_event_payload, sizeof(loc_event_payload)); - loc_eng_data.loc_event = 0; - } - - int flags = loc_eng_data.deferred_action_flags; - loc_eng_data.deferred_action_flags = 0; - engine_status = loc_eng_data.agps_status; - aiding_data_for_deletion = loc_eng_data.aiding_data_for_deletion; - status.status = loc_eng_data.agps_status; - loc_eng_data.agps_status = 0; - - // perform all actions after releasing the mutex to avoid blocking RPCs from the ARM9 - pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); - - if (loc_event != 0) { - loc_eng_process_loc_event(loc_event, &loc_event_payload); - } - - // send_delete_aiding_data must be done when GPS engine is off - if ((engine_status != GPS_STATUS_SESSION_BEGIN) && (aiding_data_for_deletion != 0)) - { - loc_eng_delete_aiding_data_deferred_action (); - } - - if (flags & (DEFERRED_ACTION_AGPS_DATA_SUCCESS | - DEFERRED_ACTION_AGPS_DATA_CLOSED | - DEFERRED_ACTION_AGPS_DATA_FAILED)) - { - loc_eng_process_atl_deferred_action(flags); - - pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex)); - // work around problem with loc_eng_stop when AGPS requests are pending - // we defer stopping the engine until the AGPS request is done - loc_eng_data.agps_request_pending = false; - if (loc_eng_data.stop_request_pending) - { - LOGD ("handling deferred stop\n"); - if (loc_stop_fix(loc_eng_data.client_handle) != RPC_LOC_API_SUCCESS) - { - LOGD ("loc_stop_fix failed!\n"); - } - } - pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex)); - } - - if (status.status != 0 && loc_eng_data.agps_status_cb) { - loc_eng_data.agps_status_cb(&status); - } - } - - // reenable the GPS lock - LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_ALL\n"); - loc_eng_set_gps_lock(RPC_LOC_LOCK_ALL); - - LOGD("loc_eng_process_deferred_action thread exiting\n"); - loc_eng_data.release_wakelock_cb(); - - loc_eng_data.deferred_action_thread = 0; -} - -// for gps.c -extern "C" const GpsInterface* get_gps_interface() -{ - return &sLocEngInterface; -} diff --git a/loc_api/libloc_api/loc_eng.h b/loc_api/libloc_api/loc_eng.h deleted file mode 100644 index b8553316..00000000 --- a/loc_api/libloc_api/loc_eng.h +++ /dev/null @@ -1,115 +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_H -#define LOC_ENG_H - -// Define boolean type to be used by libgps on loc api module -typedef unsigned char boolean; - -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - -#include -#include -#include - -#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds - -enum { - DEFERRED_ACTION_EVENT = 0x01, - DEFERRED_ACTION_DELETE_AIDING = 0x02, - DEFERRED_ACTION_AGPS_STATUS = 0x04, - DEFERRED_ACTION_AGPS_DATA_SUCCESS = 0x08, - DEFERRED_ACTION_AGPS_DATA_CLOSED = 0x10, - DEFERRED_ACTION_AGPS_DATA_FAILED = 0x20, - DEFERRED_ACTION_QUIT = 0x40, -}; - -// Module data -typedef struct -{ - rpc_loc_client_handle_type client_handle; - - gps_location_callback location_cb; - gps_status_callback status_cb; - gps_sv_status_callback sv_status_cb; - agps_status_callback agps_status_cb; - gps_nmea_callback nmea_cb; - gps_ni_notify_callback ni_notify_cb; - gps_acquire_wakelock acquire_wakelock_cb; - gps_release_wakelock release_wakelock_cb; - int agps_status; - - // used to defer stopping the GPS engine until AGPS data calls are done - boolean agps_request_pending; - boolean stop_request_pending; - pthread_mutex_t deferred_stop_mutex; - - loc_eng_xtra_data_s_type xtra_module_data; - - loc_eng_ioctl_data_s_type ioctl_data; - - // data from loc_event_cb - rpc_loc_event_mask_type loc_event; - rpc_loc_event_payload_u_type loc_event_payload; - - // TBD: - char agps_server_host[256]; - int agps_server_port; - uint32 agps_server_address; - char apn_name[100]; - int position_mode; - rpc_loc_server_connection_handle conn_handle; - - // GPS engine status - GpsStatusValue engine_status; - - // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off - GpsAidingData aiding_data_for_deletion; - - // Data variables used by deferred action thread - pthread_t deferred_action_thread; - // Mutex used by deferred action thread - pthread_mutex_t deferred_action_mutex; - // Condition variable used by deferred action thread - pthread_cond_t deferred_action_cond; - - // flags for pending events for deferred action thread - int deferred_action_flags; -} loc_eng_data_s_type; - -extern loc_eng_data_s_type loc_eng_data; - -#endif // LOC_ENG_H diff --git a/loc_api/libloc_api/loc_eng_ioctl.cpp b/loc_api/libloc_api/loc_eng_ioctl.cpp deleted file mode 100644 index dc7b2c11..00000000 --- a/loc_api/libloc_api/loc_eng_ioctl.cpp +++ /dev/null @@ -1,354 +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. - * - */ - -#define LOG_NDDEBUG 0 - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include - -#include - -#define LOG_TAG "lib_locapi" -#include - -// comment this out to enable logging -// #undef LOGD -// #define LOGD(...) {} - -// Function declarations -static boolean loc_eng_ioctl_setup_cb( - rpc_loc_client_handle_type handle, - rpc_loc_ioctl_e_type ioctl_type -); - -static boolean loc_eng_ioctl_wait_cb( - int timeout_msec, // Timeout in this number of msec - rpc_loc_ioctl_callback_s_type *cb_data_ptr // Output parameter for IOCTL calls -); - -/*=========================================================================== - -FUNCTION loc_eng_ioctl - -DESCRIPTION - This function calls loc_ioctl and waits for the callback result before - returning back to the user. - -DEPENDENCIES - N/A - -RETURN VALUE - TRUE if successful - FALSE if failed - -SIDE EFFECTS - N/A - -===========================================================================*/ -boolean loc_eng_ioctl( - rpc_loc_client_handle_type handle, - rpc_loc_ioctl_e_type ioctl_type, - rpc_loc_ioctl_data_u_type* ioctl_data_ptr, - uint32 timeout_msec, - rpc_loc_ioctl_callback_s_type *cb_data_ptr - ) -{ - boolean ret_val; - int rpc_ret_val; - loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr; - - LOGV ("loc_eng_ioctl: client = %d, ioctl_type = %d, cb_data =0x%x\n", (int32) handle, ioctl_type, (uint32) cb_data_ptr); - - ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data); - // Select the callback we are waiting for - ret_val = loc_eng_ioctl_setup_cb (handle, ioctl_type); - - if (ret_val == TRUE) - { - rpc_ret_val = loc_ioctl (handle, - ioctl_type, - ioctl_data_ptr); - - LOGV ("loc_eng_ioctl: loc_ioctl returned %d \n", rpc_ret_val); - - if (rpc_ret_val == RPC_LOC_API_SUCCESS) - { - // Wait for the callback of loc_ioctl - ret_val = loc_eng_ioctl_wait_cb (timeout_msec, cb_data_ptr); - } - else - { - ret_val = FALSE; - } - } - - // Reset the state when we are done - pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); - ioctl_cb_data_ptr->cb_is_selected = FALSE; - ioctl_cb_data_ptr->cb_is_waiting = FALSE; - ioctl_cb_data_ptr->cb_has_arrived = FALSE; - pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex); - - return ret_val; -} - - -/*=========================================================================== - -FUNCTION loc_eng_ioctl_setup_cb - -DESCRIPTION - Selects which callback is going to be waited for - -DEPENDENCIES - N/A - -RETURN VALUE - TRUE if successful - FALSE if failed - -SIDE EFFECTS - N/A - -===========================================================================*/ -static boolean loc_eng_ioctl_setup_cb( - rpc_loc_client_handle_type handle, - rpc_loc_ioctl_e_type ioctl_type - ) -{ - boolean ret_val; - loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr; - - ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data); - - pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); - if (ioctl_cb_data_ptr->cb_is_selected == TRUE) - { - LOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n"); - ret_val = FALSE; - } - else - { - ioctl_cb_data_ptr->cb_is_selected = TRUE; - ioctl_cb_data_ptr->cb_is_waiting = FALSE; - ioctl_cb_data_ptr->cb_has_arrived = FALSE; - ioctl_cb_data_ptr->client_handle = handle; - ioctl_cb_data_ptr->ioctl_type = ioctl_type; - memset (&(ioctl_cb_data_ptr->cb_payload), 0, sizeof (rpc_loc_ioctl_callback_s_type)); - ret_val = TRUE; - } - pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex); - - return ret_val; -} - -/*=========================================================================== - -FUNCTION loc_eng_ioctl_wait_cb - -DESCRIPTION - Waits for a selected callback. The wait expires in timeout_msec. - - If the function is called before an existing wait has finished, it will - immediately return EBUSY. - -DEPENDENCIES - N/A - -RETURN VALUE - TRUE if successful - FALSE if failed - -SIDE EFFECTS - N/A - -===========================================================================*/ -boolean loc_eng_ioctl_wait_cb( - int timeout_msec, // Timeout in this number of msec - rpc_loc_ioctl_callback_s_type *cb_data_ptr - ) -{ - boolean ret_val = FALSE; // the return value of this function - int rc; // return code from pthread calls - - struct timeval present_time; - struct timespec expire_time; - loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr; - - ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data); - - pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); - - do { - if (ioctl_cb_data_ptr->cb_is_selected == FALSE) - { - LOGD ("loc_eng_ioctl_wait_cb: ERROR called when cb_is_waiting is set to FALSE \n"); - ret_val = FALSE; - break; - } - - // Calculate absolute expire time - gettimeofday(&present_time, NULL); - expire_time.tv_sec = present_time.tv_sec; - expire_time.tv_sec += timeout_msec / 1000; - if ((present_time.tv_usec + timeout_msec) >= 1000) - { - expire_time.tv_sec += 1; - } - expire_time.tv_nsec = (present_time.tv_usec + timeout_msec) % 1000 * 1000; - - // Special case where callback is issued before loc_ioctl ever returns - if (ioctl_cb_data_ptr->cb_has_arrived == TRUE) - { - LOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n"); - ret_val = TRUE; - break; - } - - ioctl_cb_data_ptr->cb_is_waiting = TRUE; - // Wait for the callback until timeout expires - rc = pthread_cond_timedwait(&ioctl_cb_data_ptr->cb_arrived_cond, - &ioctl_cb_data_ptr->cb_data_mutex, - &expire_time); - - if (rc == 0) - { - ret_val = TRUE; - } - else - { - ret_val = FALSE; - } - - LOGV ("loc_eng_ioctl_wait_cb: pthread_cond_timedwait returned %d\n", rc); - - } while (0); - - // Process the ioctl callback data when IOCTL is successful - if (ret_val == TRUE) - { - ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data); - if (ioctl_cb_data_ptr->cb_payload.status == RPC_LOC_API_SUCCESS) - { - ret_val = TRUE; - if (cb_data_ptr != NULL) - { - memcpy (cb_data_ptr, - &(ioctl_cb_data_ptr->cb_payload), - sizeof (rpc_loc_ioctl_callback_s_type)); - } - } - else - { - ret_val = FALSE; - } - } - - pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex); - - LOGV ("loc_eng_ioctl_wait_cb: returned %d\n", ret_val); - return ret_val; -} - -/*=========================================================================== - -FUNCTION loc_eng_ioctl_process_cb - -DESCRIPTION - This function process the IOCTL callback, parameter specifies the client - that receives the IOCTL callback. - -DEPENDENCIES - N/A - -RETURN VALUE - TRUE if successful - FALSE if failed - -SIDE EFFECTS - N/A - -===========================================================================*/ -boolean loc_eng_ioctl_process_cb ( - rpc_loc_client_handle_type client_handle, - const rpc_loc_ioctl_callback_s_type *cb_data_ptr - ) -{ - boolean ret_val = FALSE; // the return value of this function - loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr; - ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data); - - pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); - if (client_handle != ioctl_cb_data_ptr->client_handle) - { - LOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n", - (int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle); - ret_val = FALSE; - } - else if (cb_data_ptr->type != ioctl_cb_data_ptr->ioctl_type) - { - LOGD ("loc_eng_ioctl_process_cb: ioctl type mismatch, received = %d, expected = %d \n", - cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type); - ret_val = FALSE; - } - else // both matches - { - memcpy (&(ioctl_cb_data_ptr->cb_payload), - cb_data_ptr, - sizeof (rpc_loc_ioctl_callback_s_type)); - - ioctl_cb_data_ptr->cb_has_arrived = TRUE; - - LOGV ("loc_eng_ioctl_process_cb: callback arrived for client = %d, ioctl = %d, status = %d\n", - (int32) ioctl_cb_data_ptr->client_handle, ioctl_cb_data_ptr->ioctl_type, - (int32) ioctl_cb_data_ptr->cb_payload.status); - - ret_val = TRUE; - } - - pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex); - - // Signal the waiting thread that callback has arrived - if (ret_val == TRUE) - { - pthread_cond_signal (&ioctl_cb_data_ptr->cb_arrived_cond); - } - - return ret_val; -} diff --git a/loc_api/libloc_api/loc_eng_ioctl.h b/loc_api/libloc_api/loc_eng_ioctl.h deleted file mode 100644 index b8191256..00000000 --- a/loc_api/libloc_api/loc_eng_ioctl.h +++ /dev/null @@ -1,69 +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_IOCTL_H -#define LOC_ENG_IOCTL_H - -// Module data -typedef struct loc_eng_ioctl_data_s_type -{ - // We are waiting for an ioctl callback - boolean cb_is_selected; - // The thread has been put in a wait state for an ioctl callback - boolean cb_is_waiting; - // Loc client handle that is waiting for the callback - rpc_loc_client_handle_type client_handle; - // IOCTL type that the loc client is waiting for - rpc_loc_ioctl_e_type ioctl_type; - // The IOCLT report has arrived for the waiting client - boolean cb_has_arrived; - // The payload for the RPC_LOC_EVENT_IOCTL_REPORT - rpc_loc_ioctl_callback_s_type cb_payload; - // Mutex to access this data structure - pthread_mutex_t cb_data_mutex; - // LOC ioctl callback arrived mutex - pthread_cond_t cb_arrived_cond; -} loc_eng_ioctl_data_s_type; - - -extern boolean loc_eng_ioctl -( - rpc_loc_client_handle_type handle, - rpc_loc_ioctl_e_type ioctl_type, - rpc_loc_ioctl_data_u_type* ioctl_data_ptr, - uint32 timeout_msec, - rpc_loc_ioctl_callback_s_type *cb_data_ptr -); - -extern boolean loc_eng_ioctl_process_cb -( - rpc_loc_client_handle_type client_handle, - const rpc_loc_ioctl_callback_s_type *cb_data_ptr -); -#endif // LOC_ENG_IOCTL_H diff --git a/loc_api/libloc_api/loc_eng_ni.cpp b/loc_api/libloc_api/loc_eng_ni.cpp deleted file mode 100644 index 11d7abac..00000000 --- a/loc_api/libloc_api/loc_eng_ni.cpp +++ /dev/null @@ -1,609 +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. - * - */ - -#define LOG_NDDEBUG 0 - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#define LOG_TAG "lib_locapi" -#include - -// comment this out to enable logging -// #undef LOGD -// #define LOGD(...) {} - -/*============================================================================= - * - * DATA DECLARATION - * - *============================================================================*/ - -const GpsNiInterface sLocEngNiInterface = -{ - sizeof(GpsNiInterface), - loc_eng_ni_init, - loc_eng_ni_respond, -}; - -boolean loc_eng_ni_data_init = FALSE; -loc_eng_ni_data_s_type loc_eng_ni_data; - -extern loc_eng_data_s_type loc_eng_data; - -/*============================================================================= - * - * FUNCTION DECLARATIONS - * - *============================================================================*/ - -/*=========================================================================== - -FUNCTION respond_from_enum - -DESCRIPTION - Returns the name of the response - -RETURN VALUE - response name string - -===========================================================================*/ -static const char* respond_from_enum(rpc_loc_ni_user_resp_e_type resp) -{ - switch (resp) - { - case RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT: - return "accept"; - case RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY: - return "deny"; - case RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP: - return "no response"; - default: - return NULL; - } -} - -/*=========================================================================== - -FUNCTION loc_ni_respond - -DESCRIPTION - Displays the NI request and awaits user input. If a previous request is - in session, the new one is handled using sys.ni_default_response (if exists); - otherwise, it is denied. - -DEPENDENCY - Do not lock the data by mutex loc_ni_lock - -RETURN VALUE - none - -===========================================================================*/ -static void loc_ni_respond(rpc_loc_ni_user_resp_e_type resp, - const rpc_loc_ni_event_s_type *request_pass_back -) -{ - LOGD("Sending NI response: %s\n", respond_from_enum(resp)); - - rpc_loc_ioctl_data_u_type data; - rpc_loc_ioctl_callback_s_type callback_payload; - - memcpy(&data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.ni_event_pass_back, - request_pass_back, sizeof (rpc_loc_ni_event_s_type)); - data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = resp; - - loc_eng_ioctl( - loc_eng_data.client_handle, - RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE, - &data, - LOC_IOCTL_DEFAULT_TIMEOUT, - &callback_payload - ); -} - -/*=========================================================================== - -FUNCTION loc_ni_fill_notif_verify_type - -DESCRIPTION - Fills need_notify, need_verify, etc. - -RETURN VALUE - none - -===========================================================================*/ -static boolean loc_ni_fill_notif_verify_type(GpsNiNotification *notif, - rpc_loc_ni_notify_verify_e_type notif_priv) -{ - notif->notify_flags = 0; - notif->default_response = GPS_NI_RESPONSE_NORESP; - - switch (notif_priv) - { - case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY: - notif->notify_flags = 0; - break; - - case RPC_LOC_NI_USER_NOTIFY_ONLY: - notif->notify_flags = GPS_NI_NEED_NOTIFY; - break; - - case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP: - notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY; - notif->default_response = GPS_NI_RESPONSE_ACCEPT; - break; - - case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP: - notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY; - notif->default_response = GPS_NI_RESPONSE_DENY; - break; - - case RPC_LOC_NI_USER_PRIVACY_OVERRIDE: - notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE; - break; - - default: - return FALSE; - } - - return TRUE; -} - -/*=========================================================================== - -FUNCTION hexcode - -DESCRIPTION - Converts a binary array into a Hex string. E.g., 1F 00 3F --> "1F003F" - -RETURN VALUE - bytes encoded - -===========================================================================*/ -static int hexcode(char *hexstring, int string_size, const char *data, int data_size) -{ - int i; - for (i = 0; i < data_size; i++) - { - char ch = data[i]; - if (i*2 + 3 <= string_size) - { - snprintf(&hexstring[i*2], 3, "%02X", ch); - } - else { - break; - } - } - return i; -} - -static GpsNiEncodingType convert_encoding_type(int loc_encoding) -{ - GpsNiEncodingType enc = GPS_ENC_UNKNOWN; - - switch (loc_encoding) - { - case RPC_LOC_NI_SUPL_UTF8: - enc = GPS_ENC_SUPL_UTF8; - break; - case RPC_LOC_NI_SUPL_UCS2: - enc = GPS_ENC_SUPL_UCS2; - break; - case RPC_LOC_NI_SUPL_GSM_DEFAULT: - enc = GPS_ENC_SUPL_GSM_DEFAULT; - break; - default: - break; - } - - return enc; -} - -/*=========================================================================== - -FUNCTION loc_ni_request_handler - -DESCRIPTION - Displays the NI request and awaits user input. If a previous request is - in session, it is ignored. - -RETURN VALUE - none - -===========================================================================*/ -static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_type *ni_req) -{ - GpsNiNotification notif; - notif.size = sizeof(notif); - strlcpy(notif.text, "[text]", sizeof notif.text); // defaults - strlcpy(notif.requestor_id, "[requestor id]", sizeof notif.requestor_id); - - /* If busy, use default or deny */ - if (loc_eng_ni_data.notif_in_progress) - { -#if 0 - /* Cannot be here because the current thread is in RPC client */ - /* XXX Consider adding an event queue to process overlapped NI requests */ - loc_ni_user_resp_e_type response = - sys.ni_default_resp == 1 /* accept */ ? - LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT : - LOC_NI_LCS_NOTIFY_VERIFY_DENY; - - loc_ni_respond(response, ni_req); */ -#endif - LOGW("loc_ni_request_handler, notification in progress, new NI request ignored, type: %d", - ni_req->event); - } - else { - /* Print notification */ - LOGD("NI Notification: %s, event: %d", msg, ni_req->event); - - pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock); - - /* Save request */ - memcpy(&loc_eng_ni_data.loc_ni_request, ni_req, sizeof loc_eng_ni_data.loc_ni_request); - - /* Set up NI response waiting */ - loc_eng_ni_data.notif_in_progress = TRUE; - loc_eng_ni_data.current_notif_id = abs(rand()); - - /* Fill in notification */ - notif.notification_id = loc_eng_ni_data.current_notif_id; - - const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req; - const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req; - const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req; - - switch (ni_req->event) - { - case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ: - vx_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req; - notif.ni_type = GPS_NI_TYPE_VOICE; - notif.timeout = LOC_NI_NO_RESPONSE_TIME; // vx_req->user_resp_timer_val; - memset(notif.extras, 0, sizeof notif.extras); - memset(notif.text, 0, sizeof notif.text); - memset(notif.requestor_id, 0, sizeof notif.requestor_id); - - // Requestor ID - hexcode(notif.requestor_id, sizeof notif.requestor_id, - vx_req->requester_id.requester_id, - vx_req->requester_id.requester_id_length); - - notif.text_encoding = 0; // No text and no encoding - notif.requestor_id_encoding = convert_encoding_type(vx_req->encoding_scheme); - - // Set default_response & notify_flags - loc_ni_fill_notif_verify_type(¬if, vx_req->notification_priv_type); - - break; - - case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ: - umts_cp_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req; - notif.ni_type = GPS_NI_TYPE_UMTS_CTRL_PLANE; - notif.timeout = LOC_NI_NO_RESPONSE_TIME; // umts_cp_req->user_response_timer; - memset(notif.extras, 0, sizeof notif.extras); - memset(notif.text, 0, sizeof notif.text); - memset(notif.requestor_id, 0, sizeof notif.requestor_id); - - // Stores notification text - hexcode(notif.text, sizeof notif.text, -#if (AMSS_VERSION==3200) - umts_cp_req->notification_text.notification_text_val, -#else - umts_cp_req->notification_text, -#endif - umts_cp_req->notification_length); - - // Stores requestor ID - hexcode(notif.requestor_id, sizeof notif.requestor_id, -#if (AMSS_VERSION==3200) - umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val, -#else - umts_cp_req->requestor_id.requestor_id_string, -#endif - umts_cp_req->requestor_id.string_len); - - notif.text_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme); - notif.requestor_id_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme); - - // Set default_response & notify_flags - loc_ni_fill_notif_verify_type(¬if, umts_cp_req->notification_priv_type); - - break; - - case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ: - supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req; - notif.ni_type = GPS_NI_TYPE_UMTS_SUPL; - notif.timeout = LOC_NI_NO_RESPONSE_TIME; // supl_req->user_response_timer; - memset(notif.extras, 0, sizeof notif.extras); - memset(notif.text, 0, sizeof notif.text); - memset(notif.requestor_id, 0, sizeof notif.requestor_id); - - // Client name - if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT) - { - hexcode(notif.text, sizeof notif.text, -#if (AMSS_VERSION==3200) - supl_req->client_name.client_name_string.client_name_string_val, /* buffer */ -#else - supl_req->client_name.client_name_string, /* buffer */ -#endif - supl_req->client_name.string_len /* length */ - ); - LOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len); - } else { - LOGD("SUPL NI: client_name not present."); - } - - // Requestor ID - if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT) - { - hexcode(notif.requestor_id, sizeof notif.requestor_id, -#if (AMSS_VERSION==3200) - supl_req->requestor_id.requestor_id_string.requestor_id_string_val, /* buffer */ -#else - supl_req->requestor_id.requestor_id_string, /* buffer */ -#endif - supl_req->requestor_id.string_len /* length */ - ); - LOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len); - } else { - LOGD("SUPL NI: requestor_id not present."); - } - - // Encoding type - if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT) - { - notif.text_encoding = convert_encoding_type(supl_req->datacoding_scheme); - notif.requestor_id_encoding = convert_encoding_type(supl_req->datacoding_scheme); - } else { - notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN; - } - - // Set default_response & notify_flags - loc_ni_fill_notif_verify_type(¬if, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type); - - break; - - default: - LOGE("loc_ni_request_handler, unknown request event: %d", ni_req->event); - return; - } - - /* Log requestor ID and text for debugging */ - LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif.ni_type, notif.timeout, notif.default_response); - LOGI(" requestor_id: %s (encoding: %d)", notif.requestor_id, notif.requestor_id_encoding); - LOGI(" text: %s text (encoding: %d)", notif.text, notif.text_encoding); - - /* For robustness, always sets a timeout to clear up the notification status, even though - * the OEM layer in java does not do so. - **/ - loc_eng_ni_data.response_time_left = 5 + (notif.timeout != 0 ? notif.timeout : LOC_NI_NO_RESPONSE_TIME); - LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data.response_time_left); - - pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock); - - /* Notify callback */ - if (loc_eng_data.ni_notify_cb != NULL) - { - loc_eng_data.ni_notify_cb(¬if); - } - } -} - -/*=========================================================================== - -FUNCTION loc_ni_process_user_response - -DESCRIPTION - Handles user input from the UI - -RETURN VALUE - error code (0 for successful, -1 for error) - -===========================================================================*/ -int loc_ni_process_user_response(GpsUserResponseType userResponse) -{ - LOGD("NI response from UI: %d", userResponse); - - rpc_loc_ni_user_resp_e_type resp; - switch (userResponse) - { - case GPS_NI_RESPONSE_ACCEPT: - resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT; - break; - case GPS_NI_RESPONSE_DENY: - resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY; - break; - case GPS_NI_RESPONSE_NORESP: - resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP; - break; - default: - return -1; - } - - loc_ni_respond(resp, &loc_eng_ni_data.loc_ni_request); - - /* Make the NI respond */ - pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock); - loc_eng_ni_data.notif_in_progress = FALSE; - loc_eng_ni_data.response_time_left = 0; - loc_eng_ni_data.current_notif_id = -1; - pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock); - - return 0; -} - -/*=========================================================================== - -FUNCTION loc_eng_ni_callback - -DESCRIPTION - Loc API callback handler - -RETURN VALUE - error code (0 for success) - -===========================================================================*/ -int loc_eng_ni_callback ( - rpc_loc_event_mask_type loc_event, /* event mask */ - const rpc_loc_event_payload_u_type* loc_event_payload /* payload */ -) -{ - int rc = 0; - const rpc_loc_ni_event_s_type *ni_req = &loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request; - if (loc_event == RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST) - { - switch (ni_req->event) - { - case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ: - LOGI("VX Notification"); - loc_ni_request_handler("VX Notify", ni_req); - break; - - case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ: - LOGI("UMTS CP Notification\n"); - loc_ni_request_handler("UMTS CP Notify", ni_req); - break; - - case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ: - LOGI("SUPL Notification\n"); - loc_ni_request_handler("SUPL Notify", ni_req); - break; - - default: - LOGE("Unknown NI event: %x\n", (int) ni_req->event); - break; - } - } - return rc; -} - -/*=========================================================================== - -FUNCTION loc_ni_thread_proc - -===========================================================================*/ -static void loc_ni_thread_proc(void *unused) -{ - LOGI("Starting Loc NI thread...\n"); - - while (1) - { - /* wakes up every second to check timed out requests */ - sleep(1); - - pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock); - - if (loc_eng_ni_data.notif_in_progress && loc_eng_ni_data.response_time_left > 0) - { - loc_eng_ni_data.response_time_left--; - if (loc_eng_ni_data.response_time_left <= 0) - { - loc_ni_respond(RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP, &loc_eng_ni_data.loc_ni_request); - loc_eng_ni_data.notif_in_progress = FALSE; - } - } - - pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock); - } /* while (1) */ -} - -/*=========================================================================== -FUNCTION loc_eng_ni_init - -DESCRIPTION - This function initializes the NI interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_ni_init(GpsNiCallbacks *callbacks) -{ - LOGD("loc_eng_ni_init: entered."); - - if (!loc_eng_ni_data_init) - { - pthread_mutex_init(&loc_eng_ni_data.loc_ni_lock, NULL); - callbacks->create_thread_cb("loc_api_ni", loc_ni_thread_proc, NULL); - loc_eng_ni_data_init = TRUE; - } - - loc_eng_ni_data.notif_in_progress = FALSE; - loc_eng_ni_data.current_notif_id = -1; - loc_eng_ni_data.response_time_left = 0; - - srand(time(NULL)); - loc_eng_data.ni_notify_cb = callbacks->notify_cb; -} - -/*=========================================================================== -FUNCTION loc_eng_ni_respond - -DESCRIPTION - This function sends an NI respond to the modem processor - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response) -{ - if (notif_id == loc_eng_ni_data.current_notif_id && loc_eng_ni_data.notif_in_progress) - { - LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id); - loc_ni_process_user_response(user_response); - } else { - LOGE("loc_eng_ni_respond: notif_id %d mismatch or notification not in progress, response: %d", - notif_id, user_response); - } -} diff --git a/loc_api/libloc_api/loc_eng_ni.h b/loc_api/libloc_api/loc_eng_ni.h deleted file mode 100644 index cfd2ab18..00000000 --- a/loc_api/libloc_api/loc_eng_ni.h +++ /dev/null @@ -1,56 +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_NI_H -#define LOC_ENG_NI_H - -#include - -#define LOC_NI_NO_RESPONSE_TIME 20 /* secs */ - -extern const GpsNiInterface sLocEngNiInterface; - -typedef struct { - pthread_mutex_t loc_ni_lock; - int response_time_left; /* examine time for NI response */ - boolean notif_in_progress; /* NI notification/verification in progress */ - rpc_loc_ni_event_s_type loc_ni_request; - int current_notif_id; /* ID to check against response */ -} loc_eng_ni_data_s_type; - -// Functions for sLocEngNiInterface -extern void loc_eng_ni_init(GpsNiCallbacks *callbacks); -extern void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response); - -extern int loc_eng_ni_callback ( - rpc_loc_event_mask_type loc_event, /* event mask */ - const rpc_loc_event_payload_u_type* loc_event_payload /* payload */ -); - -#endif /* LOC_ENG_NI_H */ diff --git a/loc_api/libloc_api/loc_eng_xtra.cpp b/loc_api/libloc_api/loc_eng_xtra.cpp deleted file mode 100644 index 0c3e476a..00000000 --- a/loc_api/libloc_api/loc_eng_xtra.cpp +++ /dev/null @@ -1,180 +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. - * - */ - -#define LOG_NDDEBUG 0 - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include - -#define LOG_TAG "lib_locapi" -#include - -// comment this out to enable logging -// #undef LOGD -// #define LOGD(...) {} - -#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100) -#define XTRA_BLOCK_SIZE (400) - -static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks); -static int qct_loc_eng_inject_xtra_data(char* data, int length); - -const GpsXtraInterface sLocEngXTRAInterface = -{ - sizeof(GpsXtraInterface), - qct_loc_eng_xtra_init, - qct_loc_eng_inject_xtra_data, -}; - -/*=========================================================================== -FUNCTION qct_loc_eng_xtra_init - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks) -{ - rpc_loc_event_mask_type event; - loc_eng_xtra_data_s_type *xtra_module_data_ptr; - - xtra_module_data_ptr = &(loc_eng_data.xtra_module_data); - xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb; - - return 0; -} - -/*=========================================================================== -FUNCTION qct_loc_eng_inject_xtra_data - -DESCRIPTION - Injects XTRA file into the engine. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - >0: failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int qct_loc_eng_inject_xtra_data(char* data, int length) -{ - int rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE; - boolean ret_val = 0; - int total_parts; - uint8 part; - uint16 part_len; - uint16 len_injected; - rpc_loc_ioctl_data_u_type ioctl_data; - rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr; - - LOGV ("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%x\n", length, (int) data); - - ioctl_data.disc = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA; - - predicted_orbits_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.predicted_orbits_data); - predicted_orbits_data_ptr->format_type = RPC_LOC_PREDICTED_ORBITS_XTRA; - predicted_orbits_data_ptr->total_size = length; - total_parts = (length / XTRA_BLOCK_SIZE); - if ((total_parts % XTRA_BLOCK_SIZE) != 0) - { - total_parts += 1; - } - predicted_orbits_data_ptr->total_parts = total_parts; - - len_injected = 0; // O bytes injected - // XTRA injection starts with part 1 - for (part = 1; part <= total_parts; part++) - { - predicted_orbits_data_ptr->part = part; - predicted_orbits_data_ptr->part_len = XTRA_BLOCK_SIZE; - if (XTRA_BLOCK_SIZE > (length - len_injected)) - { - predicted_orbits_data_ptr->part_len = length - len_injected; - } - predicted_orbits_data_ptr->data_ptr.data_ptr_len = predicted_orbits_data_ptr->part_len; - predicted_orbits_data_ptr->data_ptr.data_ptr_val = data + len_injected; - - LOGV ("qct_loc_eng_inject_xtra_data, inject part = %d, len = %d, len = %d\n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len, predicted_orbits_data_ptr->data_ptr.data_ptr_len); - LOGV ("qct_loc_eng_inject_xtra_data, total part = %d, len = %d \n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len); - - if (part < total_parts) - { - // No callback in this case - rpc_ret_val = loc_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA, - &ioctl_data); - - if (rpc_ret_val != RPC_LOC_API_SUCCESS) - { - LOGE ("loc_ioctl for xtra returned %d \n", rpc_ret_val); - ret_val = EINVAL; // return error - break; - } - } - else // part == total_parts - { - // Last part injection, will need to wait for callback - ret_val = loc_eng_ioctl (loc_eng_data.client_handle, - RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA, - &ioctl_data, - LOC_XTRA_INJECT_DEFAULT_TIMEOUT, - NULL /* No output information is expected*/); - break; // done with injection - } - - len_injected += predicted_orbits_data_ptr->part_len; - LOGV ("loc_ioctl for xtra len injected %d \n", len_injected); - } - - return ret_val; -} diff --git a/loc_api/libloc_api/loc_eng_xtra.h b/loc_api/libloc_api/loc_eng_xtra.h deleted file mode 100644 index a72b1528..00000000 --- a/loc_api/libloc_api/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 - -#include - -extern const GpsXtraInterface sLocEngXTRAInterface; - -// Module data -typedef struct -{ - // loc_eng_ioctl_cb_data_s_type ioctl_cb_data; - gps_xtra_download_request download_request_cb; - -} loc_eng_xtra_data_s_type; - -#endif // LOC_ENG_XTRA_H