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

Merge "Fixes ULP and FLP operation when GPS not enabled"

Browse source
This commit is contained in:
Linux Build Service Account 2013-06-12 18:17:07 -07:00 committed by Gerrit - the friendly Code Review server
commit 4ff37ed47f
3 changed files with 184 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
loc_api/libloc_api_50001/Android.mk
View file

@ -107,7 +107,8 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \ libcutils \
libloc_eng \ libloc_eng \
libgps.utils \ libgps.utils \
libdl libdl \
libandroid_runtime
LOCAL_SRC_FILES += \ LOCAL_SRC_FILES += \
loc.cpp \ loc.cpp \

204
loc_api/libloc_api_50001/loc.cpp
View file

@ -41,6 +41,7 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
#include <android_runtime/AndroidRuntime.h>
#include <cutils/properties.h> #include <cutils/properties.h>
@ -50,11 +51,18 @@ static const ulpInterface * loc_eng_get_ulp_inf(void);
static gps_location_callback gps_loc_cb = NULL; static gps_location_callback gps_loc_cb = NULL;
static gps_sv_status_callback gps_sv_cb = NULL; static gps_sv_status_callback gps_sv_cb = NULL;
static void loc_cb(UlpLocation* location, void* locExt); static void local_loc_cb(UlpLocation* location, void* locExt);
static void sv_cb(GpsSvStatus* sv_status, void* svExt); static void local_status_cb(GpsStatus* status);
static void local_sv_cb(GpsSvStatus* sv_status, void* svExt);
static void local_nmea_cb(GpsUtcTime timestamp, const char* nmea, int length);
static void local_set_capabilities_cb(uint32_t capabilities);
static void local_acquire_wakelock_cb(void);
static void local_release_wakelock_cb(void);
static void local_request_utc_time_cb(void);
// Function declarations for sLocEngInterface // Function declarations for sLocEngInterface
static int loc_init(GpsCallbacks* callbacks); static int loc_init(GpsCallbacks* callbacks);
static int loc_hal_init(void);
static int loc_start(); static int loc_start();
static int loc_stop(); static int loc_stop();
static void loc_cleanup(); static void loc_cleanup();
@ -188,6 +196,7 @@ static const UlpPhoneContextInterface sLocEngUlpPhoneContextInterface =
static loc_eng_data_s_type loc_afw_data; static loc_eng_data_s_type loc_afw_data;
static UlpCallbacks ulp_cb_data; static UlpCallbacks ulp_cb_data;
static LocCallbacks afw_cb_data;
static int gss_fd = 0; static int gss_fd = 0;
/*=========================================================================== /*===========================================================================
@ -224,6 +233,18 @@ const GpsInterface* gps_get_hardware_interface ()
ret_val = &sLocEngInterface; ret_val = &sLocEngInterface;
} }
if (0 != loc_hal_init()) {
LOC_LOGE("HAL could not be initialized");
ret_val = NULL;
} else {
ret_val = &sLocEngInterface;
}
loc_eng_read_config();
//We load up libulp module at this point itself
loc_eng_ulp_inf = loc_eng_get_ulp_inf();
EXIT_LOG(%p, ret_val); EXIT_LOG(%p, ret_val);
return ret_val; return ret_val;
} }
@ -232,6 +253,7 @@ const GpsInterface* gps_get_hardware_interface ()
extern "C" const GpsInterface* get_gps_interface() extern "C" const GpsInterface* get_gps_interface()
{ {
targetEnumType target = TARGET_OTHER; targetEnumType target = TARGET_OTHER;
if (NULL == loc_afw_data.context) {
loc_eng_read_config(); loc_eng_read_config();
//We load up libulp module at this point itself //We load up libulp module at this point itself
@ -254,6 +276,11 @@ extern "C" const GpsInterface* get_gps_interface()
LOC_LOGE("No GPS HW on this target (MPQ8064). Not returning interface"); LOC_LOGE("No GPS HW on this target (MPQ8064). Not returning interface");
return NULL; return NULL;
} }
if (0 != loc_hal_init()) {
LOC_LOGE("HAL could not be initialized");
return NULL;
}
}
return &sLocEngInterface; return &sLocEngInterface;
} }
@ -269,7 +296,7 @@ void loc_ulp_msg_sender(void* loc_eng_data_p, void* msg)
} }
/*=========================================================================== /*===========================================================================
FUNCTION loc_init FUNCTION loc_hal_init
DESCRIPTION DESCRIPTION
Initialize the location engine, this include setting up global datas Initialize the location engine, this include setting up global datas
@ -285,15 +312,10 @@ SIDE EFFECTS
N/Ax N/Ax
===========================================================================*/ ===========================================================================*/
static int loc_init(GpsCallbacks* callbacks) static int loc_hal_init(void)
{ {
int retVal = -1; int retVal = -1;
ENTRY_LOG(); ENTRY_LOG();
if(callbacks == NULL) {
LOC_LOGE("loc_init failed. cb = NULL\n");
EXIT_LOG(%d, retVal);
return retVal;
}
LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_EVENT_MASK_T event =
LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
LOC_API_ADAPTER_BIT_SATELLITE_REPORT | LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
@ -303,19 +325,18 @@ static int loc_init(GpsCallbacks* callbacks)
LOC_API_ADAPTER_BIT_STATUS_REPORT | LOC_API_ADAPTER_BIT_STATUS_REPORT |
LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT | LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
LocCallbacks clientCallbacks = {loc_cb, /* location_cb */ LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */
callbacks->status_cb, /* status_cb */ local_status_cb, /* status_cb */
sv_cb, /* sv_status_cb */ local_sv_cb, /* sv_status_cb */
callbacks->nmea_cb, /* nmea_cb */ local_nmea_cb, /* nmea_cb */
callbacks->set_capabilities_cb, /* set_capabilities_cb */ local_set_capabilities_cb, /* set_capabilities_cb */
callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */ local_acquire_wakelock_cb, /* acquire_wakelock_cb */
callbacks->release_wakelock_cb, /* release_wakelock_cb */ local_release_wakelock_cb, /* release_wakelock_cb */
callbacks->create_thread_cb, /* create_thread_cb */ (pthread_t (*)(const char*, void (*)(void*), void*))
android::AndroidRuntime::createJavaThread, /* create_thread_cb */
NULL, /* location_ext_parser */ NULL, /* location_ext_parser */
NULL, /* sv_ext_parser */ NULL, /* sv_ext_parser */
callbacks->request_utc_time_cb /* request_utc_time_cb */}; local_request_utc_time_cb /* request_utc_time_cb */};
gps_loc_cb = callbacks->location_cb;
gps_sv_cb = callbacks->sv_status_cb;
if (loc_eng_ulp_inf == NULL) if (loc_eng_ulp_inf == NULL)
retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event,
@ -324,17 +345,6 @@ static int loc_init(GpsCallbacks* callbacks)
retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event,
loc_ulp_msg_sender); loc_ulp_msg_sender);
if (ulp_cb_data.phone_context_cb) {
//ULP initilization already occurred so redo intializations here
//to restore callback table
loc_eng_ulp_phone_context_init(loc_afw_data, ulp_cb_data.phone_context_cb);
}
if (ulp_cb_data.network_location_cb) {
loc_eng_ulp_network_init(loc_afw_data, ulp_cb_data.network_location_cb);
}
int ret_val1 = loc_eng_ulp_init(loc_afw_data, loc_eng_ulp_inf); int ret_val1 = loc_eng_ulp_init(loc_afw_data, loc_eng_ulp_inf);
//Initialize the cached min_interval //Initialize the cached min_interval
loc_afw_data.min_interval_cached = ULP_MIN_INTERVAL_INVALID; loc_afw_data.min_interval_cached = ULP_MIN_INTERVAL_INVALID;
@ -1036,7 +1046,7 @@ static bool loc_inject_raw_command(char* command, int length)
return ret_val; return ret_val;
} }
static void loc_cb(UlpLocation* location, void* locExt) static void local_loc_cb(UlpLocation* location, void* locExt)
{ {
ENTRY_LOG(); ENTRY_LOG();
if (NULL != location) { if (NULL != location) {
@ -1044,6 +1054,8 @@ static void loc_cb(UlpLocation* location, void* locExt)
if (ULP_LOCATION_IS_FROM_GNSS == location->position_source ) { if (ULP_LOCATION_IS_FROM_GNSS == location->position_source ) {
if (NULL != gps_loc_cb) { if (NULL != gps_loc_cb) {
gps_loc_cb(&location->gpsLocation); gps_loc_cb(&location->gpsLocation);
} else {
LOC_LOGE("Error. GPS not enabled");
} }
} else { } else {
if (NULL != ulp_loc_cb) { if (NULL != ulp_loc_cb) {
@ -1054,12 +1066,14 @@ static void loc_cb(UlpLocation* location, void* locExt)
EXIT_LOG(%s, VOID_RET); EXIT_LOG(%s, VOID_RET);
} }
static void sv_cb(GpsSvStatus* sv_status, void* svExt) static void local_sv_cb(GpsSvStatus* sv_status, void* svExt)
{ {
ENTRY_LOG(); ENTRY_LOG();
if (NULL != gps_sv_cb) { if (NULL != gps_sv_cb) {
CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs); CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs);
gps_sv_cb(sv_status); gps_sv_cb(sv_status);
} else {
LOC_LOGE("Error. GPS not enabled");
} }
EXIT_LOG(%s, VOID_RET); EXIT_LOG(%s, VOID_RET);
} }
@ -1136,12 +1150,7 @@ static int loc_ulp_phone_context_init(UlpPhoneContextCallbacks *callbacks)
{ {
ENTRY_LOG(); ENTRY_LOG();
int ret_val = -1; int ret_val = -1;
if (loc_afw_data.context) {
ret_val = loc_eng_ulp_phone_context_init(loc_afw_data, callbacks); ret_val = loc_eng_ulp_phone_context_init(loc_afw_data, callbacks);
} else
{
ulp_cb_data.phone_context_cb = callbacks;
}
EXIT_LOG(%d, ret_val); EXIT_LOG(%d, ret_val);
return ret_val; return ret_val;
} }
@ -1191,13 +1200,7 @@ static int loc_ulp_network_init(UlpNetworkLocationCallbacks *callbacks)
{ {
ENTRY_LOG(); ENTRY_LOG();
int ret_val = -1; int ret_val = -1;
if (loc_afw_data.context) {
ret_val = loc_eng_ulp_network_init(loc_afw_data, callbacks); ret_val = loc_eng_ulp_network_init(loc_afw_data, callbacks);
} else
{
ulp_cb_data.network_location_cb = callbacks;
}
EXIT_LOG(%d, ret_val); EXIT_LOG(%d, ret_val);
return ret_val; return ret_val;
} }
@ -1279,3 +1282,116 @@ static int loc_ulp_engine_stop()
} }
/*===========================================================================
FUNCTION loc_init
DESCRIPTION
Registers the AFW call backs with the local tables
DEPENDENCIES
None
RETURN VALUE
0: success
SIDE EFFECTS
N/Ax
===========================================================================*/
static int loc_init(GpsCallbacks* callbacks)
{
int retVal = -1;
ENTRY_LOG();
if(callbacks == NULL) {
LOC_LOGE(" loc_init. cb = NULL\n");
EXIT_LOG(%d, retVal);
return retVal;
}
memset(&afw_cb_data, NULL, sizeof (LocCallbacks));
gps_loc_cb = callbacks->location_cb;
afw_cb_data.status_cb = callbacks->status_cb;
gps_sv_cb = callbacks->sv_status_cb;
afw_cb_data.set_capabilities_cb = callbacks->set_capabilities_cb;
afw_cb_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
afw_cb_data.release_wakelock_cb = callbacks->release_wakelock_cb;
afw_cb_data.request_utc_time_cb = callbacks->request_utc_time_cb;
afw_cb_data.nmea_cb = callbacks->nmea_cb;
if (NULL != callbacks->set_capabilities_cb) {
callbacks->set_capabilities_cb(gps_conf.CAPABILITIES);
}
retVal = 0;
EXIT_LOG(%d, retVal);
return retVal;
}
static void local_nmea_cb(GpsUtcTime timestamp, const char* nmea, int length)
{
ENTRY_LOG();
if (0 != length) {
if (NULL != afw_cb_data.nmea_cb) {
afw_cb_data.nmea_cb(timestamp, nmea, length);
} else
{
LOC_LOGE("Error. GPS not enabled");
}
}
EXIT_LOG(%s, VOID_RET);
}
static void local_set_capabilities_cb(uint32_t capabilities)
{
ENTRY_LOG();
if (NULL != afw_cb_data.set_capabilities_cb) {
afw_cb_data.set_capabilities_cb(capabilities);
} else {
LOC_LOGE("Error. GPS not enabled");
}
EXIT_LOG(%s, VOID_RET);
}
static void local_acquire_wakelock_cb(void)
{
ENTRY_LOG();
if (NULL != afw_cb_data.acquire_wakelock_cb) {
afw_cb_data.acquire_wakelock_cb();
} else {
LOC_LOGE("Error. GPS not enabled");
}
EXIT_LOG(%s, VOID_RET);
}
static void local_release_wakelock_cb(void)
{
ENTRY_LOG();
if (NULL != afw_cb_data.release_wakelock_cb) {
afw_cb_data.release_wakelock_cb();
} else {
LOC_LOGE("Error. GPS not enabled");
}
EXIT_LOG(%s, VOID_RET);
}
static void local_request_utc_time_cb(void)
{
ENTRY_LOG();
if (NULL != afw_cb_data.request_utc_time_cb) {
afw_cb_data.request_utc_time_cb();
} else {
LOC_LOGE("Error. GPS not enabled");
}
EXIT_LOG(%s, VOID_RET);
}
static void local_status_cb(GpsStatus* status)
{
ENTRY_LOG();
if (NULL != status) {
CALLBACK_LOG_CALLFLOW("status_callback - status", %d, status->status);
if (NULL != afw_cb_data.status_cb) {
afw_cb_data.status_cb(status);
} else {
LOC_LOGE("Error. GPS not enabled");
}
}
EXIT_LOG(%s, VOID_RET);
}

3
loc_api/libloc_api_50001/loc_eng.cpp
View file

@ -307,9 +307,6 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
// Create context (msg q + thread) (if not yet created) // Create context (msg q + thread) (if not yet created)
// This will also parse gps.conf, if not done. // This will also parse gps.conf, if not done.
loc_eng_data.context = (void*)LocEngContext::get(callbacks->create_thread_cb); loc_eng_data.context = (void*)LocEngContext::get(callbacks->create_thread_cb);
if (NULL != callbacks->set_capabilities_cb) {
callbacks->set_capabilities_cb(gps_conf.CAPABILITIES);
}
// Save callbacks // Save callbacks
loc_eng_data.location_cb = callbacks->location_cb; loc_eng_data.location_cb = callbacks->location_cb;