location/manager/location-passive.c

   1 /*
   2  * libslp-location
   3  *
   4  * Copyright (c) 2010-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   7  *                      Genie Kim <daejins.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 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "location-setting.h"
  27 #include "location-log.h"
  28
  29 #include "module-internal.h"
  30
  31 #include "location-passive.h"
  32 #include "location-marshal.h"
  33 #include "location-ielement.h"
  34 #include "location-signaling-util.h"
  35 #include "location-common-util.h"
  36 #include "location-privacy.h"
  37
  38 #include <vconf-internal-location-keys.h>
  39
  40 typedef struct _LocationPassivePrivate {
  41         LocationPassiveMod      *mod;
  42         GMutex                          mutex;
  43         gboolean                        is_started;
  44         guint                           app_type;
  45         gboolean                        set_noti;
  46         gboolean                        enabled;
  47         guint                           pos_updated_timestamp;
  48         guint                           vel_updated_timestamp;
  49         guint                           sat_updated_timestamp;
  50         guint                           loc_updated_timestamp;
  51         guint                           dist_updated_timestamp;
  52         guint                           pos_interval;
  53         guint                           vel_interval;
  54         guint                           sat_interval;
  55         guint                           loc_interval;
  56         guint                           loc_timeout;
  57         guint                           min_interval;
  58         gdouble                         min_distance;
  59         LocationPosition        *pos;
  60         LocationVelocity        *vel;
  61         LocationAccuracy        *acc;
  62         LocationSatellite       *sat;
  63         GList                           *boundary_list;
  64 } LocationPassivePrivate;
  65
  66 enum {
  67         PROP_0,
  68         PROP_METHOD_TYPE,
  69         PROP_IS_STARTED,
  70         PROP_LAST_POSITION,
  71         PROP_POS_INTERVAL,
  72         PROP_VEL_INTERVAL,
  73         PROP_SAT_INTERVAL,
  74         PROP_LOC_INTERVAL,
  75         PROP_BOUNDARY,
  76         PROP_REMOVAL_BOUNDARY,
  77         PROP_SATELLITE,
  78         PROP_MIN_INTERVAL,
  79         PROP_MIN_DISTANCE,
  80         PROP_SERVICE_STATUS,
  81         PROP_MAX
  82 };
  83
  84 static guint32 signals[LAST_SIGNAL] = {0, };
  85 static GParamSpec *properties[PROP_MAX] = {NULL, };
  86
  87 #define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), LOCATION_TYPE_PASSIVE, LocationPassivePrivate))
  88
  89 static void location_ielement_interface_init(LocationIElementInterface *iface);
  90
  91 G_DEFINE_TYPE_WITH_CODE(LocationPassive, location_passive, G_TYPE_OBJECT,
  92                                                 G_IMPLEMENT_INTERFACE(LOCATION_TYPE_IELEMENT, location_ielement_interface_init));
  93
  94 static void __reset_pos_data_from_priv(LocationPassivePrivate *priv)
  95 {
  96         LOC_FUNC_LOG
  97         g_return_if_fail(priv);
  98
  99         if (priv->pos) {
 100                 location_position_free(priv->pos);
 101                 priv->pos = NULL;
 102         }
 103         if (priv->vel) {
 104                 location_velocity_free(priv->vel);
 105                 priv->vel = NULL;
 106         }
 107         if (priv->sat) {
 108                 location_satellite_free(priv->sat);
 109                 priv->sat = NULL;
 110         }
 111         if (priv->acc) {
 112                 location_accuracy_free(priv->acc);
 113                 priv->acc = NULL;
 114         }
 115         priv->pos_updated_timestamp = 0;
 116         priv->vel_updated_timestamp = 0;
 117         priv->sat_updated_timestamp = 0;
 118         priv->loc_updated_timestamp = 0;
 119 }
 120
 121 static gboolean __get_started(gpointer self)
 122 {
 123         LocationPassivePrivate *priv = GET_PRIVATE(self);
 124         g_return_val_if_fail(priv, FALSE);
 125
 126         return priv->is_started;
 127 }
 128
 129 static int __set_started(gpointer self, gboolean started)
 130 {
 131         LocationPassivePrivate *priv = GET_PRIVATE(self);
 132         g_return_val_if_fail(priv, -1);
 133
 134         if (priv->is_started != started) {
 135                 g_mutex_lock(&priv->mutex);
 136                 priv->is_started = started;
 137                 g_mutex_unlock(&priv->mutex);
 138         }
 139
 140         return 0;
 141 }
 142
 143 static void passive_location_cb(gboolean enabled, LocationPosition *pos, LocationVelocity *vel, LocationAccuracy *acc, gpointer self)
 144 {
 145         g_return_if_fail(self);
 146         g_return_if_fail(pos);
 147         g_return_if_fail(vel);
 148         g_return_if_fail(acc);
 149
 150         LocationPassivePrivate *priv = GET_PRIVATE(self);
 151         g_return_if_fail(priv);
 152
 153         location_signaling(self, signals, enabled, priv->boundary_list, pos, vel, acc,
 154                                                 priv->pos_interval, priv->vel_interval, priv->loc_interval, &(priv->enabled),
 155                                                 &(priv->pos_updated_timestamp), &(priv->vel_updated_timestamp),
 156                                                 &(priv->loc_updated_timestamp), &(priv->pos), &(priv->vel), &(priv->acc));
 157 }
 158
 159 static void passive_satellite_cb(gboolean enabled, LocationSatellite *sat, gpointer self)
 160 {
 161         g_return_if_fail(self);
 162         LocationPassivePrivate *priv = GET_PRIVATE(self);
 163         g_return_if_fail(priv);
 164
 165         satellite_signaling(self, signals, &(priv->enabled), priv->sat_interval, TRUE, &(priv->sat_updated_timestamp), &(priv->sat), sat);
 166 }
 167
 168 static int location_passive_start(LocationPassive *self)
 169 {
 170         LOC_FUNC_LOG
 171         LocationPassivePrivate *priv = GET_PRIVATE(self);
 172         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 173         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 174         g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
 175         g_return_val_if_fail(priv->mod->ops.start, LOCATION_ERROR_NOT_AVAILABLE);
 176
 177         LOC_COND_RET(__get_started(self) == TRUE, LOCATION_ERROR_NONE, _E, "Passive already started. Error[%s]", err_msg(LOCATION_ERROR_NONE));
 178
 179         int ret = LOCATION_ERROR_NONE;
 180
 181         if (!location_setting_get_int(VCONFKEY_LOCATION_ENABLED)) {
 182                 ret = LOCATION_ERROR_SETTING_OFF;
 183         } else {
 184                 __set_started(self, TRUE);
 185
 186                 ret = priv->mod->ops.start(priv->mod->handler, 1, NULL, passive_location_cb, passive_satellite_cb, self);
 187                 if (ret != LOCATION_ERROR_NONE) {
 188                         LOCATION_LOGE("Fail to start gps. Error[%d]", ret);
 189                         __set_started(self, FALSE);
 190                         return ret;
 191                 }
 192         }
 193
 194         if (priv->app_type != CPPAPP && priv->set_noti == FALSE)
 195                 priv->set_noti = TRUE;
 196
 197         return ret;
 198 }
 199
 200 static int location_passive_stop(LocationPassive *self)
 201 {
 202         LOC_FUNC_LOG
 203         LocationPassivePrivate *priv = GET_PRIVATE(self);
 204         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 205         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 206         g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
 207         g_return_val_if_fail(priv->mod->ops.stop, LOCATION_ERROR_NOT_AVAILABLE);
 208
 209         int ret = LOCATION_ERROR_NONE;
 210
 211         if (__get_started(self) == TRUE) {
 212                 __set_started(self, FALSE);
 213                 ret = priv->mod->ops.stop(priv->mod->handler);
 214                 LOC_IF_FAIL_LOG(ret, _E, "Failed to stop [%s]", err_msg(ret));
 215                 g_signal_emit(self, signals[SERVICE_DISABLED], 0, LOCATION_STATUS_NO_FIX);
 216         }
 217
 218         if (priv->app_type != CPPAPP && priv->set_noti == TRUE)
 219                 priv->set_noti = FALSE;
 220
 221         __reset_pos_data_from_priv(priv);
 222
 223         return ret;
 224 }
 225
 226 static void location_passive_dispose(GObject *gobject)
 227 {
 228         LOC_FUNC_LOG
 229         LocationPassivePrivate *priv = GET_PRIVATE(gobject);
 230         g_return_if_fail(priv);
 231
 232         g_mutex_clear(&priv->mutex);
 233
 234         if (priv->app_type != CPPAPP && priv->set_noti == TRUE)
 235                 priv->set_noti = FALSE;
 236
 237         G_OBJECT_CLASS(location_passive_parent_class)->dispose(gobject);
 238 }
 239
 240 static void location_passive_finalize(GObject *gobject)
 241 {
 242         LOC_FUNC_LOG
 243         LocationPassivePrivate *priv = GET_PRIVATE(gobject);
 244         g_return_if_fail(priv);
 245
 246         if (priv->boundary_list) {
 247                 g_list_free_full(priv->boundary_list, free_boundary_list);
 248                 priv->boundary_list = NULL;
 249         }
 250
 251         if (priv->pos) {
 252                 location_position_free(priv->pos);
 253                 priv->pos = NULL;
 254         }
 255
 256         if (priv->vel) {
 257                 location_velocity_free(priv->vel);
 258                 priv->vel = NULL;
 259         }
 260
 261         if (priv->acc) {
 262                 location_accuracy_free(priv->acc);
 263                 priv->acc = NULL;
 264         }
 265         G_OBJECT_CLASS(location_passive_parent_class)->finalize(gobject);
 266 }
 267
 268 static guint get_valid_interval(guint interval, int max_interval, int min_interval)
 269 {
 270         if (interval > max_interval)
 271                 return (guint)max_interval;
 272         else if (interval < min_interval)
 273                 return (guint)min_interval;
 274         else
 275                 return interval;
 276 }
 277
 278 static void location_passive_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
 279 {
 280         LocationPassivePrivate *priv = GET_PRIVATE(object);
 281         g_return_if_fail(priv);
 282         int ret = 0;
 283
 284         switch (property_id) {
 285         case PROP_BOUNDARY: {
 286                 GList *boundary_list = (GList *)g_list_copy(g_value_get_pointer(value));
 287                 ret = set_prop_boundary(&priv->boundary_list, boundary_list);
 288                 if (ret != LOCATION_ERROR_NONE)
 289                         LOCATION_LOGE("Set boundary. Error[%d]", ret);
 290                 if (boundary_list)
 291                         g_list_free(boundary_list);
 292                 break;
 293         }
 294         case PROP_REMOVAL_BOUNDARY: {
 295                 LocationBoundary *req_boundary = (LocationBoundary *) g_value_dup_boxed(value);
 296                 ret = set_prop_removal_boundary(&priv->boundary_list, req_boundary);
 297                 if (ret != 0) LOCATION_LOGD("Set removal boundary. Error[%d]", ret);
 298                 break;
 299         }
 300         case PROP_POS_INTERVAL: {
 301                 guint interval = g_value_get_uint(value);
 302                 if (interval > 0) {
 303                         if (interval < LOCATION_UPDATE_INTERVAL_MAX)
 304                                 priv->pos_interval = interval;
 305                         else
 306                                 priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
 307                 } else {
 308                         priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
 309                 }
 310
 311                 break;
 312         }
 313         case PROP_VEL_INTERVAL: {
 314                 guint interval = g_value_get_uint(value);
 315                 if (interval > 0) {
 316                         if (interval < LOCATION_UPDATE_INTERVAL_MAX)
 317                                 priv->vel_interval = interval;
 318                         else
 319                                 priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
 320                 } else {
 321                         priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
 322                 }
 323                 break;
 324         }
 325         case PROP_SAT_INTERVAL: {
 326                 guint interval = g_value_get_uint(value);
 327                 LOCATION_LOGD("Set prop>> PROP_SAT_INTERVAL: %u", interval);
 328                 priv->sat_interval = get_valid_interval(interval, LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_MIN);
 329                 break;
 330         }
 331         case PROP_LOC_INTERVAL: {
 332                 guint interval = g_value_get_uint(value);
 333                 LOCATION_LOGD("Set prop>> PROP_LOC_INTERVAL: %u", interval);
 334                 if (interval > 0) {
 335                         if (interval < LOCATION_UPDATE_INTERVAL_MAX)
 336                                 priv->loc_interval = interval;
 337                         else
 338                                 priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
 339                 } else {
 340                         priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
 341                 }
 342
 343                 break;
 344         }
 345         case PROP_MIN_INTERVAL: {
 346                 guint interval = g_value_get_uint(value);
 347                 LOCATION_LOGD("Set prop>> update-min-interval: %u", interval);
 348                 if (interval > 0) {
 349                         if (interval < LOCATION_MIN_INTERVAL_MAX)
 350                                 priv->min_interval = interval;
 351                         else
 352                                 priv->min_interval = (guint)LOCATION_MIN_INTERVAL_MAX;
 353                 } else {
 354                         priv->min_interval = (guint)LOCATION_MIN_INTERVAL_DEFAULT;
 355                 }
 356
 357                 break;
 358         }
 359         case PROP_MIN_DISTANCE: {
 360                 gdouble distance = g_value_get_double(value);
 361                 LOCATION_LOGD("Set prop>> update-min-distance: %u", distance);
 362                 if (distance > 0) {
 363                         if (distance < LOCATION_MIN_DISTANCE_MAX)
 364                                 priv->min_distance = distance;
 365                         else
 366                                 priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_MAX;
 367                 } else {
 368                         priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_DEFAULT;
 369                 }
 370
 371                 break;
 372         }
 373         case PROP_SERVICE_STATUS: {
 374                 gint enabled = g_value_get_int(value);
 375                 LOCATION_LOGD("Set prop>> PROP_SERVICE_STATUS: %u", enabled);
 376                 priv->enabled = enabled;
 377                 break;
 378         }
 379         default:
 380                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 381                 break;
 382         }
 383 }
 384
 385 static void location_passive_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
 386 {
 387         LocationPassivePrivate *priv = GET_PRIVATE(object);
 388         g_return_if_fail(priv);
 389         g_return_if_fail(priv->mod);
 390         g_return_if_fail(priv->mod->handler);
 391         LocModPassiveOps ops = priv->mod->ops;
 392
 393         switch (property_id) {
 394         case PROP_METHOD_TYPE:
 395                 g_value_set_int(value, LOCATION_METHOD_PASSIVE);
 396                 break;
 397         case PROP_IS_STARTED:
 398                 g_value_set_boolean(value, __get_started(object));
 399                 break;
 400         case PROP_LAST_POSITION:
 401                 g_value_set_boxed(value, priv->pos);
 402                 break;
 403         case PROP_BOUNDARY:
 404                 g_value_set_pointer(value, g_list_first(priv->boundary_list));
 405                 break;
 406         case PROP_POS_INTERVAL:
 407                 g_value_set_uint(value, priv->pos_interval);
 408                 break;
 409         case PROP_VEL_INTERVAL:
 410                 g_value_set_uint(value, priv->vel_interval);
 411                 break;
 412         case PROP_SAT_INTERVAL:
 413                 g_value_set_uint(value, priv->sat_interval);
 414                 break;
 415         case PROP_LOC_INTERVAL:
 416                 g_value_set_uint(value, priv->loc_interval);
 417                 break;
 418         case PROP_MIN_INTERVAL:
 419                 g_value_set_uint(value, priv->min_interval);
 420                 break;
 421         case PROP_MIN_DISTANCE:
 422                 g_value_set_double(value, priv->min_distance);
 423                 break;
 424         case PROP_SATELLITE: {
 425                 LocationSatellite *satellite = NULL;
 426                 if (ops.get_satellite && priv->mod->handler && LOCATION_ERROR_NONE == ops.get_satellite(priv->mod->handler, &satellite) && satellite) {
 427                         LOCATION_LOGD("Get prop>> Last sat: num_used(%d) num_view(%d)", satellite->num_of_sat_used, satellite->num_of_sat_inview);
 428                         g_value_set_boxed(value, satellite);
 429                         location_satellite_free(satellite);
 430                 } else {
 431                         LOCATION_LOGW("Get prop>> Last sat: failed");
 432                         g_value_set_boxed(value, NULL);
 433                 }
 434                 break;
 435         }
 436         case PROP_SERVICE_STATUS:
 437                 g_value_set_int(value, priv->enabled);
 438                 break;
 439         default:
 440                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 441                 break;
 442         }
 443 }
 444
 445 static int location_passive_get_position(LocationPassive *self, LocationPosition **position, LocationAccuracy **accuracy)
 446 {
 447         LOC_FUNC_LOG
 448         int ret = LOCATION_ERROR_NOT_AVAILABLE;
 449
 450         LocationPassivePrivate *priv = GET_PRIVATE(self);
 451         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 452         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 453         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 454
 455         if (__get_started(self) != TRUE) {
 456                 LOCATION_LOGE("location is not started");
 457                 return LOCATION_ERROR_NOT_AVAILABLE;
 458         }
 459
 460         if (priv->pos) {
 461                 *position = location_position_copy(priv->pos);
 462                 if (priv->acc) *accuracy = location_accuracy_copy(priv->acc);
 463                 else *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
 464                 ret = LOCATION_ERROR_NONE;
 465         }
 466
 467         return ret;
 468 }
 469
 470 static int location_passive_get_position_ext(LocationPassive *self, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy)
 471 {
 472         LOC_FUNC_LOG
 473         int ret = LOCATION_ERROR_NOT_AVAILABLE;
 474
 475         LocationPassivePrivate *priv = GET_PRIVATE(self);
 476         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 477         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 478         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 479
 480         if (__get_started(self) != TRUE) {
 481                 LOCATION_LOGE("location is not started");
 482                 return LOCATION_ERROR_NOT_AVAILABLE;
 483         }
 484
 485         if (priv->pos && priv->vel) {
 486                 *position = location_position_copy(priv->pos);
 487                 *velocity = location_velocity_copy(priv->vel);
 488                 if (priv->acc) *accuracy = location_accuracy_copy(priv->acc);
 489                 else *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
 490                 ret = LOCATION_ERROR_NONE;
 491         }
 492
 493         return ret;
 494 }
 495
 496
 497 static int location_passive_get_last_position(LocationPassive *self, LocationPosition **position, LocationAccuracy **accuracy)
 498 {
 499         LOC_FUNC_LOG
 500         LocationPassivePrivate *priv = GET_PRIVATE(self);
 501         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 502         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 503         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 504
 505         int ret = LOCATION_ERROR_NONE;
 506         LocationVelocity *_velocity = NULL;
 507
 508         LocModPassiveOps ops = priv->mod->ops;
 509         g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
 510         g_return_val_if_fail(ops.get_last_position, LOCATION_ERROR_NOT_AVAILABLE);
 511
 512         ret = ops.get_last_position(priv->mod->handler, position, &_velocity, accuracy);
 513         if (_velocity) location_velocity_free(_velocity);
 514
 515         return ret;
 516 }
 517
 518 static int location_passive_get_last_position_ext(LocationPassive *self, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy)
 519 {
 520         LOC_FUNC_LOG
 521         LocationPassivePrivate *priv = GET_PRIVATE(self);
 522         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 523         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 524         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 525
 526         LocModPassiveOps ops = priv->mod->ops;
 527         g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
 528         g_return_val_if_fail(ops.get_last_position, LOCATION_ERROR_NOT_AVAILABLE);
 529
 530         return ops.get_last_position(priv->mod->handler, position, velocity, accuracy);
 531 }
 532
 533 static int location_passive_get_velocity(LocationPassive *self, LocationVelocity **velocity, LocationAccuracy **accuracy)
 534 {
 535         int ret = LOCATION_ERROR_NOT_AVAILABLE;
 536
 537         LocationPassivePrivate *priv = GET_PRIVATE(self);
 538         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 539         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 540         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 541
 542         if (__get_started(self) != TRUE) {
 543                 LOCATION_LOGE("location is not started");
 544                 return LOCATION_ERROR_NOT_AVAILABLE;
 545         }
 546
 547         if (priv->vel) {
 548                 *velocity = location_velocity_copy(priv->vel);
 549                 if (priv->acc) *accuracy = location_accuracy_copy(priv->acc);
 550                 else *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
 551                 ret = LOCATION_ERROR_NONE;
 552         }
 553
 554         return ret;
 555 }
 556
 557 static int location_passive_get_last_velocity(LocationPassive *self, LocationVelocity **velocity, LocationAccuracy **accuracy)
 558 {
 559         LOC_FUNC_LOG
 560         LocationPassivePrivate *priv = GET_PRIVATE(self);
 561         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 562         g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
 563         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 564
 565         int ret = LOCATION_ERROR_NONE;
 566         LocationPosition *_position = NULL;
 567
 568         LocModPassiveOps ops = priv->mod->ops;
 569         g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
 570         ret = ops.get_last_position(priv->mod->handler, &_position, velocity, accuracy);
 571         if (!_position) location_position_free(_position);
 572
 573         return ret;
 574 }
 575
 576 static int location_passive_get_satellite(LocationPassive *self, LocationSatellite **satellite)
 577 {
 578         LOC_FUNC_LOG
 579         LocationPassivePrivate *priv = GET_PRIVATE(self);
 580         g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
 581         setting_retval_if_fail(VCONFKEY_LOCATION_ENABLED);
 582
 583         LOC_COND_RET(__get_started(self) != TRUE, LOCATION_ERROR_NOT_AVAILABLE, _E, "Passive is not started [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
 584
 585         int ret = LOCATION_ERROR_NOT_AVAILABLE;
 586         if (priv->sat) {
 587                 *satellite = location_satellite_copy(priv->sat);
 588                 ret = LOCATION_ERROR_NONE;
 589         }
 590
 591         return ret;
 592 }
 593
 594 static int location_passive_get_last_satellite(LocationPassive *self, LocationSatellite **satellite)
 595 {
 596         LOC_FUNC_LOG
 597         return location_passive_get_satellite(self, satellite);
 598 }
 599
 600 static int location_passive_set_option(LocationPassive *self, const char *option)
 601 {
 602         LOC_FUNC_LOG
 603         return LOCATION_ERROR_NONE;
 604 }
 605
 606 static int location_passive_request_single_location(LocationPassive *self, int timeout)
 607 {
 608         LOC_FUNC_LOG
 609         return LOCATION_ERROR_NOT_SUPPORTED;
 610 }
 611
 612 static int location_passive_cancel_single_location(LocationPassive *self, int timeout)
 613 {
 614         LOC_FUNC_LOG
 615         return LOCATION_ERROR_NOT_SUPPORTED;
 616 }
 617
 618 static int location_passive_get_nmea(LocationPassive *self, char **nmea_data)
 619 {
 620         LOC_FUNC_LOG
 621         return LOCATION_ERROR_NOT_SUPPORTED;
 622 }
 623
 624 static int location_passive_set_mock_location(LocationPassive *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
 625 {
 626         LOC_FUNC_LOG
 627         return LOCATION_ERROR_NOT_SUPPORTED;
 628 }
 629
 630 static int location_passive_clear_mock_location(LocationPassive *self)
 631 {
 632         LOC_FUNC_LOG
 633         return LOCATION_ERROR_NOT_SUPPORTED;
 634 }
 635
 636 static void location_ielement_interface_init(LocationIElementInterface *iface)
 637 {
 638         iface->start = (TYPE_START_FUNC)location_passive_start;
 639         iface->stop = (TYPE_STOP_FUNC)location_passive_stop;
 640         iface->get_position = (TYPE_GET_POSITION)location_passive_get_position;
 641         iface->get_position_ext = (TYPE_GET_POSITION_EXT)location_passive_get_position_ext;
 642         iface->get_last_position = (TYPE_GET_POSITION)location_passive_get_last_position;
 643         iface->get_last_position_ext = (TYPE_GET_POSITION_EXT)location_passive_get_last_position_ext;
 644         iface->get_velocity = (TYPE_GET_VELOCITY)location_passive_get_velocity;
 645         iface->get_last_velocity = (TYPE_GET_VELOCITY)location_passive_get_last_velocity;
 646         iface->get_satellite = (TYPE_GET_SATELLITE)location_passive_get_satellite;
 647         iface->get_last_satellite = (TYPE_GET_SATELLITE)location_passive_get_last_satellite;
 648         iface->set_option = (TYPE_SET_OPTION)location_passive_set_option;
 649         iface->request_single_location = (TYPE_REQUEST_SINGLE_LOCATION)location_passive_request_single_location;
 650         iface->cancel_single_location = (TYPE_CANCEL_SINGLE_LOCATION)location_passive_cancel_single_location;
 651         iface->get_nmea = (TYPE_GET_NMEA)location_passive_get_nmea;
 652         iface->set_mock_location = (TYPE_SET_MOCK_LOCATION) location_passive_set_mock_location;
 653         iface->clear_mock_location = (TYPE_CLEAR_MOCK_LOCATION) location_passive_clear_mock_location;
 654 }
 655
 656 static void location_passive_init(LocationPassive *self)
 657 {
 658         LOC_FUNC_LOG
 659         LocationPassivePrivate *priv = GET_PRIVATE(self);
 660         g_return_if_fail(priv);
 661
 662         priv->mod = (LocationPassiveMod *)module_new("passive");
 663         if (!priv->mod) LOCATION_LOGW("module loading failed");
 664
 665         g_mutex_init(&priv->mutex);
 666         priv->is_started = FALSE;
 667         priv->set_noti = FALSE;
 668         priv->enabled = FALSE;
 669
 670         priv->pos_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
 671         priv->vel_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
 672         priv->sat_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
 673         priv->loc_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
 674         priv->min_interval = LOCATION_UPDATE_INTERVAL_NONE;
 675
 676         priv->pos_updated_timestamp = 0;
 677         priv->vel_updated_timestamp = 0;
 678         priv->sat_updated_timestamp = 0;
 679         priv->loc_updated_timestamp = 0;
 680
 681         priv->pos = NULL;
 682         priv->vel = NULL;
 683         priv->acc = NULL;
 684         priv->sat = NULL;
 685         priv->boundary_list = NULL;
 686
 687         priv->loc_timeout = 0;
 688
 689         priv->app_type = location_get_app_type(NULL);
 690         LOC_COND_LOG(priv->app_type == 0, _W, "[Info] Fail to get app_type");
 691 }
 692
 693 static void location_passive_class_init(LocationPassiveClass *klass)
 694 {
 695         LOC_FUNC_LOG
 696         GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 697
 698         gobject_class->set_property = location_passive_set_property;
 699         gobject_class->get_property = location_passive_get_property;
 700
 701         gobject_class->dispose = location_passive_dispose;
 702         gobject_class->finalize = location_passive_finalize;
 703
 704         g_type_class_add_private(klass, sizeof(LocationPassivePrivate));
 705
 706         signals[SERVICE_ENABLED] =
 707                         g_signal_new("service-enabled", G_TYPE_FROM_CLASS(klass),
 708                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 709                         G_STRUCT_OFFSET(LocationPassiveClass, enabled),
 710                         NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
 711
 712         signals[SERVICE_DISABLED] =
 713                         g_signal_new("service-disabled", G_TYPE_FROM_CLASS(klass),
 714                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 715                         G_STRUCT_OFFSET(LocationPassiveClass, disabled),
 716                         NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
 717
 718         signals[SERVICE_UPDATED] =
 719                         g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
 720                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 721                         G_STRUCT_OFFSET(LocationPassiveClass, service_updated),
 722                         NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER, G_TYPE_NONE, 4,
 723                         G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
 724
 725         signals[LOCATION_UPDATED] =
 726                         g_signal_new("location-updated", G_TYPE_FROM_CLASS(klass),
 727                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 728                         G_STRUCT_OFFSET(LocationPassiveClass, location_updated),
 729                         NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
 730                         G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
 731
 732         signals[ZONE_IN] =
 733                         g_signal_new("zone-in", G_TYPE_FROM_CLASS(klass),
 734                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 735                         G_STRUCT_OFFSET(LocationPassiveClass, zone_in),
 736                         NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
 737                         G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
 738
 739         signals[ZONE_OUT] =
 740                         g_signal_new("zone-out", G_TYPE_FROM_CLASS(klass),
 741                         G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 742                         G_STRUCT_OFFSET(LocationPassiveClass, zone_out),
 743                         NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
 744                         G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
 745
 746         properties[PROP_METHOD_TYPE] =
 747                         g_param_spec_int("method", "method type", "location method type name",
 748                         LOCATION_METHOD_PASSIVE, LOCATION_METHOD_PASSIVE, LOCATION_METHOD_PASSIVE, G_PARAM_READABLE);
 749
 750         properties[PROP_IS_STARTED] =
 751                         g_param_spec_boolean("is_started", "passive is started prop",
 752                         "passive is started status", FALSE, G_PARAM_READWRITE);
 753
 754         properties[PROP_LAST_POSITION] =
 755                         g_param_spec_boxed("last-position", "passive last position prop",
 756                         "passive last position data", LOCATION_TYPE_POSITION, G_PARAM_READABLE);
 757
 758         properties[PROP_POS_INTERVAL] =
 759                         g_param_spec_uint("pos-interval", "passive position interval prop",
 760                         "passive position interval data", LOCATION_UPDATE_INTERVAL_MIN,
 761                         LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
 762
 763         properties[PROP_VEL_INTERVAL] =
 764                         g_param_spec_uint("vel-interval", "passive velocity interval prop",
 765                         "passive velocity interval data", LOCATION_UPDATE_INTERVAL_MIN,
 766                         LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
 767
 768         properties[PROP_SAT_INTERVAL] =
 769                         g_param_spec_uint("sat-interval", "passive satellite interval prop",
 770                         "passive satellite interval data", LOCATION_UPDATE_INTERVAL_MIN,
 771                         LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
 772
 773         properties[PROP_LOC_INTERVAL] =
 774                         g_param_spec_uint("loc-interval", "passive location interval prop",
 775                         "passive location interval data", LOCATION_UPDATE_INTERVAL_MIN,
 776                         LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
 777
 778         properties[PROP_MIN_INTERVAL] =
 779                         g_param_spec_uint("min-interval", "passive distance-based interval prop",
 780                         "passive distance-based interval data", LOCATION_MIN_INTERVAL_MIN,
 781                         LOCATION_MIN_INTERVAL_MAX, LOCATION_MIN_INTERVAL_DEFAULT, G_PARAM_READWRITE);
 782
 783         properties[PROP_MIN_DISTANCE] =
 784                         g_param_spec_double("min-distance", "passive distance-based distance prop",
 785                         "passive distance-based distance data", LOCATION_MIN_DISTANCE_MIN,
 786                         LOCATION_MIN_DISTANCE_MAX, LOCATION_MIN_DISTANCE_DEFAULT, G_PARAM_READWRITE);
 787
 788         properties[PROP_BOUNDARY] =
 789                         g_param_spec_pointer("boundary", "passive boundary prop",
 790                         "passive boundary data", G_PARAM_READWRITE);
 791
 792         properties[PROP_REMOVAL_BOUNDARY] =
 793                         g_param_spec_boxed("removal-boundary", "passive removal boundary prop",
 794                         "passive removal boundary data", LOCATION_TYPE_BOUNDARY, G_PARAM_READWRITE);
 795
 796         properties[PROP_SATELLITE] =
 797                         g_param_spec_boxed("satellite", "passive satellite prop",
 798                         "passive satellite data", LOCATION_TYPE_SATELLITE, G_PARAM_READABLE);
 799
 800         properties[PROP_SERVICE_STATUS] =
 801                         g_param_spec_int("service-status", "location service status prop",
 802                         "location service status data", LOCATION_STATUS_NO_FIX,
 803                         LOCATION_STATUS_3D_FIX, LOCATION_STATUS_NO_FIX, G_PARAM_READABLE);
 804
 805         g_object_class_install_properties(gobject_class, PROP_MAX, properties);
 806 }
 807