src/server/sensor_event_dispatcher.cpp

   1 /*
   2  * libsensord-share
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <command_common.h>
  21 #include <sensor_event_dispatcher.h>
  22 #include <sensor_log.h>
  23 #include <thread>
  24
  25 using std::thread;
  26 using std::vector;
  27 using std::pair;
  28
  29 #define MAX_PENDING_CONNECTION 32
  30
  31 sensor_event_dispatcher::sensor_event_dispatcher()
  32 : m_lcd_on(false)
  33 {
  34 }
  35
  36 sensor_event_dispatcher::~sensor_event_dispatcher() { }
  37
  38
  39 sensor_event_dispatcher& sensor_event_dispatcher::get_instance()
  40 {
  41         static sensor_event_dispatcher inst;
  42         return inst;
  43 }
  44
  45 bool sensor_event_dispatcher::run(void)
  46 {
  47         thread dispatcher(&sensor_event_dispatcher::dispatch_event, this);
  48         dispatcher.detach();
  49
  50         return true;
  51 }
  52
  53 void sensor_event_dispatcher::accept_event_channel(csocket client_socket)
  54 {
  55         int client_id;
  56         event_channel_ready_t event_channel_ready;
  57         client_info_manager& client_info_manager = get_client_info_manager();
  58
  59         client_socket.set_connection_mode();
  60
  61         if (client_socket.recv(&client_id, sizeof(client_id)) <= 0) {
  62                 _E("Failed to receive client id on socket fd[%d]", client_socket.get_socket_fd());
  63                 return;
  64         }
  65
  66         client_socket.set_transfer_mode();
  67
  68         if(!get_client_info_manager().set_event_socket(client_id, client_socket)) {
  69                 _E("Failed to store event socket[%d] for %s", client_socket.get_socket_fd(),
  70                         client_info_manager.get_client_info(client_id));
  71                 return;
  72         }
  73
  74         event_channel_ready.magic = EVENT_CHANNEL_MAGIC;
  75         event_channel_ready.client_id = client_id;
  76
  77         _I("Event channel is accepted for %s on socket[%d]",
  78                 client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
  79
  80         if (client_socket.send(&event_channel_ready, sizeof(event_channel_ready)) <= 0) {
  81                 _E("Failed to send event_channel_ready packet to %s on socket fd[%d]",
  82                         client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
  83                 return;
  84         }
  85 }
  86
  87 void sensor_event_dispatcher::accept_event_connections(csocket client_socket)
  88 {
  89         thread event_channel_creator(&sensor_event_dispatcher::accept_event_channel, this, client_socket);
  90         event_channel_creator.detach();
  91 }
  92
  93 void sensor_event_dispatcher::dispatch_event(void)
  94 {
  95         const int MAX_SYNTH_PER_SENSOR = 5;
  96
  97         vector<sensor_event_t> v_sensor_events(MAX_SYNTH_PER_SENSOR);
  98
  99         _I("Event Dispatcher started");
 100
 101         while (true) {
 102                 void *seed_event = get_event_queue().pop();
 103
 104                 vector<void *> sensor_events;
 105                 sensor_events.push_back(seed_event);
 106
 107                 virtual_sensors v_sensors = get_active_virtual_sensors();
 108
 109                 auto it_v_sensor = v_sensors.begin();
 110
 111                 while (it_v_sensor != v_sensors.end()) {
 112                         int synthesized_cnt;
 113                         v_sensor_events.clear();
 114                         (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event));
 115                         synthesized_cnt = v_sensor_events.size();
 116
 117                         for (int i = 0; i < synthesized_cnt; ++i) {
 118                                 sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t));
 119                                 if (!v_event) {
 120                                         _E("Failed to allocate memory");
 121                                         continue;
 122                                 }
 123
 124                                 memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t));
 125                                 sensor_events.push_back(v_event);
 126                         }
 127
 128                         ++it_v_sensor;
 129                 }
 130
 131                 sort_sensor_events(sensor_events);
 132
 133                 for (unsigned int i = 0; i < sensor_events.size(); ++i) {
 134                         if (is_record_event(((sensor_event_t *)(sensor_events[i]))->event_type))
 135                                 put_last_event(((sensor_event_t *)(sensor_events[i]))->event_type, *((sensor_event_t *)(sensor_events[i])));
 136                 }
 137
 138                 send_sensor_events(sensor_events);
 139         }
 140 }
 141
 142
 143 void sensor_event_dispatcher::send_sensor_events(vector<void *> &events)
 144 {
 145         void *event;
 146         sensor_event_t *sensor_events = NULL;
 147         client_info_manager& client_info_manager = get_client_info_manager();
 148
 149         const int RESERVED_CLIENT_CNT = 20;
 150         static client_id_vec id_vec(RESERVED_CLIENT_CNT);
 151
 152         for (unsigned int i = 0; i < events.size(); ++i) {
 153                 sensor_id_t sensor_id;
 154                 unsigned int event_type;
 155                 int length;
 156
 157                 sensor_events = (sensor_event_t*)events[i];
 158                 length = sizeof(sensor_event_t) + sensor_events->data_length;
 159                 sensor_id = sensor_events->sensor_id;
 160                 event_type = sensor_events->event_type;
 161
 162                 event = (void *)malloc(length);
 163                 if (!event) {
 164                         _E("Failed to allocate memory");
 165                         return;
 166                 }
 167
 168                 memcpy(event, sensor_events, sizeof(sensor_event_t));
 169                 memcpy((char *)event + sizeof(sensor_event_t), sensor_events->data, sensor_events->data_length);
 170
 171                 id_vec.clear();
 172                 client_info_manager.get_listener_ids(sensor_id, event_type, id_vec);
 173
 174                 auto it_client_id = id_vec.begin();
 175
 176                 while (it_client_id != id_vec.end()) {
 177                         csocket client_socket;
 178                         client_info_manager.get_event_socket(*it_client_id, client_socket);
 179                         bool ret = (client_socket.send(event, length) > 0);
 180
 181                         if (ret)
 182                                 _D("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
 183                         else
 184                                 _E("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
 185
 186                         ++it_client_id;
 187                 }
 188
 189                 free(sensor_events->data);
 190                 free(sensor_events);
 191         }
 192 }
 193
 194 client_info_manager& sensor_event_dispatcher::get_client_info_manager(void)
 195 {
 196         return client_info_manager::get_instance();
 197 }
 198
 199 sensor_event_queue& sensor_event_dispatcher::get_event_queue(void)
 200 {
 201         return sensor_event_queue::get_instance();
 202 }
 203
 204 bool sensor_event_dispatcher::is_record_event(unsigned int event_type)
 205 {
 206         return false;
 207 }
 208
 209 void sensor_event_dispatcher::put_last_event(unsigned int event_type, const sensor_event_t &event)
 210 {
 211         AUTOLOCK(m_last_events_mutex);
 212         m_last_events[event_type] = event;
 213 }
 214
 215 bool sensor_event_dispatcher::get_last_event(unsigned int event_type, sensor_event_t &event)
 216 {
 217         AUTOLOCK(m_last_events_mutex);
 218
 219         auto it_event = m_last_events.find(event_type);
 220
 221         if (it_event == m_last_events.end())
 222                 return false;
 223
 224         event = it_event->second;
 225         return true;
 226 }
 227
 228 bool sensor_event_dispatcher::has_active_virtual_sensor(virtual_sensor *sensor)
 229 {
 230         AUTOLOCK(m_active_virtual_sensors_mutex);
 231
 232         auto it_v_sensor = find(m_active_virtual_sensors.begin(), m_active_virtual_sensors.end(), sensor);
 233
 234         return (it_v_sensor != m_active_virtual_sensors.end());
 235 }
 236
 237
 238 virtual_sensors sensor_event_dispatcher::get_active_virtual_sensors(void)
 239 {
 240         AUTOLOCK(m_active_virtual_sensors_mutex);
 241
 242         return m_active_virtual_sensors;
 243 }
 244
 245 struct sort_comp {
 246         bool operator()(const void *left, const void *right) {
 247                 return ((sensor_event_t *)left)->data->timestamp < ((sensor_event_t *)right)->data->timestamp;
 248         }
 249 };
 250
 251 void sensor_event_dispatcher::sort_sensor_events(vector<void *> &events)
 252 {
 253         std::sort(events.begin(), events.end(), sort_comp());
 254 }
 255
 256 void sensor_event_dispatcher::request_last_event(int client_id, sensor_id_t sensor_id)
 257 {
 258         client_info_manager& client_info_manager = get_client_info_manager();
 259         event_type_vector event_vec;
 260         csocket client_socket;
 261
 262         if (client_info_manager.get_registered_events(client_id, sensor_id, event_vec)) {
 263                 if (!client_info_manager.get_event_socket(client_id, client_socket)) {
 264                         _E("Failed to get event socket from %s",
 265                                         client_info_manager.get_client_info(client_id));
 266                         return;
 267                 }
 268
 269                 auto it_event = event_vec.begin();
 270                 while (it_event != event_vec.end()) {
 271                         sensor_event_t event;
 272                         if (is_record_event(*it_event) && get_last_event(*it_event, event)) {
 273                                 if (client_socket.send(&event, sizeof(event)) > 0)
 274                                         _I("Send the last event[0x%x] to %s on socket[%d]", event.event_type,
 275                                                 client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
 276                                 else
 277                                         _E("Failed to send event[0x%x] to %s on socket[%d]", event.event_type,
 278                                                 client_info_manager.get_client_info(client_id), client_socket.get_socket_fd());
 279                         }
 280                         ++it_event;
 281                 }
 282         }
 283 }
 284
 285
 286 bool sensor_event_dispatcher::add_active_virtual_sensor(virtual_sensor * sensor)
 287 {
 288         AUTOLOCK(m_active_virtual_sensors_mutex);
 289
 290         if (has_active_virtual_sensor(sensor)) {
 291                 _E("[%s] sensor is already added on active virtual sensors", sensor->get_name());
 292                 return false;
 293         }
 294
 295         m_active_virtual_sensors.push_back(sensor);
 296
 297         return true;
 298 }
 299
 300 bool sensor_event_dispatcher::delete_active_virtual_sensor(virtual_sensor * sensor)
 301 {
 302         AUTOLOCK(m_active_virtual_sensors_mutex);
 303
 304         auto it_v_sensor = find(m_active_virtual_sensors.begin(), m_active_virtual_sensors.end(), sensor);
 305
 306         if (it_v_sensor == m_active_virtual_sensors.end()) {
 307                 _E("Fail to delete non-existent [%s] sensor on active virtual sensors", sensor->get_name());
 308                 return false;
 309         }
 310
 311         m_active_virtual_sensors.erase(it_v_sensor);
 312
 313         return true;
 314 }