* because legacy API is not supported anymoyre, cb_type is unnecessary.
Change-Id: I723c28555c1d08106d9b21e3bc332c7c3056a179
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>
static void clean_up(void);
static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, sensor_rep &cur_rep);
static void restore_session(void);
-static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, int cb_type, void* cb, void *user_data);
+static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, void* cb, void *user_data);
class initiator {
public:
}
-static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, int cb_type, void* cb, void *user_data)
+static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, void* cb, void *user_data)
{
sensor_id_t sensor_id;
sensor_rep prev_rep, cur_rep;
handle, interval, max_batch_latency, cb, user_data);
sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
- sensor_client_info::get_instance().register_event(handle, event_type, interval, max_batch_latency, cb_type, cb, user_data);
+ sensor_client_info::get_instance().register_event(handle, event_type, interval, max_batch_latency, cb, user_data);
sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
API bool sensord_register_event(int handle, unsigned int event_type, unsigned int interval, unsigned int max_batch_latency, sensor_cb_t cb, void *user_data)
{
- return register_event(handle, event_type, interval, max_batch_latency, SENSOR_EVENT_CB, (void *)cb, user_data);
+ return register_event(handle, event_type, interval, max_batch_latency, (void *)cb, user_data);
}
-API bool sensord_register_hub_event(int handle, unsigned int event_type, unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
-{
- return register_event(handle, event_type, interval, max_batch_latency, SENSORHUB_EVENT_CB, (void *)cb, user_data);
-}
-
-
API bool sensord_unregister_event(int handle, unsigned int event_type)
{
sensor_id_t sensor_id;
sensor_rep prev_rep, cur_rep;
bool ret;
unsigned int prev_interval, prev_latency;
- int prev_cb_type;
void *prev_cb;
void *prev_user_data;
event_type, get_sensor_name(sensor_id), handle);
sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
- sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data);
+ sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
if (!sensor_client_info::get_instance().unregister_event(handle, event_type)) {
_E("%s try to unregister non registered event %s[%#x] for sensor %s[%d]",
ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
if (!ret)
- sensor_client_info::get_instance().register_event(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data);
+ sensor_client_info::get_instance().register_event(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
return ret;
sensor_rep prev_rep, cur_rep;
bool ret;
unsigned int prev_interval, prev_latency;
- int prev_cb_type;
void *prev_cb;
void *prev_user_data;
sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
- sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data);
+ sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
if (!sensor_client_info::get_instance().set_event_batch(handle, event_type, interval, latency))
return false;
API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
{
unsigned int prev_interval, prev_latency;
- int prev_cb_type;
void *prev_cb;
void *prev_user_data;
AUTOLOCK(lock);
- if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) {
+ if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data)) {
_E("Failed to get event info with handle = %d, event_type = %#x", handle, event_type);
return false;
}
API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_type, unsigned int max_batch_latency)
{
unsigned int prev_interval, prev_latency;
- int prev_cb_type;
void *prev_cb;
void *prev_user_data;
AUTOLOCK(lock);
- if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb_type, prev_cb, prev_user_data)) {
+ if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data)) {
_E("Failed to get event info with handle = %d, event_type = %#x", handle, event_type);
return false;
}
return true;
}
+
+API bool sensord_register_hub_event(int handle, unsigned int event_type, unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
+{
+ return false;
+}
+
#include <sensor_common.h>
-typedef enum {
- SENSOR_EVENT_CB,
- SENSORHUB_EVENT_CB,
- SENSOR_LEGACY_CB,
-} event_cb_type_t;
-
class reg_event_info {
public:
unsigned long long m_id;
unsigned int type;
unsigned int m_interval;
unsigned int m_latency;
- int m_cb_type;
void *m_cb;
void *m_user_data;
unsigned long long m_previous_event_time;
reg_event_info()
: m_id(0), m_handle(-1),
type(0), m_interval(POLL_1HZ_MS), m_latency(0),
- m_cb_type(SENSOR_EVENT_CB), m_cb(NULL), m_user_data(NULL),
+ m_cb(NULL), m_user_data(NULL),
m_previous_event_time(0), m_fired(false) {}
~reg_event_info() {}
}
bool sensor_client_info::register_event(int handle, unsigned int event_type,
- unsigned int interval, unsigned int latency, int cb_type, void *cb, void* user_data)
+ unsigned int interval, unsigned int latency, void *cb, void* user_data)
{
AUTOLOCK(m_handle_info_lock);
return false;
}
- if (!it_handle->second.add_reg_event_info(event_type, interval, latency, cb_type, cb, user_data))
+ if (!it_handle->second.add_reg_event_info(event_type, interval, latency, cb, user_data))
return false;
return true;
return true;
}
-bool sensor_client_info::get_event_info(int handle, unsigned int event_type, unsigned int &interval, unsigned int &latency, int &cb_type, void* &cb, void* &user_data)
+bool sensor_client_info::get_event_info(int handle, unsigned int event_type, unsigned int &interval, unsigned int &latency, void* &cb, void* &user_data)
{
AUTOLOCK(m_handle_info_lock);
interval = event_info->m_interval;
- cb_type = event_info->m_cb_type;
cb = event_info->m_cb;
user_data = event_info->m_user_data;
latency = event_info->m_latency;
int create_handle(sensor_id_t sensor_id);
bool delete_handle(int handle);
bool register_event(int handle, unsigned int event_type,
- unsigned int interval, unsigned int latency, int cb_type, void *cb, void* user_data);
+ unsigned int interval, unsigned int latency, void *cb, void* user_data);
bool unregister_event(int handle, unsigned int event_type);
bool register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void* user_data);
bool set_event_batch(int handle, unsigned int event_type, unsigned int interval, unsigned int latency);
bool set_accuracy(int handle, int accuracy);
bool set_bad_accuracy(int handle, int bad_accuracy);
- bool get_event_info(int handle, unsigned int event_type, unsigned int &interval, unsigned int &latency, int &cb_type, void* &cb, void* &user_data);
+ bool get_event_info(int handle, unsigned int event_type, unsigned int &interval, unsigned int &latency, void* &cb, void* &user_data);
void get_listening_sensors(sensor_id_vector &sensors);
void get_sensor_rep(sensor_id_t sensor, sensor_rep& rep);
cal_event_info = handle_info.get_reg_event_info(cal_event_type);
if ((accuracy == SENSOR_ACCURACY_BAD) && !handle_info.m_bad_accuracy && cal_event_info) {
- sensor_event_data_t cal_event_data;
void *cal_sensor_data;
cal_event_info->m_previous_event_time = time;
if (!event_info)
return NULL;
- if (event_info->m_cb_type == SENSOR_LEGACY_CB) {
- cal_event_data.event_data = (void *)&(accuracy);
- cal_event_data.event_data_size = sizeof(accuracy);
- cal_sensor_data = &cal_event_data;
- } else {
- sensor_data_t *cal_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));
- retvm_if(!cal_data, NULL, "Failed to allocate memory");
-
- cal_data->accuracy = accuracy;
- cal_data->timestamp = time;
- cal_data->values[0] = accuracy;
- cal_data->value_count = 1;
- cal_sensor_data = cal_data;
- }
+ sensor_data_t *cal_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));
+ retvm_if(!cal_data, NULL, "Failed to allocate memory");
+
+ cal_data->accuracy = accuracy;
+ cal_data->timestamp = time;
+ cal_data->values[0] = accuracy;
+ cal_data->value_count = 1;
+ cal_sensor_data = cal_data;
cal_callback_info = get_callback_info(handle_info.m_sensor_id, cal_event_info, cal_sensor_data);
{
unsigned long long cur_time;
reg_event_info *event_info = NULL;
- sensor_event_data_t event_data;
sensor_id_t sensor_id;
sensor_handle_info_map handles_info;
void *sensor_data;
- sensor_panning_data_t panning_data;
- int single_state_event_data = 0;
-
int accuracy = SENSOR_ACCURACY_GOOD;
unsigned int event_type = *((unsigned int *)(event));
cur_time = sensor_event->data->timestamp;
accuracy = sensor_event->data->accuracy;
- if (is_single_state_event(event_type)) {
- single_state_event_data = (int) sensor_event->data->values[0];
- event_data.event_data = (void *)&(single_state_event_data);
- event_data.event_data_size = sizeof(single_state_event_data);
- } else if (is_panning_event(event_type)) {
- panning_data.x = (int)sensor_event->data->values[0];
- panning_data.y = (int)sensor_event->data->values[1];
- event_data.event_data = (void *)&panning_data;
- event_data.event_data_size = sizeof(panning_data);
- } else {
- event_data.event_data = &(sensor_event->data);
- event_data.event_data_size = sizeof(sensor_event->data);
- }
-
{ /* scope for the lock */
m_client_info.get_all_handle_info(handles_info);
if (cal_callback_info)
client_callback_infos.push_back(cal_callback_info);
- if (event_info->m_cb_type == SENSOR_LEGACY_CB)
- callback_info = get_callback_info(sensor_id, event_info, &event_data);
- else
- callback_info = get_callback_info(sensor_id, event_info, sensor_data);
+ callback_info = get_callback_info(sensor_id, event_info, sensor_data);
if (!callback_info) {
_E("Failed to get callback_info");
callback_info->sensor = sensor_info_to_sensor(sensor_info_manager::get_instance().get_info(sensor_id));
callback_info->event_id = event_info->m_id;
callback_info->handle = event_info->m_handle;
- callback_info->cb_type = event_info->m_cb_type;
callback_info->cb = event_info->m_cb;
callback_info->event_type = event_info->type;
callback_info->user_data = event_info->m_user_data;
{
client_callback_info *cb_info = (client_callback_info*) data;
- if (sensor_event_listener::get_instance().is_valid_callback(cb_info)) {
- if (cb_info->accuracy_cb)
- cb_info->accuracy_cb(cb_info->sensor, cb_info->timestamp, cb_info->accuracy, cb_info->accuracy_user_data);
-
- if (cb_info->cb_type == SENSOR_EVENT_CB)
- ((sensor_cb_t) cb_info->cb)(cb_info->sensor, cb_info->event_type, (sensor_data_t *) cb_info->sensor_data, cb_info->user_data);
- else if (cb_info->cb_type == SENSORHUB_EVENT_CB)
- ((sensorhub_cb_t) cb_info->cb)(cb_info->sensor, cb_info->event_type, (sensorhub_data_t *) cb_info->sensor_data, cb_info->user_data);
- else if (cb_info->cb_type == SENSOR_LEGACY_CB)
- ((sensor_legacy_cb_t) cb_info->cb)(cb_info->event_type, (sensor_event_data_t *) cb_info->sensor_data, cb_info->user_data);
- } else {
+ if (!sensor_event_listener::get_instance().is_valid_callback(cb_info)) {
_W("Discard invalid callback cb(%#x)(%s, %#x, %#x) with id: %llu",
cb_info->cb, get_event_name(cb_info->event_type), cb_info->sensor_data,
cb_info->user_data, cb_info->event_id);
- }
- if (cb_info->cb_type == SENSOR_LEGACY_CB) {
- sensor_event_data_t *data = (sensor_event_data_t *) cb_info->sensor_data;
- delete[] (char *)data->event_data;
+ free(cb_info->sensor_data);
+ delete cb_info;
+ return false;
}
+ if (cb_info->accuracy_cb)
+ cb_info->accuracy_cb(cb_info->sensor, cb_info->timestamp, cb_info->accuracy, cb_info->accuracy_user_data);
+
+ ((sensor_cb_t) cb_info->cb)(cb_info->sensor, cb_info->event_type, (sensor_data_t *) cb_info->sensor_data, cb_info->user_data);
+
free(cb_info->sensor_data);
delete cb_info;
return false;
}
-
-
ssize_t sensor_event_listener::sensor_event_poll(void* buffer, int buffer_len, struct epoll_event &event)
{
ssize_t len;
int handle;
sensor_t sensor;
unsigned int event_type;
- int cb_type;
void *cb;
void *sensor_data;
void *user_data;
}
}
-bool sensor_handle_info::add_reg_event_info(unsigned int event_type, unsigned int interval, unsigned int latency, int cb_type, void *cb, void *user_data)
+bool sensor_handle_info::add_reg_event_info(unsigned int event_type, unsigned int interval, unsigned int latency, void *cb, void *user_data)
{
reg_event_info event_info;
event_info.type = event_type;
event_info.m_interval = interval;
event_info.m_latency = latency;
- event_info.m_cb_type = cb_type;
event_info.m_cb = cb;
event_info.m_user_data = user_data;
sensor_handle_info();
~sensor_handle_info();
- bool add_reg_event_info(unsigned int event_type, unsigned int interval, unsigned int latency, int cb_type, void *cb,void *user_data);
+ bool add_reg_event_info(unsigned int event_type, unsigned int interval, unsigned int latency, void *cb, void *user_data);
bool delete_reg_event_info(unsigned int event_type);
bool change_reg_event_batch(unsigned int event_type, unsigned int interval, unsigned int latency);