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

Rename (IF_)LOGD(_IF) to (IF_)ALOGD(_IF) DO NOT MERGE

Browse source 
See https://android-git.corp.google.com/g/156016

Bug: 5449033
Change-Id: I5a8da519f9d62f6b2978313462e32cba4cec6304
This commit is contained in:
Steve Block 2011-12-20 16:25:13 +00:00
parent 7c2f7b69f9
commit b80e8ff4f8
7 changed files with 74 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -67,8 +67,8 @@ when who what, where, why
#include <utils/Log.h> #include <utils/Log.h>
/* Comment this out to enable logging */ /* Comment this out to enable logging */
#undef LOGD #undef ALOGD
#define LOGD(...) {} #define ALOGD(...) {}
/*===================================================================== /*=====================================================================
External declarations External declarations
@ -99,17 +99,17 @@ bool_t rpc_loc_event_cb_f_type_0x00040001_svc(
/* Callback not registered, or unexpected ID (shouldn't happen) */ /* Callback not registered, or unexpected ID (shouldn't happen) */
if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID) if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID)
{ {
LOGD("Warning: No callback handler.\n"); ALOGD("Warning: No callback handler.\n");
ret->loc_event_cb_f_type_result = 0; ret->loc_event_cb_f_type_result = 0;
return 1; /* simply return */ return 1; /* simply return */
} }
LOGD("proc: %x prog: %x vers: %x\n", ALOGD("proc: %x prog: %x vers: %x\n",
(int) req->rq_proc, (int) req->rq_proc,
(int) req->rq_prog, (int) req->rq_prog,
(int) req->rq_vers); (int) req->rq_vers);
LOGD("Callback received: %x (handle=%d ret_ptr=%d)\n", ALOGD("Callback received: %x (handle=%d ret_ptr=%d)\n",
(int) argp->loc_event, (int) argp->loc_event,
(int) argp->loc_handle, (int) argp->loc_handle,
(int) ret); (int) ret);
@ -133,7 +133,7 @@ int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t res
/* /*
* Insert additional freeing code here, if needed * Insert additional freeing code here, if needed
*/ */
// LOGD("***** loc_apicbprog_freeresult\n"); // ALOGD("***** loc_apicbprog_freeresult\n");
return 1; return 1;
} }
@ -160,9 +160,9 @@ int loc_api_glue_init(void)
if (loc_api_clnt == NULL) if (loc_api_clnt == NULL)
{ {
/* Print msg */ /* Print msg */
LOGD("Trying to create RPC client...\n"); ALOGD("Trying to create RPC client...\n");
loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL); loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL);
LOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt); ALOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
if (loc_api_clnt == NULL) if (loc_api_clnt == NULL)
{ {
@ -174,7 +174,7 @@ int loc_api_glue_init(void)
int rc = loc_apicb_app_init(); int rc = loc_apicb_app_init();
if (rc >= 0) if (rc >= 0)
{ {
LOGD("Loc API callback initialized.\n"); ALOGD("Loc API callback initialized.\n");
} else { } else {
fprintf(stderr, "Loc API callback initialization failed.\n"); fprintf(stderr, "Loc API callback initialization failed.\n");
return 0; return 0;

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

@ -67,8 +67,8 @@ when who what, where, why
#include <utils/Log.h> #include <utils/Log.h>
/* Comment this out to enable logging */ /* Comment this out to enable logging */
#undef LOGD #undef ALOGD
#define LOGD(...) {} #define ALOGD(...) {}
/*===================================================================== /*=====================================================================
External declarations External declarations
@ -99,17 +99,17 @@ bool_t rpc_loc_event_cb_f_type_0x00010001_svc(
/* Callback not registered, or unexpected ID (shouldn't happen) */ /* Callback not registered, or unexpected ID (shouldn't happen) */
if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID) if (loc_api_saved_cb == NULL || argp->cb_id != LOC_API_CB_ID)
{ {
LOGD("Warning: No callback handler.\n"); ALOGD("Warning: No callback handler.\n");
ret->loc_event_cb_f_type_result = 0; ret->loc_event_cb_f_type_result = 0;
return 1; /* simply return */ return 1; /* simply return */
} }
LOGD("proc: %x prog: %x vers: %x\n", ALOGD("proc: %x prog: %x vers: %x\n",
(int) req->rq_proc, (int) req->rq_proc,
(int) req->rq_prog, (int) req->rq_prog,
(int) req->rq_vers); (int) req->rq_vers);
LOGD("Callback received: %x (handle=%d ret_ptr=%d)\n", ALOGD("Callback received: %x (handle=%d ret_ptr=%d)\n",
(int) argp->loc_event, (int) argp->loc_event,
(int) argp->loc_handle, (int) argp->loc_handle,
(int) ret); (int) ret);
@ -133,7 +133,7 @@ int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t res
/* /*
* Insert additional freeing code here, if needed * Insert additional freeing code here, if needed
*/ */
// LOGD("***** loc_apicbprog_freeresult\n"); // ALOGD("***** loc_apicbprog_freeresult\n");
return 1; return 1;
} }
@ -160,9 +160,9 @@ int loc_api_glue_init(void)
if (loc_api_clnt == NULL) if (loc_api_clnt == NULL)
{ {
/* Print msg */ /* Print msg */
LOGD("Trying to create RPC client...\n"); ALOGD("Trying to create RPC client...\n");
loc_api_clnt = clnt_create(NULL, LOC_APIPROG, /*LOC_APIVERS*/ 0x00010000, NULL); loc_api_clnt = clnt_create(NULL, LOC_APIPROG, /*LOC_APIVERS*/ 0x00010000, NULL);
LOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt); ALOGD("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
if (loc_api_clnt == NULL) if (loc_api_clnt == NULL)
{ {
@ -174,7 +174,7 @@ int loc_api_glue_init(void)
int rc = loc_apicb_app_init(); int rc = loc_apicb_app_init();
if (rc >= 0) if (rc >= 0)
{ {
LOGD("Loc API callback initialized.\n"); ALOGD("Loc API callback initialized.\n");
} else { } else {
fprintf(stderr, "Loc API callback initialization failed.\n"); fprintf(stderr, "Loc API callback initialization failed.\n");
return 0; return 0;

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

@ -25,7 +25,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
#define PRINT(x...) do { \ #define PRINT(x...) do { \
fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \ fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \
fprintf(stdout, ##x); \ fprintf(stdout, ##x); \
LOGD(x); \ ALOGD(x); \
} while(0) } while(0)
#ifdef DEBUG #ifdef DEBUG

72
loc_api/libloc_api/loc_eng.cpp
View file

@ -57,8 +57,8 @@ $Author: $
#include <utils/Log.h> #include <utils/Log.h>
// comment this out to enable logging // comment this out to enable logging
// #undef LOGD // #undef ALOGD
// #define LOGD(...) {} // #define ALOGD(...) {}
#define DEBUG_MOCK_NI 0 #define DEBUG_MOCK_NI 0
@ -150,7 +150,7 @@ const GpsInterface* gps_get_hardware_interface ()
property_get("gps.disable", propBuf, ""); property_get("gps.disable", propBuf, "");
if (propBuf[0] == '1') if (propBuf[0] == '1')
{ {
LOGD("gps_get_interface returning NULL because gps.disable=1\n"); ALOGD("gps_get_interface returning NULL because gps.disable=1\n");
return NULL; return NULL;
} }
@ -240,7 +240,7 @@ static int loc_eng_init(GpsCallbacks* callbacks)
loc_eng_data.deferred_action_thread = callbacks->create_thread_cb("loc_api", loc_eng_data.deferred_action_thread = callbacks->create_thread_cb("loc_api",
loc_eng_process_deferred_action, NULL); loc_eng_process_deferred_action, NULL);
LOGD ("loc_eng_init called, client id = %d\n", (int32) loc_eng_data.client_handle); ALOGD ("loc_eng_init called, client id = %d\n", (int32) loc_eng_data.client_handle);
return 0; return 0;
} }
@ -314,20 +314,20 @@ SIDE EFFECTS
static int loc_eng_start() static int loc_eng_start()
{ {
int ret_val; int ret_val;
LOGD ("loc_eng_start\n"); ALOGD ("loc_eng_start\n");
if (loc_eng_data.position_mode != GPS_POSITION_MODE_STANDALONE && if (loc_eng_data.position_mode != GPS_POSITION_MODE_STANDALONE &&
loc_eng_data.agps_server_host[0] != 0 && loc_eng_data.agps_server_host[0] != 0 &&
loc_eng_data.agps_server_port != 0) { loc_eng_data.agps_server_port != 0) {
int result = set_agps_server(); int result = set_agps_server();
LOGD ("set_agps_server returned = %d\n", result); ALOGD ("set_agps_server returned = %d\n", result);
} }
ret_val = loc_start_fix (loc_eng_data.client_handle); ret_val = loc_start_fix (loc_eng_data.client_handle);
if (ret_val != RPC_LOC_API_SUCCESS) if (ret_val != RPC_LOC_API_SUCCESS)
{ {
LOGD ("loc_eng_start returned error = %d\n", ret_val); ALOGD ("loc_eng_start returned error = %d\n", ret_val);
} }
return 0; return 0;
@ -354,7 +354,7 @@ static int loc_eng_stop()
{ {
int ret_val; int ret_val;
LOGD ("loc_eng_stop\n"); ALOGD ("loc_eng_stop\n");
pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex)); pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex));
// work around problem with loc_eng_stop when AGPS requests are pending // work around problem with loc_eng_stop when AGPS requests are pending
@ -362,7 +362,7 @@ static int loc_eng_stop()
if (loc_eng_data.agps_request_pending) if (loc_eng_data.agps_request_pending)
{ {
loc_eng_data.stop_request_pending = true; loc_eng_data.stop_request_pending = true;
LOGD ("deferring stop until AGPS data call is finished\n"); ALOGD ("deferring stop until AGPS data call is finished\n");
pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
return 0; return 0;
} }
@ -371,7 +371,7 @@ static int loc_eng_stop()
ret_val = loc_stop_fix (loc_eng_data.client_handle); ret_val = loc_stop_fix (loc_eng_data.client_handle);
if (ret_val != RPC_LOC_API_SUCCESS) if (ret_val != RPC_LOC_API_SUCCESS)
{ {
LOGD ("loc_eng_stop returned error = %d\n", ret_val); ALOGD ("loc_eng_stop returned error = %d\n", ret_val);
} }
return 0; return 0;
@ -382,7 +382,7 @@ static int loc_eng_set_gps_lock(rpc_loc_lock_e_type lock_type)
rpc_loc_ioctl_data_u_type ioctl_data; rpc_loc_ioctl_data_u_type ioctl_data;
boolean ret_val; boolean ret_val;
LOGD ("loc_eng_set_gps_lock mode, client = %d, lock_type = %d\n", ALOGD ("loc_eng_set_gps_lock mode, client = %d, lock_type = %d\n",
(int32) loc_eng_data.client_handle, lock_type); (int32) loc_eng_data.client_handle, lock_type);
ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = lock_type; ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = lock_type;
@ -396,7 +396,7 @@ static int loc_eng_set_gps_lock(rpc_loc_lock_e_type lock_type)
if (ret_val != TRUE) if (ret_val != TRUE)
{ {
LOGD ("loc_eng_set_gps_lock mode failed\n"); ALOGD ("loc_eng_set_gps_lock mode failed\n");
} }
return 0; return 0;
@ -425,7 +425,7 @@ static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence
rpc_loc_fix_criteria_s_type *fix_criteria_ptr; rpc_loc_fix_criteria_s_type *fix_criteria_ptr;
boolean ret_val; boolean ret_val;
LOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n", ALOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n",
(int32) loc_eng_data.client_handle, min_interval, mode); (int32) loc_eng_data.client_handle, min_interval, mode);
loc_eng_data.position_mode = mode; loc_eng_data.position_mode = mode;
@ -478,7 +478,7 @@ static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence
if (ret_val != TRUE) if (ret_val != TRUE)
{ {
LOGD ("loc_eng_set_position mode failed\n"); ALOGD ("loc_eng_set_position mode failed\n");
} }
return 0; return 0;
@ -506,7 +506,7 @@ static int loc_eng_inject_time (GpsUtcTime time, int64_t timeReference, int unce
rpc_loc_assist_data_time_s_type *time_info_ptr; rpc_loc_assist_data_time_s_type *time_info_ptr;
boolean ret_val; boolean ret_val;
LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty); ALOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty);
ioctl_data.disc = RPC_LOC_IOCTL_INJECT_UTC_TIME; ioctl_data.disc = RPC_LOC_IOCTL_INJECT_UTC_TIME;
@ -523,7 +523,7 @@ static int loc_eng_inject_time (GpsUtcTime time, int64_t timeReference, int unce
if (ret_val != TRUE) if (ret_val != TRUE)
{ {
LOGD ("loc_eng_inject_time failed\n"); ALOGD ("loc_eng_inject_time failed\n");
} }
return 0; return 0;
@ -723,7 +723,7 @@ static int32 loc_event_cb(
} }
else else
{ {
LOGD ("loc client mismatch: received = %d, expected = %d \n", (int32) client_handle, (int32) loc_eng_data.client_handle); ALOGD ("loc client mismatch: received = %d, expected = %d \n", (int32) client_handle, (int32) loc_eng_data.client_handle);
} }
return RPC_LOC_API_SUCCESS; return RPC_LOC_API_SUCCESS;
@ -1024,7 +1024,7 @@ SIDE EFFECTS
===========================================================================*/ ===========================================================================*/
static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr) 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); ALOGD ("loc_event_cb: get loc event location server request, event = %d\n", server_request_ptr->event);
// Signal DeferredActionThread to send the APN name // Signal DeferredActionThread to send the APN name
pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
@ -1075,7 +1075,7 @@ 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_open(const char* apn)
{ {
int apn_len; int apn_len;
LOGD("loc_eng_agps_data_conn_open: %s\n", apn); ALOGD("loc_eng_agps_data_conn_open: %s\n", apn);
pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
@ -1085,7 +1085,7 @@ static int loc_eng_agps_data_conn_open(const char* apn)
if (apn_len >= sizeof(loc_eng_data.apn_name)) if (apn_len >= sizeof(loc_eng_data.apn_name))
{ {
LOGD ("loc_eng_set_apn: error, apn name exceeds maximum lenght of 100 chars\n"); ALOGD ("loc_eng_set_apn: error, apn name exceeds maximum lenght of 100 chars\n");
apn_len = sizeof(loc_eng_data.apn_name) - 1; apn_len = sizeof(loc_eng_data.apn_name) - 1;
} }
@ -1103,7 +1103,7 @@ 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_closed()
{ {
LOGD("loc_eng_agps_data_conn_closed\n"); ALOGD("loc_eng_agps_data_conn_closed\n");
pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
/* hold a wake lock while events are pending for deferred_action_thread */ /* hold a wake lock while events are pending for deferred_action_thread */
loc_eng_data.acquire_wakelock_cb(); loc_eng_data.acquire_wakelock_cb();
@ -1115,7 +1115,7 @@ static int loc_eng_agps_data_conn_closed()
static int loc_eng_agps_data_conn_failed() static int loc_eng_agps_data_conn_failed()
{ {
LOGD("loc_eng_agps_data_conn_failed\n"); ALOGD("loc_eng_agps_data_conn_failed\n");
pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
/* hold a wake lock while events are pending for deferred_action_thread */ /* hold a wake lock while events are pending for deferred_action_thread */
@ -1163,7 +1163,7 @@ static int set_agps_server()
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_val = url;
server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len = strlen(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); ALOGD ("set_agps_server, addr = %s\n", server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val);
#else #else
char* buf = server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr; 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); int buf_len = sizeof(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr);
@ -1174,7 +1174,7 @@ static int set_agps_server()
(loc_eng_data.agps_server_port & (0x0000ffff))); (loc_eng_data.agps_server_port & (0x0000ffff)));
server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = buf_len; server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = buf_len;
LOGD ("set_agps_server, addr = %s\n", buf); ALOGD ("set_agps_server, addr = %s\n", buf);
#endif #endif
ret_val = loc_eng_ioctl (loc_eng_data.client_handle, ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
@ -1185,7 +1185,7 @@ static int set_agps_server()
if (ret_val != TRUE) if (ret_val != TRUE)
{ {
LOGD ("set_agps_server failed\n"); ALOGD ("set_agps_server failed\n");
return -1; return -1;
} }
else else
@ -1197,7 +1197,7 @@ static int set_agps_server()
static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port) 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); ALOGD ("loc_eng_set_default_agps_server, type = %d, hostname = %s, port = %d\n", type, hostname, port);
if (type != AGPS_TYPE_SUPL) if (type != AGPS_TYPE_SUPL)
return -1; return -1;
@ -1246,7 +1246,7 @@ static void loc_eng_delete_aiding_data_deferred_action (void)
LOC_IOCTL_DEFAULT_TIMEOUT, LOC_IOCTL_DEFAULT_TIMEOUT,
NULL); NULL);
LOGD("loc_eng_ioctl for aiding data deletion returned %d, 1 for success\n", ret_val); ALOGD("loc_eng_ioctl for aiding data deletion returned %d, 1 for success\n", ret_val);
} }
/*=========================================================================== /*===========================================================================
@ -1304,7 +1304,7 @@ static void loc_eng_process_atl_deferred_action (int flags)
#endif #endif
// Delay this so that PDSM ATL module will behave properly // Delay this so that PDSM ATL module will behave properly
sleep (1); sleep (1);
LOGD("loc_eng_ioctl for ATL with apn_name = %s\n", conn_open_status_ptr->apn_name); ALOGD("loc_eng_ioctl for ATL with apn_name = %s\n", conn_open_status_ptr->apn_name);
} }
else // data_connection_failed else // data_connection_failed
{ {
@ -1320,7 +1320,7 @@ static void loc_eng_process_atl_deferred_action (int flags)
LOC_IOCTL_DEFAULT_TIMEOUT, LOC_IOCTL_DEFAULT_TIMEOUT,
NULL); NULL);
LOGD("loc_eng_ioctl for ATL returned %d (1 for success)\n", ret_val); ALOGD("loc_eng_ioctl for ATL returned %d (1 for success)\n", ret_val);
} }
/*=========================================================================== /*===========================================================================
@ -1368,7 +1368,7 @@ static void loc_eng_process_loc_event (rpc_loc_event_mask_type loc_event,
if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event == if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ) RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ)
{ {
LOGD ("loc_event_cb: xtra download requst"); ALOGD ("loc_event_cb: xtra download requst");
// Call Registered callback // Call Registered callback
if (loc_eng_data.xtra_module_data.download_request_cb != NULL) if (loc_eng_data.xtra_module_data.download_request_cb != NULL)
@ -1429,13 +1429,13 @@ static void loc_eng_process_deferred_action (void* arg)
status.size = sizeof(status); status.size = sizeof(status);
status.type = AGPS_TYPE_SUPL; status.type = AGPS_TYPE_SUPL;
LOGD("loc_eng_process_deferred_action started\n"); ALOGD("loc_eng_process_deferred_action started\n");
// make sure we do not run in background scheduling group // make sure we do not run in background scheduling group
set_sched_policy(gettid(), SP_FOREGROUND); set_sched_policy(gettid(), SP_FOREGROUND);
// disable the GPS lock // disable the GPS lock
LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n"); ALOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n");
loc_eng_set_gps_lock(RPC_LOC_LOCK_NONE); loc_eng_set_gps_lock(RPC_LOC_LOCK_NONE);
while (1) while (1)
@ -1506,10 +1506,10 @@ static void loc_eng_process_deferred_action (void* arg)
loc_eng_data.agps_request_pending = false; loc_eng_data.agps_request_pending = false;
if (loc_eng_data.stop_request_pending) if (loc_eng_data.stop_request_pending)
{ {
LOGD ("handling deferred stop\n"); ALOGD ("handling deferred stop\n");
if (loc_stop_fix(loc_eng_data.client_handle) != RPC_LOC_API_SUCCESS) if (loc_stop_fix(loc_eng_data.client_handle) != RPC_LOC_API_SUCCESS)
{ {
LOGD ("loc_stop_fix failed!\n"); ALOGD ("loc_stop_fix failed!\n");
} }
} }
pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
@ -1521,10 +1521,10 @@ static void loc_eng_process_deferred_action (void* arg)
} }
// reenable the GPS lock // reenable the GPS lock
LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_ALL\n"); ALOGD("Setting GPS privacy lock to RPC_LOC_LOCK_ALL\n");
loc_eng_set_gps_lock(RPC_LOC_LOCK_ALL); loc_eng_set_gps_lock(RPC_LOC_LOCK_ALL);
LOGD("loc_eng_process_deferred_action thread exiting\n"); ALOGD("loc_eng_process_deferred_action thread exiting\n");
loc_eng_data.release_wakelock_cb(); loc_eng_data.release_wakelock_cb();
loc_eng_data.deferred_action_thread = 0; loc_eng_data.deferred_action_thread = 0;

14
loc_api/libloc_api/loc_eng_ioctl.cpp
View file

@ -52,8 +52,8 @@ $Author: $
#include <utils/Log.h> #include <utils/Log.h>
// comment this out to enable logging // comment this out to enable logging
// #undef LOGD // #undef ALOGD
// #define LOGD(...) {} // #define ALOGD(...) {}
// Function declarations // Function declarations
static boolean loc_eng_ioctl_setup_cb( static boolean loc_eng_ioctl_setup_cb(
@ -164,7 +164,7 @@ static boolean loc_eng_ioctl_setup_cb(
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
if (ioctl_cb_data_ptr->cb_is_selected == TRUE) if (ioctl_cb_data_ptr->cb_is_selected == TRUE)
{ {
LOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n"); ALOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n");
ret_val = FALSE; ret_val = FALSE;
} }
else else
@ -222,7 +222,7 @@ boolean loc_eng_ioctl_wait_cb(
do { do {
if (ioctl_cb_data_ptr->cb_is_selected == FALSE) 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"); ALOGD ("loc_eng_ioctl_wait_cb: ERROR called when cb_is_waiting is set to FALSE \n");
ret_val = FALSE; ret_val = FALSE;
break; break;
} }
@ -240,7 +240,7 @@ boolean loc_eng_ioctl_wait_cb(
// Special case where callback is issued before loc_ioctl ever returns // Special case where callback is issued before loc_ioctl ever returns
if (ioctl_cb_data_ptr->cb_has_arrived == TRUE) if (ioctl_cb_data_ptr->cb_has_arrived == TRUE)
{ {
LOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n"); ALOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n");
ret_val = TRUE; ret_val = TRUE;
break; break;
} }
@ -321,13 +321,13 @@ boolean loc_eng_ioctl_process_cb (
pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex); pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
if (client_handle != ioctl_cb_data_ptr->client_handle) if (client_handle != ioctl_cb_data_ptr->client_handle)
{ {
LOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n", ALOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n",
(int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle); (int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle);
ret_val = FALSE; ret_val = FALSE;
} }
else if (cb_data_ptr->type != ioctl_cb_data_ptr->ioctl_type) 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", ALOGD ("loc_eng_ioctl_process_cb: ioctl type mismatch, received = %d, expected = %d \n",
cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type); cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type);
ret_val = FALSE; ret_val = FALSE;
} }

20
loc_api/libloc_api/loc_eng_ni.cpp
View file

@ -46,8 +46,8 @@ $Id:
#include <utils/Log.h> #include <utils/Log.h>
// comment this out to enable logging // comment this out to enable logging
// #undef LOGD // #undef ALOGD
// #define LOGD(...) {} // #define ALOGD(...) {}
/*============================================================================= /*=============================================================================
* *
@ -119,7 +119,7 @@ static void loc_ni_respond(rpc_loc_ni_user_resp_e_type resp,
const rpc_loc_ni_event_s_type *request_pass_back const rpc_loc_ni_event_s_type *request_pass_back
) )
{ {
LOGD("Sending NI response: %s\n", respond_from_enum(resp)); ALOGD("Sending NI response: %s\n", respond_from_enum(resp));
rpc_loc_ioctl_data_u_type data; rpc_loc_ioctl_data_u_type data;
rpc_loc_ioctl_callback_s_type callback_payload; rpc_loc_ioctl_callback_s_type callback_payload;
@ -272,7 +272,7 @@ static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_typ
} }
else { else {
/* Print notification */ /* Print notification */
LOGD("NI Notification: %s, event: %d", msg, ni_req->event); ALOGD("NI Notification: %s, event: %d", msg, ni_req->event);
pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock); pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
@ -366,9 +366,9 @@ static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_typ
#endif #endif
supl_req->client_name.string_len /* length */ supl_req->client_name.string_len /* length */
); );
LOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len); ALOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
} else { } else {
LOGD("SUPL NI: client_name not present."); ALOGD("SUPL NI: client_name not present.");
} }
// Requestor ID // Requestor ID
@ -382,9 +382,9 @@ static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_typ
#endif #endif
supl_req->requestor_id.string_len /* length */ supl_req->requestor_id.string_len /* length */
); );
LOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len); ALOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
} else { } else {
LOGD("SUPL NI: requestor_id not present."); ALOGD("SUPL NI: requestor_id not present.");
} }
// Encoding type // Encoding type
@ -440,7 +440,7 @@ RETURN VALUE
===========================================================================*/ ===========================================================================*/
int loc_ni_process_user_response(GpsUserResponseType userResponse) int loc_ni_process_user_response(GpsUserResponseType userResponse)
{ {
LOGD("NI response from UI: %d", userResponse); ALOGD("NI response from UI: %d", userResponse);
rpc_loc_ni_user_resp_e_type resp; rpc_loc_ni_user_resp_e_type resp;
switch (userResponse) switch (userResponse)
@ -563,7 +563,7 @@ SIDE EFFECTS
===========================================================================*/ ===========================================================================*/
void loc_eng_ni_init(GpsNiCallbacks *callbacks) void loc_eng_ni_init(GpsNiCallbacks *callbacks)
{ {
LOGD("loc_eng_ni_init: entered."); ALOGD("loc_eng_ni_init: entered.");
if (!loc_eng_ni_data_init) if (!loc_eng_ni_data_init)
{ {

4
loc_api/libloc_api/loc_eng_xtra.cpp
View file

@ -49,8 +49,8 @@ $Author: $
#include <utils/Log.h> #include <utils/Log.h>
// comment this out to enable logging // comment this out to enable logging
// #undef LOGD // #undef ALOGD
// #define LOGD(...) {} // #define ALOGD(...) {}
#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100) #define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
#define XTRA_BLOCK_SIZE (400) #define XTRA_BLOCK_SIZE (400)