src/badge.c

   1 /*
   2  *  libbadge
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngjoo Park <yjoo93.park@samsung.com>,
   7  *      Seungtaek Chung <seungtaek.chung@samsung.com>, Youngsub Ko <ys4610.ko@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the License);
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an AS IS BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25
  26 #include "badge.h"
  27 #include "badge_log.h"
  28 #include "badge_error.h"
  29 #include "badge_internal.h"
  30 #include "badge_ipc.h"
  31
  32 EXPORT_API
  33 int badge_create(const char *pkgname, const char *writable_pkg)
  34 {
  35         char *caller = NULL;
  36         int err = BADGE_ERROR_NONE;
  37
  38         if (pkgname == NULL) {
  39                 return BADGE_ERROR_INVALID_PARAMETER;
  40         }
  41
  42         caller = _badge_get_pkgname_by_pid();
  43         if (!caller) {
  44                 ERR("fail to get caller pkgname");
  45                 return BADGE_ERROR_PERMISSION_DENIED;
  46         }
  47
  48         err = badge_ipc_request_insert(pkgname, writable_pkg, caller);
  49
  50         free(caller);
  51         return err;
  52 }
  53
  54 EXPORT_API
  55 int badge_new(const char *writable_app_id)
  56 {
  57         char *caller = NULL;
  58         int err = BADGE_ERROR_NONE;
  59
  60         caller = _badge_get_pkgname_by_pid();
  61         if (!caller) {
  62                 ERR("fail to get caller pkgname");
  63                 return BADGE_ERROR_PERMISSION_DENIED;
  64         }
  65
  66         err = badge_ipc_request_insert(caller, writable_app_id, caller);
  67
  68         free(caller);
  69         return err;
  70 }
  71
  72 EXPORT_API
  73 int badge_remove(const char *app_id)
  74 {
  75         char *caller = NULL;
  76         int result = BADGE_ERROR_NONE;
  77
  78         if (app_id == NULL) {
  79                 return BADGE_ERROR_INVALID_PARAMETER;
  80         }
  81
  82         caller = _badge_get_pkgname_by_pid();
  83         if (!caller) {
  84                 ERR("fail to get caller pkgname");
  85                 return BADGE_ERROR_PERMISSION_DENIED;
  86         }
  87
  88         result = badge_ipc_request_delete(app_id, caller);
  89
  90         free(caller);
  91         return result;
  92 }
  93
  94 EXPORT_API
  95 int badge_is_existing(const char *app_id, bool *existing)
  96 {
  97         return _badge_is_existing(app_id, existing);
  98 }
  99
 100
 101 EXPORT_API
 102 int badge_foreach_existed(badge_cb callback, void *data)
 103 {
 104         return _badge_foreach_existed(callback, data);
 105 }
 106
 107 EXPORT_API
 108 int badge_set_count(const char *app_id, unsigned int count)
 109 {
 110         char *caller = NULL;
 111         int result = BADGE_ERROR_NONE;
 112
 113         if (app_id == NULL) {
 114                 return BADGE_ERROR_INVALID_PARAMETER;
 115         }
 116
 117         caller = _badge_get_pkgname_by_pid();
 118         if (!caller) {
 119                 ERR("fail to get caller pkgname");
 120                 return BADGE_ERROR_PERMISSION_DENIED;
 121         }
 122
 123         result = badge_ipc_request_set_count(app_id, caller, count);
 124
 125         free(caller);
 126         return result;
 127 }
 128
 129 EXPORT_API
 130 int badge_get_count(const char *app_id, unsigned int *count)
 131 {
 132         return _badget_get_count(app_id, count);
 133 }
 134
 135 EXPORT_API
 136 int badge_set_display(const char *app_id, unsigned int is_display)
 137 {
 138         char *caller = NULL;
 139         int result = BADGE_ERROR_NONE;
 140
 141         if (app_id == NULL) {
 142                 return BADGE_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         caller = _badge_get_pkgname_by_pid();
 146         if (!caller) {
 147                 ERR("fail to get caller pkgname");
 148                 return BADGE_ERROR_PERMISSION_DENIED;
 149         }
 150
 151         result = badge_ipc_request_set_display(app_id, caller, is_display);
 152
 153         free(caller);
 154         return result;
 155 }
 156
 157 EXPORT_API
 158 int badge_get_display(const char *app_id, unsigned int *is_display)
 159 {
 160         return _badget_get_display(app_id, is_display);
 161 }
 162
 163 EXPORT_API
 164 int badge_register_changed_cb(badge_change_cb callback, void *data)
 165 {
 166         if (callback == NULL) {
 167                 return BADGE_ERROR_INVALID_PARAMETER;
 168         }
 169
 170         return _badge_register_changed_cb(callback, data);
 171 }
 172
 173 EXPORT_API
 174 int badge_unregister_changed_cb(badge_change_cb callback)
 175 {
 176         if (callback == NULL) {
 177                 return BADGE_ERROR_INVALID_PARAMETER;
 178         }
 179
 180         return _badge_unregister_changed_cb(callback);
 181 }
 182
 183 EXPORT_API
 184 int badge_is_service_ready(void)
 185 {
 186         return badge_ipc_is_master_ready();
 187 }
 188
 189 EXPORT_API
 190 int badge_add_deferred_task(
 191                 void (*badge_add_deferred_task)(void *data), void *user_data)
 192 {
 193         return badge_ipc_add_deferred_task(badge_add_deferred_task, user_data);
 194 }
 195
 196 EXPORT_API
 197 int badge_del_deferred_task(
 198                 void (*badge_add_deferred_task)(void *data))
 199 {
 200         return badge_ipc_del_deferred_task(badge_add_deferred_task);
 201 }