module/module_geofence_server.c

   1 /* Copyright 2014 Samsung Electronics Co., Ltd All Rights Reserved
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif
  19
  20 #include <glib.h>
  21 #include <gmodule.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <app_manager.h>
  25 #include <dlfcn.h>
  26 #include <geofence_client.h>
  27 #include <geofence_module.h>
  28 #include "log.h"
  29
  30 #define GEOFENCE_SERVER_SERVICE_NAME    "org.tizen.lbs.Providers.GeofenceServer"
  31 #define GEOFENCE_SERVER_SERVICE_PATH    "/org/tizen/lbs/Providers/GeofenceServer"
  32
  33 #define MYPLACES_APP_ID  "org.tizen.myplace"
  34
  35 typedef enum {
  36     ACCESS_TYPE_PRIVATE = 1,
  37     ACCESS_TYPE_PUBLIC,
  38     ACCESS_TYPE_UNKNOWN,
  39 } access_type_e;
  40
  41 typedef struct {
  42         geofence_client_dbus_h geofence_client;
  43         GeofenceModCB geofence_cb;
  44         GeofenceModProximityCB geofence_proximity_cb;
  45         GeofenceModEventCB geofence_event_cb;
  46         gchar *app_id;
  47         gpointer userdata;
  48 } GeofenceManagerData;
  49
  50 EXPORT_API int add_geopoint(void *handle, int place_id, double latitude, double longitude, int radius, const char *address, int *fence_id)
  51 {
  52         MOD_LOGD("add_geopoint");
  53         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
  54         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
  55         int new_fence_id = -1;
  56
  57         new_fence_id = geo_client_add_geofence(geofence_manager->geofence_client, geofence_manager->app_id, place_id, GEOFENCE_TYPE_GEOPOINT, latitude, longitude, radius, address, "", "");
  58         *fence_id = new_fence_id;
  59
  60         if (new_fence_id == -1)
  61                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
  62
  63         return GEOFENCE_MANAGER_ERROR_NONE;
  64 }
  65
  66 EXPORT_API int add_bssid(void *handle, int place_id, const char *bssid, const char *ssid, geofence_type_e type, int *fence_id)
  67 {
  68         MOD_LOGD("add_bssid");
  69         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
  70         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
  71         int new_fence_id = -1;
  72
  73         new_fence_id = geo_client_add_geofence(geofence_manager->geofence_client, geofence_manager->app_id, place_id, type, -1, -1, -1, "", bssid, ssid);
  74         *fence_id = new_fence_id;
  75
  76         if (new_fence_id == -1)
  77                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
  78
  79         return GEOFENCE_MANAGER_ERROR_NONE;
  80 }
  81
  82 EXPORT_API int add_place(void *handle, const char *place_name, int *place_id)
  83 {
  84         MOD_LOGD("add_place");
  85         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
  86         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
  87         int new_place_id = -1;
  88
  89         new_place_id = geo_client_add_place(geofence_manager->geofence_client, geofence_manager->app_id, place_name);
  90         *place_id = new_place_id;
  91
  92         if (new_place_id == -1)
  93                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
  94
  95         return GEOFENCE_MANAGER_ERROR_NONE;
  96 }
  97
  98 EXPORT_API int update_place(void *handle, int place_id, const char *place_name)
  99 {
 100         MOD_LOGD("update_place");
 101         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 102         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 103
 104         int ret = geo_client_update_place(geofence_manager->geofence_client, geofence_manager->app_id, place_id, place_name);
 105         if (ret != GEOFENCE_CLIENT_ERROR_NONE)
 106                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 107
 108         return GEOFENCE_MANAGER_ERROR_NONE;
 109 }
 110
 111 EXPORT_API int remove_geofence(void *handle, int fence_id)
 112 {
 113         MOD_LOGD("remove_geofence");
 114         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 115         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 116
 117         int ret = geo_client_delete_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id);
 118         if (ret != GEOFENCE_CLIENT_ERROR_NONE)
 119                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 120
 121         return GEOFENCE_MANAGER_ERROR_NONE;
 122 }
 123
 124 EXPORT_API int remove_place(void *handle, int place_id)
 125 {
 126         MOD_LOGD("remove_place");
 127         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 128         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 129
 130         int ret = geo_client_delete_place(geofence_manager->geofence_client, geofence_manager->app_id, place_id);
 131         if (ret != GEOFENCE_CLIENT_ERROR_NONE)
 132                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 133
 134         return GEOFENCE_MANAGER_ERROR_NONE;
 135 }
 136
 137 EXPORT_API int enable_service(void *handle, int fence_id, bool enable)
 138 {
 139         MOD_LOGD("enable_service");
 140         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 141         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 142
 143         int ret = geo_client_enable_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id, enable);
 144         if (ret != GEOFENCE_CLIENT_ERROR_NONE)
 145                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 146
 147         return GEOFENCE_MANAGER_ERROR_NONE;
 148 }
 149
 150 static void geofence_callback(GVariant *param, void *user_data)
 151 {
 152         g_return_if_fail(user_data);
 153         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)user_data;
 154         int fence_id, access_type, state;
 155         char *app_id = NULL;
 156
 157         g_variant_get(param, "(siii)", &app_id, &fence_id, &access_type, &state);
 158
 159         if (access_type == ACCESS_TYPE_PRIVATE) {
 160                 if (!(g_strcmp0(geofence_manager->app_id, app_id))) {   /*Sending the alert only the app-id matches in case of private fence*/
 161                         if (geofence_manager->geofence_cb)
 162                                 geofence_manager->geofence_cb(fence_id, state, geofence_manager->userdata);
 163                 }
 164         } else {
 165                 if (geofence_manager->geofence_cb)      /*Here filteration is done in the manager as public fences cannot be restricted/filtered.*/
 166                         geofence_manager->geofence_cb(fence_id, state, geofence_manager->userdata);
 167         }
 168 }
 169
 170 static void geofence_proximity_callback(GVariant *param, void *user_data)
 171 {
 172         g_return_if_fail(user_data);
 173         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)user_data;
 174         int fence_id, access_type, proximity_state, provider;
 175         char *app_id = NULL;
 176
 177         g_variant_get(param, "(siiii)", &app_id, &fence_id, &access_type, &proximity_state, &provider);
 178
 179         if (access_type == ACCESS_TYPE_PRIVATE) {
 180                 if (!(g_strcmp0(geofence_manager->app_id, app_id))) {   /*Sending the alert only the app-id matches in case of private fence*/
 181                         if (geofence_manager->geofence_proximity_cb)
 182                                 geofence_manager->geofence_proximity_cb(fence_id, proximity_state, provider, geofence_manager->userdata);
 183                 }
 184         } else {
 185                 if (geofence_manager->geofence_proximity_cb)      /*Here filteration is done in the manager as public fences cannot be restricted/filtered.*/
 186                         geofence_manager->geofence_proximity_cb(fence_id, proximity_state, provider, geofence_manager->userdata);
 187         }
 188 }
 189
 190 static void geofence_event_callback(GVariant *param, void *user_data)
 191 {
 192         g_return_if_fail(user_data);
 193         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)user_data;
 194         int place_id, fence_id, access_type, error, state;
 195         char *app_id = NULL;
 196
 197         g_variant_get(param, "(iiisii)", &place_id, &fence_id, &access_type, &app_id, &error, &state);
 198
 199
 200         MOD_LOGD("place_id: %d, fence_id: %d, Error: %d, State: %d(0x%x", place_id, fence_id, error, state, state);
 201         MOD_LOGD("app_id: %s", geofence_manager->app_id);
 202
 203         if (access_type == ACCESS_TYPE_PUBLIC) {
 204                 if (!g_strcmp0(app_id, MYPLACES_APP_ID) || !g_strcmp0(geofence_manager->app_id, app_id)) {
 205                         if (geofence_manager->geofence_event_cb)
 206                                 geofence_manager->geofence_event_cb(place_id, fence_id, error, state, geofence_manager->userdata);
 207                 }
 208         } else {
 209                 if (!(g_strcmp0(geofence_manager->app_id, app_id))) {
 210                         if (geofence_manager->geofence_event_cb)
 211                                 geofence_manager->geofence_event_cb(place_id, fence_id, error, state, geofence_manager->userdata);
 212                 }
 213         }
 214 }
 215
 216 EXPORT_API int get_place_name(void *handle, int place_id, char **place_name)
 217 {
 218         GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle;
 219         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 220         g_return_val_if_fail(place_name, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 221
 222         int error_code = GEOFENCE_MANAGER_ERROR_NONE;
 223         int ret = geo_client_get_place_name(geofence_manager->geofence_client, geofence_manager->app_id, place_id, place_name, &error_code);
 224         if (ret != GEOFENCE_CLIENT_ERROR_NONE)
 225                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 226         return error_code;
 227 }
 228
 229 EXPORT_API int get_geofences(void *handle, int place_id, int *fence_amount, int **fence_ids, geofence_s **params)
 230 {
 231         GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle;
 232         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 233         g_return_val_if_fail(fence_amount, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 234         g_return_val_if_fail(fence_ids, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 235         g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 236
 237         if (!geofence_manager) {
 238                 *fence_amount = 0;
 239                 return GEOFENCE_MANAGER_ERROR_NONE;
 240         }
 241         int index = 0;
 242         GVariantIter *iter = NULL;
 243         GVariantIter *iter_row = NULL;
 244         gchar *key;
 245         GVariant *value;
 246         int fence_cnt = 0;
 247         int error_code = GEOFENCE_MANAGER_ERROR_NONE;
 248
 249         int ret = geo_client_get_geofences(geofence_manager->geofence_client, geofence_manager->app_id, place_id, &iter, &fence_cnt, &error_code);
 250         if (error_code != GEOFENCE_MANAGER_ERROR_NONE)
 251                 return error_code;
 252         else if (ret != GEOFENCE_MANAGER_ERROR_NONE)
 253                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 254
 255         *fence_amount = fence_cnt;
 256         MOD_LOGD("Total fence count : %d", *fence_amount);
 257         int *fence_id_array = (int *) g_slice_alloc0(sizeof(int) * fence_cnt);
 258         geofence_s *p = (geofence_s *) g_slice_alloc0(sizeof(geofence_s) * fence_cnt);
 259
 260         if (iter == NULL) {
 261                 MOD_LOGI("Iterator is null");
 262         }
 263         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 264                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 265                         if (!g_strcmp0(key, "fence_id")) {
 266                                 fence_id_array[index] =
 267                                     g_variant_get_int32(value);
 268                         } else if (!g_strcmp0(key, "place_id")) {
 269                                 p[index].place_id = g_variant_get_int32(value);
 270                         } else if (!g_strcmp0(key, "geofence_type")) {
 271                                 p[index].type = g_variant_get_int32(value);
 272                         } else if (!g_strcmp0(key, "latitude")) {
 273                                 p[index].latitude = g_variant_get_double(value);
 274                         } else if (!g_strcmp0(key, "longitude")) {
 275                                 p[index].longitude = g_variant_get_double(value);
 276                         } else if (!g_strcmp0(key, "radius")) {
 277                                 p[index].radius = g_variant_get_int32(value);
 278                         } else if (!g_strcmp0(key, "address")) {
 279                                 g_strlcpy(p[index].address, g_variant_get_string(value, NULL), ADDRESS_LEN);
 280                         } else if (!g_strcmp0(key, "bssid")) {
 281                                 g_strlcpy(p[index].bssid, g_variant_get_string(value, NULL), WLAN_BSSID_LEN);
 282                         } else if (!g_strcmp0(key, "ssid")) {
 283                                 g_strlcpy(p[index].ssid, g_variant_get_string(value, NULL), WLAN_BSSID_LEN);
 284                         }
 285                 }
 286                 MOD_LOGI("Fence_id: %d, Place_id: %d, Type: %d, lat: %f, lon: %f, rad: %d, address: %s, bssid: %s, ssid: %s", fence_id_array[index], p[index].place_id, p[index].type, p[index].latitude, p[index].longitude, p[index].radius, p[index].address, p[index].bssid, p[index].ssid);
 287                 index++;
 288                 g_variant_iter_free(iter_row);
 289         }
 290         g_variant_iter_free(iter);
 291         *params = (geofence_s *) p;
 292         *fence_ids = fence_id_array;
 293
 294         return GEOFENCE_MANAGER_ERROR_NONE;
 295 }
 296
 297 EXPORT_API int get_places(void *handle, int *place_amount, int **place_ids, place_s **params)
 298 {
 299         GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle;
 300         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 301         g_return_val_if_fail(place_amount, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 302         g_return_val_if_fail(place_ids, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 303         g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 304
 305         if (!geofence_manager) {
 306                 *place_amount = 0;
 307                 return GEOFENCE_MANAGER_ERROR_NONE;
 308         }
 309         int index = 0;
 310         GVariantIter *iter = NULL;
 311         GVariantIter *iter_row = NULL;
 312         gchar *key;
 313         GVariant *value;
 314         int place_cnt = 0;
 315         int error_code = -1;
 316
 317         /*Call the geofence_client api here....*/
 318         geo_client_get_places(geofence_manager->geofence_client, geofence_manager->app_id, &iter, &place_cnt, &error_code);
 319         if (error_code != GEOFENCE_MANAGER_ERROR_NONE)
 320                 return error_code;
 321
 322         *place_amount = place_cnt;
 323         MOD_LOGI("Total place count : %d", *place_amount);
 324         int *place_id_array = (int *)g_slice_alloc0(sizeof(int) * place_cnt);
 325         place_s *p = (place_s *)g_slice_alloc0(sizeof(place_s) * place_cnt);
 326
 327         if (iter == NULL)
 328                 MOD_LOGI("Iterator is null");
 329
 330         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 331                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 332                         if (!g_strcmp0(key, "place_id")) {
 333                                 place_id_array[index] = g_variant_get_int32(value);
 334                         } else if (!g_strcmp0(key, "place_name")) {
 335                                 g_strlcpy(p[index].place_name, g_variant_get_string(value, NULL), PLACE_NAME_LEN);
 336                         }
 337                 }
 338                 MOD_LOGI("place_id: %d, place_name: %s", place_id_array[index], p[index].place_name);
 339                 index++;
 340                 g_variant_iter_free(iter_row);
 341         }
 342         g_variant_iter_free(iter);
 343         *params = (place_s *)p;
 344
 345         *place_ids = place_id_array;
 346
 347         return GEOFENCE_MANAGER_ERROR_NONE;
 348 }
 349
 350 static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_data)
 351 {
 352         if (!g_strcmp0(sig, "GeofenceInout")) {
 353                 MOD_LOGD("GeofenceInoutChanged");
 354                 geofence_callback(param, user_data);
 355         } else if (!g_strcmp0(sig, "GeofenceProximity")) {
 356                 MOD_LOGD("GeofenceProximityChanged");
 357                 geofence_proximity_callback(param, user_data);
 358         } else if (!g_strcmp0(sig, "GeofenceEvent")) {
 359                 MOD_LOGD("GeofenceEventInvoked");
 360                 geofence_event_callback(param, user_data);
 361         } else {
 362                 MOD_LOGD("Invalid signal[%s]", sig);
 363         }
 364 }
 365
 366 EXPORT_API int start_geofence(void *handle, int fence_id)
 367 {
 368         MOD_LOGD("start_geofence");
 369         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 370         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION);
 371
 372         int ret = GEOFENCE_MANAGER_ERROR_NONE;
 373
 374         MOD_LOGD("geofence-server(%x)", geofence_manager);
 375
 376         ret = geo_client_start_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id);
 377         if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
 378                 MOD_LOGE("Fail to start geofence_client_h. Error[%d]", ret);
 379                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 380         }
 381
 382         return GEOFENCE_MANAGER_ERROR_NONE;
 383 }
 384
 385 EXPORT_API int stop_geofence(void *handle, int fence_id)
 386 {
 387         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 388         MOD_LOGD("geofence_manager->geofence_cb : %x", geofence_manager->geofence_cb);
 389         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 390         g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 391
 392         int ret = GEOFENCE_CLIENT_ERROR_NONE;
 393
 394         ret = geo_client_stop_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id);
 395         if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
 396                 MOD_LOGE("Fail to stop. Error[%d]", ret);
 397                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 398         }
 399
 400         return GEOFENCE_MANAGER_ERROR_NONE;
 401 }
 402
 403 EXPORT_API int create(void *handle, GeofenceModCB geofence_cb, GeofenceModProximityCB geofence_proximity_cb, GeofenceModEventCB geofence_event_cb, void *userdata)
 404 {
 405         GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle;
 406         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 407         g_return_val_if_fail(geofence_cb, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 408
 409         /* create connnection */
 410         int ret = GEOFENCE_MANAGER_ERROR_NONE;
 411
 412         geofence_manager->geofence_cb = geofence_cb;
 413         geofence_manager->geofence_proximity_cb = geofence_proximity_cb;
 414         geofence_manager->geofence_event_cb = geofence_event_cb;
 415         geofence_manager->userdata = userdata;
 416
 417         ret = geo_client_create(&(geofence_manager->geofence_client));
 418         if (ret != GEOFENCE_CLIENT_ERROR_NONE || !geofence_manager->geofence_client) {
 419                 MOD_LOGE("Fail to create geofence_client_dbus_h. Error[%d]", ret);
 420                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 421         }
 422
 423         MOD_LOGD("geofence_manager->geofence_client: %p", geofence_manager->geofence_client);
 424         ret = geo_client_start(geofence_manager->geofence_client, on_signal_callback, geofence_manager);
 425 #if 0
 426         ret = geo_client_start(geofence_manager->geofence_client, on_signal_callback, geofence_manager);
 427 #endif
 428
 429         if (ret != GEOFENCE_CLIENT_ERROR_NONE) {
 430                 if (ret == GEOFENCE_CLIENT_ACCESS_DENIED) {
 431                         MOD_LOGE("Access denied[%d]", ret);
 432                         return GEOFENCE_CLIENT_ACCESS_DENIED;
 433                 }
 434                 MOD_LOGE("Fail to start geofence_client_dbus_h. Error[%d]", ret);
 435                 geo_client_destroy(geofence_manager->geofence_client);
 436                 geofence_manager->geofence_client = NULL;
 437
 438                 return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
 439         }
 440
 441         return GEOFENCE_MANAGER_ERROR_NONE;
 442 }
 443
 444 EXPORT_API int destroy(void *handle)
 445 {
 446         MOD_LOGD("destroy");
 447
 448         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 449         g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 450         g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER);
 451
 452         int ret = GEOFENCE_MANAGER_ERROR_NONE;
 453
 454         ret = geo_client_stop(geofence_manager->geofence_client);
 455         if (ret != GEOFENCE_CLIENT_ERROR_NONE) {
 456                 MOD_LOGE("Fail to stop. Error[%d]", ret);
 457                 geo_client_destroy(geofence_manager->geofence_client);
 458                 geofence_manager->geofence_client = NULL;
 459                 return GEOFENCE_MANAGER_ERROR_IPC;
 460         }
 461
 462         ret = geo_client_destroy(geofence_manager->geofence_client);
 463         if (ret != GEOFENCE_CLIENT_ERROR_NONE) {
 464                 MOD_LOGE("Fail to destroy. Error[%d]", ret);
 465                 return GEOFENCE_MANAGER_ERROR_IPC;
 466         }
 467         geofence_manager->geofence_client = NULL;
 468         geofence_manager->geofence_cb = NULL;
 469         geofence_manager->geofence_event_cb = NULL;
 470         geofence_manager->userdata = NULL;
 471
 472         return GEOFENCE_MANAGER_ERROR_NONE;
 473 }
 474
 475 static void __get_caller_app_id(void *handle)
 476 {
 477         GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle;
 478         g_return_if_fail(geofence_manager);
 479
 480         gchar *app_id = NULL;
 481         int ret = 0;
 482
 483         pid_t pid = 0;
 484         pid = getpid();
 485         ret = app_manager_get_app_id(pid, &app_id);
 486         if (ret != APP_MANAGER_ERROR_NONE) {
 487                 MOD_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
 488         } else {
 489                 MOD_LOGD("app_id: %s", app_id);
 490                 geofence_manager->app_id = app_id;
 491         }
 492 }
 493
 494 EXPORT_API gpointer init(GeofenceModOps *ops)
 495 {
 496         MOD_LOGD("init");
 497
 498         g_return_val_if_fail(ops, NULL);
 499         ops->create = create;
 500         ops->destroy = destroy;
 501         ops->enable_service = enable_service;
 502         ops->start_geofence = start_geofence;
 503         ops->stop_geofence = stop_geofence;
 504         ops->add_geopoint = add_geopoint;
 505         ops->add_bssid = add_bssid;
 506         ops->remove_geofence = remove_geofence;
 507         ops->get_geofences = get_geofences;
 508
 509         ops->add_place = add_place;
 510         ops->update_place = update_place;
 511         ops->remove_place = remove_place;
 512         ops->get_place_name = get_place_name;
 513         ops->get_places = get_places;
 514
 515         GeofenceManagerData *geofence_manager = g_new0(GeofenceManagerData, 1);
 516         g_return_val_if_fail(geofence_manager, NULL);
 517
 518         geofence_manager->geofence_cb = NULL;
 519         geofence_manager->geofence_proximity_cb = NULL;
 520         geofence_manager->geofence_event_cb = NULL;
 521         geofence_manager->userdata = NULL;
 522
 523         __get_caller_app_id(geofence_manager);
 524
 525         return (gpointer) geofence_manager;
 526 }
 527
 528 EXPORT_API void shutdown(gpointer handle)
 529 {
 530         MOD_LOGD("shutdown");
 531         g_return_if_fail(handle);
 532         GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle;
 533
 534         if (geofence_manager->geofence_client) {
 535                 geo_client_stop(geofence_manager->geofence_client);
 536                 geo_client_destroy(geofence_manager->geofence_client);
 537                 geofence_manager->geofence_client = NULL;
 538         }
 539
 540         geofence_manager->geofence_cb = NULL;
 541         g_free(geofence_manager->app_id);
 542         g_free(geofence_manager);
 543         geofence_manager = NULL;
 544 }