location/manager/location-passive.c

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