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

Hold a wake lock while events are pending for the deferred action thread.

Browse source 
Signed-off-by: Mike Lockwood <lockwood@android.com>
This commit is contained in:
Mike Lockwood 2010-04-07 09:06:06 -04:00
parent a4977cd631
commit 2c115de409
2 changed files with 92 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
loc_api/libloc_api/loc_eng.cpp
View file

@ -91,8 +91,7 @@ static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_p
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);
static void* loc_eng_process_deferred_action (void* arg); static void* loc_eng_process_deferred_action (void* arg);
static void loc_eng_process_atl_deferred_action (boolean data_connection_succeeded, static void loc_eng_process_atl_deferred_action (int flags);
boolean data_connection_closed);
static void loc_eng_delete_aiding_data_deferred_action (void); static void loc_eng_delete_aiding_data_deferred_action (void);
static int set_agps_server(); static int set_agps_server();
@ -182,10 +181,12 @@ static int loc_eng_init(GpsCallbacks* callbacks)
memset (&loc_eng_data, 0, sizeof (loc_eng_data_s_type)); memset (&loc_eng_data, 0, sizeof (loc_eng_data_s_type));
// LOC ENG module data initialization // LOC ENG module data initialization
loc_eng_data.location_cb = callbacks->location_cb; loc_eng_data.location_cb = callbacks->location_cb;
loc_eng_data.sv_status_cb = callbacks->sv_status_cb; loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
loc_eng_data.status_cb = callbacks->status_cb; loc_eng_data.status_cb = callbacks->status_cb;
loc_eng_data.nmea_cb = callbacks->nmea_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_mask_type event = RPC_LOC_EVENT_PARSED_POSITION_REPORT |
RPC_LOC_EVENT_SATELLITE_REPORT | RPC_LOC_EVENT_SATELLITE_REPORT |
@ -200,12 +201,9 @@ static int loc_eng_init(GpsCallbacks* callbacks)
pthread_mutex_init (&(loc_eng_data.deferred_action_mutex), NULL); pthread_mutex_init (&(loc_eng_data.deferred_action_mutex), NULL);
pthread_cond_init (&(loc_eng_data.deferred_action_cond) , NULL); pthread_cond_init (&(loc_eng_data.deferred_action_cond) , NULL);
loc_eng_data.deferred_action_thread_need_exit = FALSE;
loc_eng_data.loc_event = 0; loc_eng_data.loc_event = 0;
loc_eng_data.data_connection_succeeded = FALSE; loc_eng_data.deferred_action_flags = 0;
loc_eng_data.data_connection_closed = FALSE;
loc_eng_data.data_connection_failed = FALSE;
memset (loc_eng_data.apn_name, 0, sizeof (loc_eng_data.apn_name)); memset (loc_eng_data.apn_name, 0, sizeof (loc_eng_data.apn_name));
loc_eng_data.aiding_data_for_deletion = 0; loc_eng_data.aiding_data_for_deletion = 0;
@ -256,10 +254,12 @@ static void loc_eng_cleanup()
if (loc_eng_data.deferred_action_thread) if (loc_eng_data.deferred_action_thread)
{ {
/* Terminate deferred action working thread */ /* Terminate deferred action working thread */
pthread_mutex_lock (&loc_eng_data.deferred_action_mutex); pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
loc_eng_data.deferred_action_thread_need_exit = TRUE; /* hold a wake lock while events are pending for deferred_action_thread */
pthread_cond_signal (&loc_eng_data.deferred_action_cond); loc_eng_data.acquire_wakelock_cb();
pthread_mutex_unlock (&loc_eng_data.deferred_action_mutex); 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; void* ignoredValue;
pthread_join(loc_eng_data.deferred_action_thread, &ignoredValue); pthread_join(loc_eng_data.deferred_action_thread, &ignoredValue);
@ -520,6 +520,9 @@ static void loc_eng_delete_aiding_data (GpsAidingData f)
if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) && if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
(loc_eng_data.aiding_data_for_deletion != 0)) (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)); 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 // In case gps engine is ON, the assistance data will be deleted when the engine is OFF
@ -666,8 +669,11 @@ static int32 loc_event_cb(
loc_eng_data.loc_event = loc_event; loc_eng_data.loc_event = loc_event;
memcpy(&loc_eng_data.loc_event_payload, loc_event_payload, sizeof(*loc_event_payload)); memcpy(&loc_eng_data.loc_event_payload, loc_event_payload, sizeof(*loc_event_payload));
pthread_cond_signal (&loc_eng_data.deferred_action_cond); /* hold a wake lock while events are pending for deferred_action_thread */
pthread_mutex_unlock (&loc_eng_data.deferred_action_mutex); 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 else
{ {
@ -919,18 +925,21 @@ static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_rep
} }
} }
pthread_mutex_lock (&loc_eng_data.deferred_action_mutex); pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
loc_eng_data.engine_status = status.status; loc_eng_data.engine_status = status.status;
// Wake up the thread for aiding data deletion. // Wake up the thread for aiding data deletion.
if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) && if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
(loc_eng_data.aiding_data_for_deletion != 0)) (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)); 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 // 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); 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) static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr)
@ -982,8 +991,11 @@ static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *s
loc_eng_data.agps_status = GPS_RELEASE_AGPS_DATA_CONN; loc_eng_data.agps_status = GPS_RELEASE_AGPS_DATA_CONN;
} }
pthread_cond_signal (&loc_eng_data.deferred_action_cond); /* hold a wake lock while events are pending for deferred_action_thread */
pthread_mutex_unlock (&loc_eng_data.deferred_action_mutex); 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);
} }
/*=========================================================================== /*===========================================================================
@ -1014,7 +1026,6 @@ static int loc_eng_agps_data_conn_open(const char* apn)
LOGD("loc_eng_agps_data_conn_open: %s\n", apn); LOGD("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));
loc_eng_data.data_connection_succeeded = TRUE;
if (apn != NULL) if (apn != NULL)
{ {
@ -1030,6 +1041,9 @@ static int loc_eng_agps_data_conn_open(const char* apn)
loc_eng_data.apn_name[apn_len] = '\0'; 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_cond_signal(&(loc_eng_data.deferred_action_cond));
pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
return 0; return 0;
@ -1039,8 +1053,9 @@ static int loc_eng_agps_data_conn_closed()
{ {
LOGD("loc_eng_agps_data_conn_closed\n"); LOGD("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));
loc_eng_data.data_connection_closed = TRUE; /* hold a wake lock while events are pending for deferred_action_thread */
// DO WE NEED TO SIGNAL HERE? 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_cond_signal(&(loc_eng_data.deferred_action_cond));
pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
return 0; return 0;
@ -1051,7 +1066,9 @@ static int loc_eng_agps_data_conn_failed()
LOGD("loc_eng_agps_data_conn_failed\n"); LOGD("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));
loc_eng_data.data_connection_failed = TRUE; /* 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_cond_signal(&(loc_eng_data.deferred_action_cond));
pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
return 0; return 0;
@ -1185,8 +1202,7 @@ SIDE EFFECTS
N/A N/A
===========================================================================*/ ===========================================================================*/
static void loc_eng_process_atl_deferred_action (boolean data_connection_succeeded, static void loc_eng_process_atl_deferred_action (int flags)
boolean data_connection_closed)
{ {
rpc_loc_server_open_status_s_type *conn_open_status_ptr; rpc_loc_server_open_status_s_type *conn_open_status_ptr;
rpc_loc_server_close_status_s_type *conn_close_status_ptr; rpc_loc_server_close_status_s_type *conn_close_status_ptr;
@ -1198,7 +1214,7 @@ static void loc_eng_process_atl_deferred_action (boolean data_connection_succeed
memset (&ioctl_data, 0, sizeof (rpc_loc_ioctl_data_u_type)); memset (&ioctl_data, 0, sizeof (rpc_loc_ioctl_data_u_type));
if (data_connection_closed) if (flags & DEFERRED_ACTION_AGPS_DATA_CLOSED)
{ {
ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS; 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 = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status);
@ -1210,7 +1226,7 @@ static void loc_eng_process_atl_deferred_action (boolean data_connection_succeed
ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS; 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 = &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status;
conn_open_status_ptr->conn_handle = loc_eng_data.conn_handle; conn_open_status_ptr->conn_handle = loc_eng_data.conn_handle;
if (data_connection_succeeded) if (flags & DEFERRED_ACTION_AGPS_DATA_SUCCESS)
{ {
conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_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 // Both buffer are of the same maximum size, and the source is null terminated
@ -1352,23 +1368,24 @@ static void* loc_eng_process_deferred_action (void* arg)
LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n"); LOGD("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 (loc_eng_data.deferred_action_thread_need_exit == FALSE) while (1)
{ {
GpsAidingData aiding_data_for_deletion; GpsAidingData aiding_data_for_deletion;
GpsStatusValue engine_status; GpsStatusValue engine_status;
boolean data_connection_succeeded;
boolean data_connection_closed;
boolean data_connection_failed;
rpc_loc_event_mask_type loc_event; rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type loc_event_payload; rpc_loc_event_payload_u_type loc_event_payload;
// Wait until we are signalled to do a deferred action, or exit // Wait until we are signalled to do a deferred action, or exit
pthread_mutex_lock(&loc_eng_data.deferred_action_mutex); pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
if (loc_eng_data.deferred_action_flags == 0)
loc_eng_data.release_wakelock_cb();
pthread_cond_wait(&loc_eng_data.deferred_action_cond, pthread_cond_wait(&loc_eng_data.deferred_action_cond,
&loc_eng_data.deferred_action_mutex); &loc_eng_data.deferred_action_mutex);
if (loc_eng_data.deferred_action_thread_need_exit == TRUE) if (loc_eng_data.deferred_action_flags & DEFERRED_ACTION_QUIT)
{ {
pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex); pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
break; break;
@ -1381,16 +1398,12 @@ static void* loc_eng_process_deferred_action (void* arg)
loc_eng_data.loc_event = 0; 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; engine_status = loc_eng_data.agps_status;
aiding_data_for_deletion = loc_eng_data.aiding_data_for_deletion; aiding_data_for_deletion = loc_eng_data.aiding_data_for_deletion;
status.status = loc_eng_data.agps_status; status.status = loc_eng_data.agps_status;
loc_eng_data.agps_status = 0; loc_eng_data.agps_status = 0;
data_connection_succeeded = loc_eng_data.data_connection_succeeded;
data_connection_closed = loc_eng_data.data_connection_closed;
data_connection_failed = loc_eng_data.data_connection_failed;
loc_eng_data.data_connection_closed = FALSE;
loc_eng_data.data_connection_succeeded = FALSE;
loc_eng_data.data_connection_failed = FALSE;
// perform all actions after releasing the mutex to avoid blocking RPCs from the ARM9 // perform all actions after releasing the mutex to avoid blocking RPCs from the ARM9
pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex)); pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
@ -1405,15 +1418,16 @@ static void* loc_eng_process_deferred_action (void* arg)
loc_eng_delete_aiding_data_deferred_action (); loc_eng_delete_aiding_data_deferred_action ();
} }
if (data_connection_succeeded || data_connection_closed || data_connection_failed) if (flags & (DEFERRED_ACTION_AGPS_DATA_SUCCESS |
DEFERRED_ACTION_AGPS_DATA_CLOSED |
DEFERRED_ACTION_AGPS_DATA_FAILED))
{ {
loc_eng_process_atl_deferred_action(data_connection_succeeded, data_connection_closed); loc_eng_process_atl_deferred_action(flags);
} }
if (status.status != 0 && loc_eng_data.agps_status_cb) { if (status.status != 0 && loc_eng_data.agps_status_cb) {
loc_eng_data.agps_status_cb(&status); loc_eng_data.agps_status_cb(&status);
} }
} }
// reenable the GPS lock // reenable the GPS lock
@ -1421,6 +1435,7 @@ static void* loc_eng_process_deferred_action (void* arg)
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"); LOGD("loc_eng_process_deferred_action thread exiting\n");
loc_eng_data.release_wakelock_cb();
return NULL; return NULL;
} }

60
loc_api/libloc_api/loc_eng.h
View file

@ -51,52 +51,62 @@ typedef unsigned char boolean;
#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds #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 // Module data
typedef struct typedef struct
{ {
rpc_loc_client_handle_type client_handle; rpc_loc_client_handle_type client_handle;
gps_location_callback location_cb; gps_location_callback location_cb;
gps_status_callback status_cb; gps_status_callback status_cb;
gps_sv_status_callback sv_status_cb; gps_sv_status_callback sv_status_cb;
agps_status_callback agps_status_cb; agps_status_callback agps_status_cb;
gps_nmea_callback nmea_cb; gps_nmea_callback nmea_cb;
gps_ni_notify_callback ni_notify_cb; gps_ni_notify_callback ni_notify_cb;
int agps_status; gps_acquire_wakelock acquire_wakelock_cb;
gps_release_wakelock release_wakelock_cb;
int agps_status;
loc_eng_xtra_data_s_type xtra_module_data; loc_eng_xtra_data_s_type xtra_module_data;
loc_eng_ioctl_data_s_type ioctl_data; loc_eng_ioctl_data_s_type ioctl_data;
// data from loc_event_cb // data from loc_event_cb
rpc_loc_event_mask_type loc_event; rpc_loc_event_mask_type loc_event;
rpc_loc_event_payload_u_type loc_event_payload; rpc_loc_event_payload_u_type loc_event_payload;
boolean data_connection_succeeded;
boolean data_connection_closed;
boolean data_connection_failed;
// TBD: // TBD:
char agps_server_host[256]; char agps_server_host[256];
int agps_server_port; int agps_server_port;
uint32 agps_server_address; uint32 agps_server_address;
char apn_name[100]; char apn_name[100];
int position_mode; int position_mode;
rpc_loc_server_connection_handle conn_handle; rpc_loc_server_connection_handle conn_handle;
// GPS engine status // GPS engine status
GpsStatusValue engine_status; GpsStatusValue engine_status;
// Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
GpsAidingData aiding_data_for_deletion; GpsAidingData aiding_data_for_deletion;
// Data variables used by deferred action thread // Data variables used by deferred action thread
pthread_t deferred_action_thread; pthread_t deferred_action_thread;
// Signal deferred action thread to exit
boolean deferred_action_thread_need_exit;
// Mutex used by deferred action thread // Mutex used by deferred action thread
pthread_mutex_t deferred_action_mutex; pthread_mutex_t deferred_action_mutex;
// Condition variable used by deferred action thread // Condition variable used by deferred action thread
pthread_cond_t deferred_action_cond; pthread_cond_t deferred_action_cond;
// flags for pending events for deferred action thread
int deferred_action_flags;
} loc_eng_data_s_type; } loc_eng_data_s_type;
extern loc_eng_data_s_type loc_eng_data; extern loc_eng_data_s_type loc_eng_data;