c17d90dd002b75ad2d69d1c825ce99d553328fad
[framework/location/libslp-lbs-plugin-replay.git] / replay-plugin / src / gps_plugin_replay.c
1 /*
2  * GPS manager replay plugin
3  *
4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
5  *
6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Yunhan Kim <yhan.kim@samsung.com>,
7  *          Genie Kim <daejins.kim@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  * http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <glib.h>
26 #include <errno.h>
27 #include <sys/time.h>
28
29 #include <gps_manager_plugin_intf.h>
30
31 #include "gps_plugin_debug.h"
32 #include "nmea_parser.h"
33 #include "setting.h"
34
35 #define REPLAY_NMEA_SET_SIZE            4096
36 #define REPLAY_NMEA_SENTENCE_SIZE       128
37
38 gps_event_cb g_gps_event_cb = NULL;
39
40 typedef struct {
41         FILE *fd;
42         int interval;
43         int replay_mode;
44
45         pos_data_t *pos_data;
46         sv_data_t *sv_data;
47         nmea_data_t *nmea_data;
48
49         GSource *timeout_src;
50         GMainContext *default_context;
51 } replay_timeout;
52
53 replay_timeout *g_replay_timer = NULL;
54
55 int gps_plugin_replay_gps_init(gps_event_cb gps_event_cb, gps_server_param_t * gps_params);
56 int gps_plugin_replay_gps_deinit(gps_failure_reason_t * reason_code);
57 int gps_plugin_replay_gps_request(gps_action_t gps_action, void *data, gps_failure_reason_t * reason_code);
58
59 static const gps_plugin_interface g_gps_plugin_replay_interface = {
60         gps_plugin_replay_gps_init,
61         gps_plugin_replay_gps_deinit,
62         gps_plugin_replay_gps_request
63 };
64
65 void gps_plugin_replay_pos_event(pos_data_t * data)
66 {
67         gps_event_info_t gps_event;
68         time_t timestamp;
69
70         memset(&gps_event, 0, sizeof(gps_event_info_t));
71         time(&timestamp);
72
73         gps_event.event_id = GPS_EVENT_REPORT_POSITION;
74
75         if (data == NULL) {
76                 LOG_PLUGIN(DBG_ERR, "NULL POS data.");
77                 gps_event.event_data.pos_ind.error = GPS_ERR_COMMUNICATION;
78         } else {
79                 gps_event.event_data.pos_ind.error = GPS_ERR_NONE;
80                 gps_event.event_data.pos_ind.pos.timestamp = timestamp;
81                 gps_event.event_data.pos_ind.pos.latitude = data->latitude;
82                 gps_event.event_data.pos_ind.pos.longitude = data->longitude;
83                 gps_event.event_data.pos_ind.pos.altitude = data->altitude;
84                 gps_event.event_data.pos_ind.pos.speed = data->speed;
85                 gps_event.event_data.pos_ind.pos.bearing = data->bearing;
86                 gps_event.event_data.pos_ind.pos.hor_accuracy = data->hor_accuracy;
87                 gps_event.event_data.pos_ind.pos.ver_accuracy = data->ver_accuracy;
88         }
89
90         //LOG_PLUGIN(DBG_LOW, "%d / %f / %f / %f", gps_event.event_data.pos_ind.pos.timestamp, gps_event.event_data.pos_ind.pos.latitude, gps_event.event_data.pos_ind.pos.longitude, gps_event.event_data.pos_ind.pos.altitude);
91
92         if (g_gps_event_cb != NULL) {
93                 g_gps_event_cb(&gps_event);
94         }
95 }
96
97 void gps_plugin_replay_sv_event(sv_data_t * data)
98 {
99         int i;
100         gps_event_info_t gps_event;
101         time_t timestamp;
102
103         memset(&gps_event, 0, sizeof(gps_event_info_t));
104         time(&timestamp);
105         gps_event.event_id = GPS_EVENT_REPORT_SATELLITE;
106
107         if (data == NULL) {
108                 LOG_PLUGIN(DBG_ERR, "NULL SV data.");
109                 gps_event.event_data.sv_ind.error = GPS_ERR_COMMUNICATION;
110         } else {
111                 gps_event.event_data.sv_ind.error = GPS_ERR_NONE;
112                 gps_event.event_data.sv_ind.sv.timestamp = timestamp;
113                 gps_event.event_data.sv_ind.sv.pos_valid = data->pos_valid;
114                 gps_event.event_data.sv_ind.sv.num_of_sat = data->num_of_sat;
115                 for (i = 0; i < data->num_of_sat; i++) {
116                         gps_event.event_data.sv_ind.sv.sat[i].used = data->sat[i].used;
117                         gps_event.event_data.sv_ind.sv.sat[i].prn = data->sat[i].prn;
118                         gps_event.event_data.sv_ind.sv.sat[i].snr = data->sat[i].snr;
119                         gps_event.event_data.sv_ind.sv.sat[i].elevation = data->sat[i].elevation;
120                         gps_event.event_data.sv_ind.sv.sat[i].azimuth = data->sat[i].azimuth;
121                 }
122         }
123
124         if (g_gps_event_cb != NULL) {
125                 g_gps_event_cb(&gps_event);
126         }
127 }
128
129 void gps_plugin_replay_nmea_event(nmea_data_t * data)
130 {
131         gps_event_info_t gps_event;
132         time_t timestamp;
133
134         memset(&gps_event, 0, sizeof(gps_event_info_t));
135         time(&timestamp);
136
137         gps_event.event_id = GPS_EVENT_REPORT_NMEA;
138
139         if (data == NULL) {
140                 LOG_PLUGIN(DBG_ERR, "NULL NMEA data.");
141                 gps_event.event_data.nmea_ind.error = GPS_ERR_COMMUNICATION;
142         } else {
143                 if (data->len > REPLAY_NMEA_SENTENCE_SIZE) {
144                         LOG_PLUGIN(DBG_WARN, "The Size of NMEA[ %d ] is larger then max ", data->len);
145                         data->len = REPLAY_NMEA_SENTENCE_SIZE;
146                         gps_event.event_data.nmea_ind.error = GPS_ERR_COMMUNICATION;
147                 } else {
148                         gps_event.event_data.nmea_ind.error = GPS_ERR_NONE;
149                 }
150                 gps_event.event_data.nmea_ind.nmea.timestamp = timestamp;
151                 gps_event.event_data.nmea_ind.nmea.len = data->len;
152                 gps_event.event_data.nmea_ind.nmea.data = (char *)malloc(data->len);
153                 memset(gps_event.event_data.nmea_ind.nmea.data, 0x00, data->len);
154                 memcpy(gps_event.event_data.nmea_ind.nmea.data, data->data, data->len);
155                 //LOG_PLUGIN(DBG_LOW, "NMEA[%d] : %s", gps_event.event_data.nmea_ind.nmea.len, gps_event.event_data.nmea_ind.nmea.data);
156         }
157
158         if (g_gps_event_cb != NULL) {
159                 g_gps_event_cb(&gps_event);
160         }
161
162         if (gps_event.event_data.nmea_ind.nmea.data != NULL) {
163                 free(gps_event.event_data.nmea_ind.nmea.data);
164                 gps_event.event_data.nmea_ind.nmea.data = NULL;
165         }
166 }
167
168 void gps_plugin_respond_start_session(gboolean ret)
169 {
170         gps_event_info_t gps_event;
171         gps_event.event_id = GPS_EVENT_START_SESSION;
172
173         if (ret == TRUE) {
174                 gps_event.event_data.start_session_rsp.error = GPS_ERR_NONE;
175         } else {
176                 gps_event.event_data.start_session_rsp.error = GPS_ERR_COMMUNICATION;
177         }
178
179         if (g_gps_event_cb != NULL) {
180                 g_gps_event_cb(&gps_event);
181         }
182 }
183
184 void gps_plugin_respond_stop_session(void)
185 {
186         gps_event_info_t gps_event;
187
188         gps_event.event_id = GPS_EVENT_STOP_SESSION;
189         gps_event.event_data.stop_session_rsp.error = GPS_ERR_NONE;
190
191         if (g_gps_event_cb != NULL) {
192                 g_gps_event_cb(&gps_event);
193         }
194 }
195
196 gboolean gps_plugin_replay_read_nmea(replay_timeout * timer, char *nmea_data)
197 {
198         gboolean ret = FALSE;
199         int ref = 0;
200         char buf[REPLAY_NMEA_SENTENCE_SIZE] = { 0, };
201
202         if (timer->fd == NULL) {
203                 LOG_PLUGIN(DBG_ERR, "nmea fd is NULL");
204                 return FALSE;
205         }
206
207         if (nmea_data == NULL) {
208                 LOG_PLUGIN(DBG_ERR, "nmea_data is NULL");
209                 fclose(timer->fd);
210                 timer->fd = NULL;
211                 return FALSE;
212         }
213
214         while (fgets(buf, REPLAY_NMEA_SENTENCE_SIZE, timer->fd) != NULL) {
215                 if (strncmp(buf, "$GPGGA", 6) == 0) {
216                         ref++;
217                         if (ref > 1) {
218                                 fseek(timer->fd, -strlen(buf), SEEK_CUR);
219                                 LOG_PLUGIN(DBG_LOW, "2nd GPGGA : stop to read nmea data");
220                                 ret = TRUE;
221                                 break;
222                         } else if (ref == 1) {
223                                 LOG_PLUGIN(DBG_LOW, "1st GPGGA : start to read nmea data");
224                                 strncpy(nmea_data, buf, strlen(buf));
225                         }
226                 } else {
227                         if (strlen(nmea_data) + strlen(buf) > REPLAY_NMEA_SET_SIZE) {
228                                 LOG_PLUGIN(DBG_ERR, "read nmea data size is too long");
229                                 break;
230                         } else {
231                                 strncat(nmea_data, buf, strlen(buf));
232                         }
233                 }
234                 timer->nmea_data->len = strlen(buf);
235                 timer->nmea_data->data = buf;
236                 gps_plugin_replay_nmea_event(timer->nmea_data);
237         }
238
239         if (feof(timer->fd)) {
240                 LOG_PLUGIN(DBG_ERR, "end of file");
241                 rewind(timer->fd);
242                 ret = TRUE;
243         } else {
244                 LOG_PLUGIN(DBG_LOW, "read nmea data [%s]", nmea_data);
245         }
246         return ret;
247 }
248
249 gboolean gps_plugin_replay_read_manual(pos_data_t * pos_data)
250 {
251         gboolean ret = TRUE;
252
253         if (setting_get_double(MANUAL_LATITUDE, &pos_data->latitude) == FALSE) {
254                 LOG_PLUGIN(DBG_ERR, "Fail to get latitude");
255                 ret = FALSE;
256         }
257         if (setting_get_double(MANUAL_LONGITUDE, &pos_data->longitude) == FALSE) {
258                 LOG_PLUGIN(DBG_ERR, "Fail to get longitude");
259                 ret = FALSE;
260         }
261         if (setting_get_double(MANUAL_ALTITUDE, &pos_data->altitude) == FALSE) {
262                 LOG_PLUGIN(DBG_ERR, "Fail to get altitude");
263                 ret = FALSE;
264         }
265
266         return ret;
267 }
268
269 gboolean gps_plugin_replay_timeout_cb(gpointer data)
270 {
271         gboolean ret = FALSE;
272         read_error_t err = READ_SUCCESS;
273         replay_timeout *timer = (replay_timeout *) data;
274         char nmea_data[REPLAY_NMEA_SET_SIZE] = { 0, };
275
276         memset(timer->pos_data, 0, sizeof(pos_data_t));
277         memset(timer->sv_data, 0, sizeof(sv_data_t));
278
279         if (timer->replay_mode == REPLAY_NMEA) {
280                 if (gps_plugin_replay_read_nmea(timer, nmea_data) == FALSE) {
281                         LOG_PLUGIN(DBG_ERR, "Fail to read nmea data from file");
282                         return FALSE;
283                 } else {
284                         err = nmea_parser(nmea_data, timer->pos_data, timer->sv_data);
285                         if (err == READ_ERROR) {
286                                 LOG_PLUGIN(DBG_ERR, "Fail to parser nmea data from file");
287                                 return FALSE;
288                         } else if (err == READ_NOT_FIXED) {
289                                 LOG_PLUGIN(DBG_LOW, "GPS position is not fixed");
290                                 timer->sv_data->pos_valid = FALSE;
291                         }
292                 }
293         } else if (timer->replay_mode == REPLAY_MANUAL) {
294                 if (gps_plugin_replay_read_manual(timer->pos_data) == FALSE) {
295                         LOG_PLUGIN(DBG_ERR, "Fail to read manual data");
296                         err = READ_ERROR;
297                         return FALSE;
298                 } else {
299                         timer->sv_data->pos_valid = TRUE;
300                         err = READ_SUCCESS;
301                 }
302         } else if (timer->replay_mode == REPLAY_OFF) {
303                 LOG_PLUGIN(DBG_WARN, "replay_mode is OFF");
304                 err = READ_NOT_FIXED;
305                 timer->sv_data->pos_valid = FALSE;
306         }
307
308         if (timer != NULL) {
309                 if (g_gps_event_cb != NULL) {
310                         if (err != READ_NOT_FIXED) {
311                                 gps_plugin_replay_pos_event(timer->pos_data);
312                         }
313                         gps_plugin_replay_sv_event(timer->sv_data);
314                 }
315                 ret = TRUE;
316         }
317         return ret;
318 }
319
320 void gps_plugin_stop_replay_mode(replay_timeout * timer)
321 {
322         if (timer->replay_mode == REPLAY_NMEA && fclose(timer->fd) != 0) {
323                 LOG_PLUGIN(DBG_ERR, "fclose failed");
324         }
325         timer->fd = NULL;
326
327         if (timer->timeout_src != NULL && timer->default_context != NULL && !g_source_is_destroyed(timer->timeout_src)) {
328                 if (timer->default_context == g_source_get_context(timer->timeout_src)) {
329                         g_source_destroy(timer->timeout_src);
330                         LOG_PLUGIN(DBG_LOW, "g_source_destroy timeout_src");
331                 } else {
332                         LOG_PLUGIN(DBG_WARN, "timer->timeout_src is attatched to 0x%x (actual 0x%x)",
333                                    g_source_get_context(timer->timeout_src), timer->default_context);
334                 }
335                 timer->timeout_src = NULL;
336                 timer->default_context = NULL;
337         } else {
338                 LOG_PLUGIN(DBG_WARN, "timeout_src or default_context is NULL or timeout_src is already destroyed");
339         }
340         gps_plugin_respond_stop_session();
341 }
342
343 gboolean gps_plugin_get_nmea_fd(replay_timeout * timer)
344 {
345         char replay_file_path[256];
346
347         snprintf(replay_file_path, sizeof(replay_file_path), NMEA_FILE_PATH"%s", setting_get_string(NMEA_FILE_NAME));
348         LOG_PLUGIN(DBG_ERR, "replay file name : %s", replay_file_path);
349
350         timer->fd = fopen(replay_file_path, "r");
351         if (timer->fd == NULL) {
352                 LOG_PLUGIN(DBG_ERR, "fopen(%s) failed", replay_file_path);
353                 return FALSE;
354         }
355         return TRUE;
356 }
357
358 gboolean gps_plugin_start_replay_mode(replay_timeout * timer)
359 {
360         gboolean ret = FALSE;
361
362         if (timer->replay_mode == REPLAY_NMEA) {
363                 if (gps_plugin_get_nmea_fd(timer) == FALSE) {
364                         return FALSE;
365                 }
366         }
367
368         if (timer->default_context == NULL) {
369                 timer->default_context = g_main_context_default();
370                 if (timer->default_context == NULL) {
371                         return ret;
372                 }
373         }
374
375         if (timer->timeout_src != NULL) {
376                 LOG_PLUGIN(DBG_ERR, "timeout_src is already existed");
377                 ret = FALSE;
378         } else {
379                 timer->timeout_src = g_timeout_source_new_seconds(timer->interval);
380                 if (timer->timeout_src != NULL) {
381                         g_source_set_callback(timer->timeout_src, &gps_plugin_replay_timeout_cb, timer, NULL);
382                         if (g_source_attach(timer->timeout_src, timer->default_context) > 0) {
383                                 LOG_PLUGIN(DBG_LOW, "timeout_src(0x%x) is created & attatched to 0x%x", timer->timeout_src,
384                                            timer->default_context);
385                                 ret = TRUE;
386                         } else {
387                                 gps_plugin_stop_replay_mode(timer);
388                                 ret = FALSE;
389                         }
390                 }
391         }
392         gps_plugin_respond_start_session(ret);
393
394         return ret;
395 }
396
397 static void replay_mode_changed_cb(keynode_t * key, void *data)
398 {
399         if (setting_get_int(REPLAY_MODE, &g_replay_timer->replay_mode) == FALSE) {
400                 g_replay_timer->replay_mode = REPLAY_OFF;
401         }
402
403         if (g_replay_timer->replay_mode == REPLAY_NMEA) {
404                 if (gps_plugin_get_nmea_fd(g_replay_timer) == FALSE) {
405                         LOG_PLUGIN(DBG_ERR, "Fail to get nmea fd.");
406                 }
407         } else {
408                 if (g_replay_timer->fd != NULL) {
409                         fclose(g_replay_timer->fd);
410                         g_replay_timer->fd = NULL;
411                 }
412         }
413         return;
414 }
415
416 replay_timeout *gps_plugin_replay_timer_init()
417 {
418         replay_timeout *timer = NULL;
419
420         timer = (replay_timeout *) malloc(sizeof(replay_timeout));
421         if (timer == NULL) {
422                 LOG_PLUGIN(DBG_ERR, "replay_timeout allocation is failed.");
423                 return NULL;
424         }
425
426         timer->fd = NULL;
427         timer->interval = 1;
428         if (setting_get_int(REPLAY_MODE, &timer->replay_mode) == FALSE) {
429                 timer->replay_mode = REPLAY_OFF;
430         }
431         setting_notify_key_changed(REPLAY_MODE, replay_mode_changed_cb);
432
433         timer->pos_data = (pos_data_t *) malloc(sizeof(pos_data_t));
434         timer->sv_data = (sv_data_t *) malloc(sizeof(sv_data_t));
435         timer->nmea_data = (nmea_data_t *) malloc(sizeof(nmea_data_t));
436
437         if (timer->pos_data == NULL || timer->sv_data == NULL || timer->nmea_data == NULL) {
438                 LOG_PLUGIN(DBG_ERR, "pos_data or sv_data or nmea_data allocation is failed.");
439                 return NULL;
440         }
441
442         timer->timeout_src = NULL;
443         timer->default_context = NULL;
444
445         return timer;
446 }
447
448 void gps_plugin_replay_timer_deinit(replay_timeout * timer)
449 {
450         if (timer == NULL) {
451                 return;
452         }
453
454         if (timer->pos_data != NULL) {
455                 free(timer->pos_data);
456                 timer->pos_data = NULL;
457         }
458         if (timer->sv_data != NULL) {
459                 free(timer->sv_data);
460                 timer->sv_data = NULL;
461         }
462         if (timer->nmea_data != NULL) {
463                 free(timer->nmea_data);
464                 timer->nmea_data = NULL;
465         }
466
467         setting_ignore_key_changed(REPLAY_MODE, replay_mode_changed_cb);
468
469         free(timer);
470         timer = NULL;
471 }
472
473 int gps_plugin_replay_gps_init(gps_event_cb gps_event_cb, gps_server_param_t * gps_params)
474 {
475         g_gps_event_cb = gps_event_cb;
476         g_replay_timer = gps_plugin_replay_timer_init();
477
478         return TRUE;
479 }
480
481 int gps_plugin_replay_gps_deinit(gps_failure_reason_t * reason_code)
482 {
483         gps_plugin_replay_timer_deinit(g_replay_timer);
484
485         return TRUE;
486 }
487
488 int gps_plugin_replay_gps_request(gps_action_t gps_action, void *data, gps_failure_reason_t * reason_code)
489 {
490         switch (gps_action) {
491         case GPS_ACTION_SEND_PARAMS:
492                 break;
493         case GPS_ACTION_START_SESSION:
494                 gps_plugin_start_replay_mode(g_replay_timer);
495                 break;
496         case GPS_ACTION_STOP_SESSION:
497                 gps_plugin_stop_replay_mode(g_replay_timer);
498                 break;
499         case GPS_INDI_SUPL_VERIFICATION:
500         case GPS_INDI_SUPL_DNSQUERY:
501         case GPS_ACTION_START_FACTTEST:
502         case GPS_ACTION_STOP_FACTTEST:
503         case GPS_ACTION_REQUEST_SUPL_NI:
504                 LOG_PLUGIN(DBG_LOW, "Don't use action type : [ %d ]", gps_action);
505                 break;
506         default:
507                 break;
508         }
509
510         return TRUE;
511 }
512
513 EXPORT_API const gps_plugin_interface *get_gps_plugin_interface()
514 {
515         return &g_gps_plugin_replay_interface;
516 }