src/badge_service.c

   1 /*
   2  * Copyright 2016  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <dlog.h>
  18 #include <gio/gio.h>
  19 #include <sys/smack.h>
  20 #include <badge.h>
  21 #include <badge_db.h>
  22 #include <badge_setting_service.h>
  23 #include <badge_internal.h>
  24 #include <tzplatform_config.h>
  25
  26 #include "service_common.h"
  27 #include "badge_service.h"
  28 #include "debug.h"
  29
  30 #define PROVIDER_BADGE_INTERFACE_NAME "org.tizen.data_provider_badge_service"
  31 static GHashTable *_monitoring_hash = NULL;
  32
  33 static void _on_name_appeared(GDBusConnection *connection,
  34                 const gchar     *name,
  35                 const gchar     *name_owner,
  36                 gpointer         user_data)
  37 {
  38         DbgPrint("name appeared : %s", name);
  39 }
  40
  41 static void _on_name_vanished(GDBusConnection *connection,
  42                 const gchar     *name,
  43                 gpointer         user_data)
  44 {
  45         DbgPrint("name vanished : %s", name);
  46         monitoring_info_s *info = (monitoring_info_s *)user_data;
  47         if (info) {
  48                 DbgPrint("name vanished uid : %d", info->uid);
  49                 g_bus_unwatch_name(info->watcher_id);
  50         }
  51 }
  52
  53 static void _badge_dbus_method_call_handler(GDBusConnection *conn,
  54                 const gchar *sender, const gchar *object_path,
  55                 const gchar *iface_name, const gchar *method_name,
  56                 GVariant *parameters, GDBusMethodInvocation *invocation,
  57                 gpointer user_data)
  58 {
  59         DbgPrint("badge method_name: %s", method_name);
  60
  61         GVariant *reply_body = NULL;
  62         int ret = BADGE_ERROR_INVALID_PARAMETER;
  63         uid_t uid = get_sender_uid(sender);
  64
  65         if (g_strcmp0(method_name, "badge_service_register") == 0)
  66                 ret = service_register(parameters, &reply_body, sender,
  67                                 _on_name_appeared, _on_name_vanished, &_monitoring_hash, uid);
  68         else if (g_strcmp0(method_name, "get_badge_existing") == 0)
  69                 ret = badge_get_badge_existing(parameters, &reply_body, uid);
  70         else if (g_strcmp0(method_name, "get_list") == 0)
  71                 ret = badge_get_badge_list(parameters, &reply_body, uid);
  72         else if (g_strcmp0(method_name, "insert_badge") == 0)
  73                 ret = badge_insert(parameters, &reply_body, uid);
  74         else if (g_strcmp0(method_name, "delete_badge") == 0)
  75                 ret = badge_delete(parameters, &reply_body, uid);
  76         else if (g_strcmp0(method_name, "set_badge_count") == 0)
  77                 ret = badge_set_badge_count(parameters, &reply_body, uid);
  78         else if (g_strcmp0(method_name, "get_badge_count") == 0)
  79                 ret = badge_get_badge_count(parameters, &reply_body, uid);
  80         else if (g_strcmp0(method_name, "set_disp_option") == 0)
  81                 ret = badge_set_display_option(parameters, &reply_body, uid);
  82         else if (g_strcmp0(method_name, "get_disp_option") == 0)
  83                 ret = badge_get_display_option(parameters, &reply_body, uid);
  84         else if (g_strcmp0(method_name, "set_noti_property") == 0)
  85                 ret = badge_set_setting_property(parameters, &reply_body, uid);
  86         else if (g_strcmp0(method_name, "get_noti_property") == 0)
  87                 ret = badge_get_setting_property(parameters, &reply_body, uid);
  88
  89         if (ret == BADGE_ERROR_NONE) {
  90                 DbgPrint("badge service success : %d", ret);
  91                 g_dbus_method_invocation_return_value(
  92                                 invocation, reply_body);
  93         } else {
  94                 DbgPrint("badge service fail : %d", ret);
  95                 g_dbus_method_invocation_return_error(
  96                                 invocation,
  97                                 BADGE_ERROR,
  98                                 ret,
  99                                 "badge service error");
 100         }
 101 }
 102
 103 static const GDBusInterfaceVTable _badge_interface_vtable = {
 104                 _badge_dbus_method_call_handler,
 105                 NULL,
 106                 NULL
 107 };
 108
 109 int badge_register_dbus_interface()
 110 {
 111         static gchar introspection_xml[] =
 112                         "  <node>"
 113                         "  <interface name='org.tizen.data_provider_badge_service'>"
 114                         "        <method name='badge_service_register'>"
 115                         "          <arg type='i' name='uid' direction='in'/>"
 116                         "        </method>"
 117                         "        <method name='get_badge_existing'>"
 118                         "          <arg type='s' name='pkgname' direction='in'/>"
 119                         "          <arg type='i' name='uid' direction='in'/>"
 120                         "          <arg type='i' name='exist' direction='out'/>"
 121                         "        </method>"
 122                         "        <method name='get_list'>"
 123                         "          <arg type='i' name='uid' direction='in'/>"
 124                         "          <arg type='a(v)' name='badge_list' direction='out'/>"
 125                         "        </method>"
 126                         "        <method name='insert_badge'>"
 127                         "          <arg type='s' name='pkgname' direction='in'/>"
 128                         "          <arg type='s' name='writable_pkg' direction='in'/>"
 129                         "          <arg type='s' name='caller' direction='in'/>"
 130                         "          <arg type='i' name='uid' direction='in'/>"
 131                         "        </method>"
 132
 133                         "        <method name='delete_badge'>"
 134                         "          <arg type='s' name='pkgname' direction='in'/>"
 135                         "          <arg type='s' name='caller' direction='in'/>"
 136                         "          <arg type='i' name='uid' direction='in'/>"
 137                         "        </method>"
 138
 139                         "        <method name='set_badge_count'>"
 140                         "          <arg type='s' name='pkgname' direction='in'/>"
 141                         "          <arg type='s' name='caller' direction='in'/>"
 142                         "          <arg type='i' name='count' direction='in'/>"
 143                         "          <arg type='i' name='uid' direction='in'/>"
 144                         "        </method>"
 145
 146                         "        <method name='get_badge_count'>"
 147                         "          <arg type='s' name='pkgname' direction='in'/>"
 148                         "          <arg type='i' name='uid' direction='in'/>"
 149                         "          <arg type='i' name='count' direction='out'/>"
 150                         "        </method>"
 151
 152                         "        <method name='set_disp_option'>"
 153                         "          <arg type='s' name='pkgname' direction='in'/>"
 154                         "          <arg type='s' name='caller' direction='in'/>"
 155                         "          <arg type='i' name='is_display' direction='in'/>"
 156                         "          <arg type='i' name='uid' direction='in'/>"
 157                         "        </method>"
 158
 159                         "        <method name='get_disp_option'>"
 160                         "          <arg type='s' name='pkgname' direction='in'/>"
 161                         "          <arg type='i' name='uid' direction='in'/>"
 162                         "          <arg type='i' name='is_display' direction='out'/>"
 163                         "        </method>"
 164
 165                         "        <method name='set_noti_property'>"
 166                         "          <arg type='s' name='pkgname' direction='in'/>"
 167                         "          <arg type='s' name='property' direction='in'/>"
 168                         "          <arg type='s' name='value' direction='in'/>"
 169                         "          <arg type='i' name='uid' direction='in'/>"
 170                         "        </method>"
 171
 172                         "        <method name='get_noti_property'>"
 173                         "          <arg type='s' name='pkgname' direction='in'/>"
 174                         "          <arg type='s' name='property' direction='in'/>"
 175                         "          <arg type='i' name='uid' direction='in'/>"
 176                         "          <arg type='s' name='value' direction='out'/>"
 177                         "        </method>"
 178                         "  </interface>"
 179                         "  </node>";
 180
 181         return service_common_register_dbus_interface(introspection_xml, _badge_interface_vtable);
 182 }
 183
 184 static int _validate_and_set_param_uid_with_uid(uid_t uid, uid_t *param_uid)
 185 {
 186         int ret = BADGE_ERROR_NONE;
 187
 188         if (uid > NORMAL_UID_BASE && uid != *param_uid) {
 189                 ErrPrint("invalid sender uid : %d, param_uid : %d", uid, *param_uid);
 190                 return BADGE_ERROR_INVALID_PARAMETER;
 191         } else if (uid <= NORMAL_UID_BASE) {
 192                 if (*param_uid <= NORMAL_UID_BASE) {
 193                         if (*param_uid != uid)
 194                                 return BADGE_ERROR_INVALID_PARAMETER;
 195                         *param_uid = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 196                 }
 197         }
 198         return ret;
 199 }
 200
 201 static void _release_badge_info(gpointer data)
 202 {
 203         badge_info_s *badge = (badge_info_s *)data;
 204         if (badge == NULL)
 205                 return;
 206         if (badge->pkg)
 207                 free(badge->pkg);
 208         free(badge);
 209 }
 210
 211 /* get_badge_existing */
 212 int badge_get_badge_existing(GVariant *parameters, GVariant **reply_body, uid_t uid)
 213 {
 214         int ret = BADGE_ERROR_NONE;
 215         char *pkgname = NULL;
 216         bool existing = 0;
 217         uid_t param_uid;
 218
 219         g_variant_get(parameters, "(&si)", &pkgname, &param_uid);
 220         DbgPrint("badge_get_badge_existing %s", pkgname);
 221
 222         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 223         if (ret != BADGE_ERROR_NONE)
 224                 return ret;
 225
 226         if (pkgname != NULL)
 227                 ret = badge_db_is_existing(pkgname, &existing, param_uid);
 228         else
 229                 return BADGE_ERROR_INVALID_PARAMETER;
 230
 231         if (ret != BADGE_ERROR_NONE) {
 232                 ErrPrint("failed to get badge existing :%d\n", ret);
 233                 return ret;
 234         }
 235
 236         *reply_body = g_variant_new("(i)", existing);
 237         if (*reply_body == NULL) {
 238                 ErrPrint("cannot make gvariant to noti");
 239                 return BADGE_ERROR_OUT_OF_MEMORY;
 240         }
 241         DbgPrint("badge_get_badge_existing service done");
 242         return ret;
 243 }
 244
 245 /* get_list */
 246 int badge_get_badge_list(GVariant *parameters, GVariant **reply_body, uid_t uid)
 247 {
 248         GList *badge_list = NULL;
 249         GList *iter_list = NULL;
 250         GVariant *body = NULL;
 251         badge_info_s *badge;
 252         GVariantBuilder *builder;
 253         int ret;
 254         uid_t param_uid;
 255
 256         g_variant_get(parameters, "(i)", &param_uid);
 257
 258         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 259         if (ret != BADGE_ERROR_NONE)
 260                 return ret;
 261
 262         ret = badge_db_get_list(&badge_list, param_uid);
 263         if (ret != BADGE_ERROR_NONE) {
 264                 ErrPrint("badge get list fail : %d", ret);
 265                 return ret;
 266         }
 267
 268         builder = g_variant_builder_new(G_VARIANT_TYPE("a(v)"));
 269         iter_list = g_list_first(badge_list);
 270         for (; iter_list != NULL; iter_list = iter_list->next) {
 271                 badge = iter_list->data;
 272                 body = g_variant_new("(si)", badge->pkg, badge->badge_count);
 273                 g_variant_builder_add(builder, "(v)", body);
 274         }
 275         g_list_free_full(badge_list, (GDestroyNotify)_release_badge_info);
 276
 277         *reply_body = g_variant_new("(a(v))", builder);
 278         g_variant_builder_unref(builder);
 279
 280         if (*reply_body == NULL) {
 281                 ErrPrint("cannot make reply_body");
 282                 return BADGE_ERROR_OUT_OF_MEMORY;
 283         }
 284
 285         DbgPrint("badge_get_badge_list done !!");
 286         return BADGE_ERROR_NONE;
 287 }
 288
 289 /* insert_badge */
 290 int badge_insert(GVariant *parameters, GVariant **reply_body, uid_t uid)
 291 {
 292         int ret = BADGE_ERROR_NONE;
 293         char *pkgname = NULL;
 294         char *writable_pkg = NULL;
 295         char *caller = NULL;
 296         GVariant *body = NULL;
 297         GList *monitoring_list = NULL;
 298         uid_t param_uid;
 299
 300         g_variant_get(parameters, "(&s&s&si)", &pkgname, &writable_pkg, &caller, &param_uid);
 301
 302         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 303         if (ret != BADGE_ERROR_NONE)
 304                 return ret;
 305
 306         if (pkgname != NULL && writable_pkg != NULL && caller != NULL)
 307                 ret = badge_db_insert(pkgname, writable_pkg, caller, param_uid);
 308         else
 309                 return BADGE_ERROR_INVALID_PARAMETER;
 310
 311         if (ret != BADGE_ERROR_NONE) {
 312                 ErrPrint("failed to insert badge :%d\n", ret);
 313                 return ret;
 314         }
 315
 316         body = g_variant_new("(si)", pkgname, param_uid);
 317         if (body == NULL) {
 318                 ErrPrint("cannot make gvariant to noti");
 319                 return BADGE_ERROR_OUT_OF_MEMORY;
 320         }
 321
 322         monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
 323         ret = send_notify(body, "insert_badge_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
 324         g_variant_unref(body);
 325
 326         if (ret != BADGE_ERROR_NONE) {
 327                 ErrPrint("failed to send notify:%d\n", ret);
 328                 return ret;
 329         }
 330
 331         *reply_body = g_variant_new("()");
 332         if (*reply_body == NULL) {
 333                 ErrPrint("cannot make gvariant to noti");
 334                 return BADGE_ERROR_OUT_OF_MEMORY;
 335         }
 336
 337         return ret;
 338 }
 339
 340 /* delete_badge */
 341 int badge_delete(GVariant *parameters, GVariant **reply_body, uid_t uid)
 342 {
 343         int ret = BADGE_ERROR_NONE;
 344         char *pkgname = NULL;
 345         char *caller = NULL;
 346         GVariant *body = NULL;
 347         GList *monitoring_list = NULL;
 348         uid_t param_uid;
 349
 350         g_variant_get(parameters, "(&s&si)", &pkgname, &caller, &param_uid);
 351
 352         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 353         if (ret != BADGE_ERROR_NONE)
 354                 return ret;
 355
 356         if (pkgname != NULL && caller != NULL) {
 357                 ret = badge_db_delete(pkgname, caller, param_uid);
 358         } else {
 359                 return BADGE_ERROR_INVALID_PARAMETER;
 360         }
 361
 362         if (ret != BADGE_ERROR_NONE) {
 363                 ErrPrint("failed to delete badge :%d\n", ret);
 364                 return ret;
 365         }
 366
 367         body = g_variant_new("(si)", pkgname, param_uid);
 368         if (body == NULL) {
 369                 ErrPrint("cannot make gvariant to noti");
 370                 return BADGE_ERROR_OUT_OF_MEMORY;
 371         }
 372
 373         monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
 374         ret = send_notify(body, "delete_badge_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
 375         g_variant_unref(body);
 376
 377         if (ret != BADGE_ERROR_NONE) {
 378                 ErrPrint("failed to send notify:%d\n", ret);
 379                 return ret;
 380         }
 381
 382         *reply_body = g_variant_new("()");
 383         if (*reply_body == NULL) {
 384                 ErrPrint("cannot make gvariant to noti");
 385                 return BADGE_ERROR_OUT_OF_MEMORY;
 386         }
 387         return ret;
 388 }
 389
 390 /* set_badge_count */
 391 int badge_set_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid)
 392 {
 393         int ret = BADGE_ERROR_NONE;
 394         char *pkgname = NULL;
 395         char *caller = NULL;
 396         unsigned int count = 0;
 397         GVariant *body = NULL;
 398         GList *monitoring_list = NULL;
 399         uid_t param_uid;
 400
 401         g_variant_get(parameters, "(&s&sii)", &pkgname, &caller, &count, &param_uid);
 402
 403         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 404         if (ret != BADGE_ERROR_NONE)
 405                 return ret;
 406
 407         if (pkgname != NULL && caller != NULL)
 408                 ret = badge_db_set_count(pkgname, caller, count, param_uid);
 409         else
 410                 return BADGE_ERROR_INVALID_PARAMETER;
 411
 412         if (ret != BADGE_ERROR_NONE) {
 413                 ErrPrint("failed to set badge :%d\n", ret);
 414                 return ret;
 415         }
 416
 417         body = g_variant_new("(sii)", pkgname, count, param_uid);
 418         if (body == NULL) {
 419                 ErrPrint("cannot make gvariant to noti");
 420                 return BADGE_ERROR_OUT_OF_MEMORY;
 421         }
 422
 423         monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
 424         ret = send_notify(body, "set_badge_count_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
 425         g_variant_unref(body);
 426
 427         if (ret != BADGE_ERROR_NONE) {
 428                 ErrPrint("failed to send notify:%d\n", ret);
 429                 return ret;
 430         }
 431         DbgPrint("send badge count notify done ret : %d", ret);
 432
 433         *reply_body = g_variant_new("()");
 434         if (*reply_body == NULL) {
 435                 ErrPrint("cannot make gvariant to noti");
 436                 return BADGE_ERROR_OUT_OF_MEMORY;
 437         }
 438         return ret;
 439 }
 440
 441 /* get_badge_count */
 442 int badge_get_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid)
 443 {
 444         int ret = BADGE_ERROR_NONE;
 445         char *pkgname = NULL;
 446         unsigned int count = 0;
 447         uid_t param_uid;
 448
 449         g_variant_get(parameters, "(&si)", &pkgname, &param_uid);
 450
 451         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 452         if (ret != BADGE_ERROR_NONE)
 453                 return ret;
 454
 455         if (pkgname != NULL)
 456                 ret =  badge_db_get_count(pkgname, &count, param_uid);
 457         else
 458                 return BADGE_ERROR_INVALID_PARAMETER;
 459
 460         if (ret != BADGE_ERROR_NONE) {
 461                 ErrPrint("failed to get badge count :%d\n", ret);
 462                 return ret;
 463         }
 464
 465         *reply_body = g_variant_new("(i)", count);
 466         if (*reply_body == NULL) {
 467                 ErrPrint("cannot make gvariant to noti");
 468                 return BADGE_ERROR_OUT_OF_MEMORY;
 469         }
 470         DbgPrint("badge_get_badge_count service done");
 471         return ret;
 472 }
 473
 474 /* set_disp_option */
 475 int badge_set_display_option(GVariant *parameters, GVariant **reply_body, uid_t uid)
 476 {
 477         int ret = BADGE_ERROR_NONE;
 478         char *pkgname = NULL;
 479         char *caller = NULL;
 480         unsigned int is_display = 0;
 481         GVariant *body = NULL;
 482         GList *monitoring_list = NULL;
 483         uid_t param_uid;
 484
 485         g_variant_get(parameters, "(&s&sii)", &pkgname, &caller, &is_display, &param_uid);
 486
 487         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 488         if (ret != BADGE_ERROR_NONE)
 489                 return ret;
 490
 491         DbgPrint("set disp option : %s, %s, %d", pkgname, caller, is_display);
 492
 493         if (pkgname != NULL && caller != NULL)
 494                 ret = badge_db_set_display_option(pkgname, is_display, param_uid);
 495         else
 496                 return BADGE_ERROR_INVALID_PARAMETER;
 497
 498         if (ret != BADGE_ERROR_NONE) {
 499                 ErrPrint("failed to set display option :%d\n", ret);
 500                 return ret;
 501         }
 502
 503         body = g_variant_new("(sii)", pkgname, is_display, param_uid);
 504         if (body == NULL) {
 505                 ErrPrint("cannot make gvariant to noti");
 506                 return BADGE_ERROR_OUT_OF_MEMORY;
 507         }
 508
 509         monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
 510         ret = send_notify(body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
 511         g_variant_unref(body);
 512
 513         if (ret != BADGE_ERROR_NONE) {
 514                 ErrPrint("failed to send notify:%d\n", ret);
 515                 return ret;
 516         }
 517
 518         *reply_body = g_variant_new("()");
 519         if (*reply_body == NULL) {
 520                 ErrPrint("cannot make gvariant to noti");
 521                 return BADGE_ERROR_OUT_OF_MEMORY;
 522         }
 523         DbgPrint("set disp option done %d", ret);
 524         return ret;
 525 }
 526
 527 /* get_disp_option */
 528 int badge_get_display_option(GVariant *parameters, GVariant **reply_body, uid_t uid)
 529 {
 530         int ret = BADGE_ERROR_NONE;
 531         char *pkgname = NULL;
 532         unsigned int is_display = 0;
 533         uid_t param_uid;
 534
 535         g_variant_get(parameters, "(&si)", &pkgname, &param_uid);
 536
 537         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 538         if (ret != BADGE_ERROR_NONE)
 539                 return ret;
 540
 541         DbgPrint("get disp option : %s", pkgname);
 542
 543         if (pkgname != NULL)
 544                 ret = badge_db_get_display_option(pkgname, &is_display, param_uid);
 545         else
 546                 return BADGE_ERROR_INVALID_PARAMETER;
 547
 548         if (ret != BADGE_ERROR_NONE) {
 549                 ErrPrint("failed to get display option :%d\n", ret);
 550                 return ret;
 551         }
 552
 553         *reply_body = g_variant_new("(i)", is_display);
 554         if (*reply_body == NULL) {
 555                 ErrPrint("cannot make gvariant to noti");
 556                 return BADGE_ERROR_OUT_OF_MEMORY;
 557         }
 558         return ret;
 559 }
 560
 561 /* set_noti_property */
 562 int badge_set_setting_property(GVariant *parameters, GVariant **reply_body, uid_t uid)
 563 {
 564         int ret = 0;
 565         int is_display = 0;
 566         char *pkgname = NULL;
 567         char *property = NULL;
 568         char *value = NULL;
 569         GVariant *body = NULL;
 570         GList *monitoring_list = NULL;
 571         uid_t param_uid;
 572
 573         g_variant_get(parameters, "(&s&s&si)", &pkgname, &property, &value, &param_uid);
 574
 575         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 576         if (ret != BADGE_ERROR_NONE)
 577                 return ret;
 578
 579         if (pkgname != NULL && property != NULL && value != NULL)
 580                 ret = badge_setting_db_set(pkgname, property, value, param_uid);
 581         else
 582                 return BADGE_ERROR_INVALID_PARAMETER;
 583
 584         if (ret != BADGE_ERROR_NONE) {
 585                 ErrPrint("failed to setting db set :%d\n", ret);
 586                 return ret;
 587         }
 588
 589         if (ret == BADGE_ERROR_NONE) {
 590                 if (strcmp(property, "OPT_BADGE") == 0) {
 591                         if (strcmp(value, "ON") == 0)
 592                                 is_display = 1;
 593                         else
 594                                 is_display = 0;
 595
 596                         body = g_variant_new("(si)", pkgname, is_display);
 597                         if (body == NULL) {
 598                                 ErrPrint("cannot make gvariant to noti");
 599                                 return BADGE_ERROR_OUT_OF_MEMORY;
 600                         }
 601
 602                         monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
 603                         ret = send_notify(body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
 604                         g_variant_unref(body);
 605                         if (ret != BADGE_ERROR_NONE) {
 606                                 ErrPrint("failed to send notify:%d\n", ret);
 607                                 return ret;
 608                         }
 609                 }
 610         } else {
 611                 ErrPrint("failed to set noti property:%d\n", ret);
 612         }
 613
 614         *reply_body = g_variant_new("()");
 615         if (*reply_body == NULL) {
 616                 ErrPrint("cannot make gvariant to noti");
 617                 return BADGE_ERROR_OUT_OF_MEMORY;
 618         }
 619         return ret;
 620 }
 621
 622 /* get_noti_property */
 623 int badge_get_setting_property(GVariant *parameters, GVariant **reply_body, uid_t uid)
 624 {
 625         int ret = 0;
 626         char *pkgname = NULL;
 627         char *property = NULL;
 628         char *value = NULL;
 629         uid_t param_uid;
 630
 631         g_variant_get(parameters, "(&s&si)", &pkgname, &property, &param_uid);
 632
 633         ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
 634         if (ret != BADGE_ERROR_NONE)
 635                 return ret;
 636
 637         if (pkgname != NULL && property != NULL)
 638                 ret = badge_setting_db_get(pkgname, property, &value, param_uid);
 639         else
 640                 return BADGE_ERROR_INVALID_PARAMETER;
 641
 642         if (ret != BADGE_ERROR_NONE) {
 643                 ErrPrint("failed to setting db get :%d\n", ret);
 644                 return ret;
 645         }
 646
 647         *reply_body = g_variant_new("(s)", value);
 648         if (*reply_body == NULL) {
 649                 ErrPrint("cannot make gvariant to noti");
 650                 return BADGE_ERROR_OUT_OF_MEMORY;
 651         }
 652         return ret;
 653 }
 654
 655 /*!
 656  * MAIN THREAD
 657  * Do not try to do anyother operation in these functions
 658  */
 659 HAPI int badge_service_init(void)
 660 {
 661         int result;
 662
 663         _monitoring_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, free_monitoring_list);
 664         result = badge_db_init();
 665         if (result != BADGE_ERROR_NONE) {
 666                 ErrPrint("badge db init fail %d", result);
 667                 return result;
 668         }
 669
 670         result = badge_register_dbus_interface();
 671         if (result != SERVICE_COMMON_ERROR_NONE) {
 672                 ErrPrint("badge register dbus fail %d", result);
 673                 return BADGE_ERROR_IO_ERROR;
 674         }
 675
 676         return BADGE_ERROR_NONE;
 677 }
 678
 679 HAPI int badge_service_fini(void)
 680 {
 681         return BADGE_ERROR_NONE;
 682 }
 683
 684 /* End of a file */