client/vc_setting.c

   1 /*
   2 * Copyright (c) 2011-2019 Samsung Electronics Co., Ltd All Rights Reserved
   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
  18 #include "vc_config_mgr.h"
  19 #include "vc_main.h"
  20 #include "vc_setting_dbus.h"
  21 #include "voice_control_common.h"
  22 #include "voice_control_setting.h"
  23
  24 /**
  25 * @brief Enumerations of mode.
  26 */
  27 typedef enum {
  28         VC_SETTING_STATE_NONE = 0,
  29         VC_SETTING_STATE_READY
  30 } vc_setting_state_e;
  31
  32 #define VC_SETTING_CONFIG_HANDLE        30000000
  33
  34 static vc_setting_state_e g_state = VC_SETTING_STATE_NONE;
  35
  36 static vc_setting_supported_engine_cb g_engine_cb = NULL;
  37 static void* g_engine_user_data = NULL;
  38
  39 static vc_setting_engine_changed_cb g_engine_changed_cb = NULL;
  40 static void* g_engine_changed_user_data = NULL;
  41
  42 static vc_setting_enabled_changed_cb g_enabled_changed_cb = NULL;
  43 static void* g_enabled_changed_user_data = NULL;
  44
  45 static vc_setting_current_language_changed_cb g_current_language_changed_cb = NULL;
  46 static void* g_current_language_changed_user_data = NULL;
  47
  48 void __config_lang_changed_cb(const char* before_lang, const char* current_lang)
  49 {
  50         SLOG(LOG_DEBUG, TAG_VCS, "Lang changed : before(%s) current(%s)", before_lang, current_lang);
  51
  52         if (NULL != g_current_language_changed_cb) {
  53                 g_current_language_changed_cb(before_lang, current_lang, g_current_language_changed_user_data);
  54         }
  55 }
  56
  57 void __vc_setting_state_changed_cb(int before_state, int current_state, void* user_data)
  58 {
  59         SLOG(LOG_DEBUG, TAG_VCS, "Service State changed : Before(%d) Current(%d)",
  60                  before_state, current_state);
  61         return;
  62 }
  63
  64 void __vc_setting_enabled_changed_cb(bool enabled)
  65 {
  66         SLOG(LOG_DEBUG, TAG_VCS, "Service enabled changed : %s", enabled ? "on" : "off");
  67
  68         if (NULL != g_enabled_changed_cb) {
  69                 g_enabled_changed_cb(enabled, g_enabled_changed_user_data);
  70         }
  71
  72         return;
  73 }
  74
  75 void __vc_setting_engine_changed_cb(const char* engine_appid)
  76 {
  77         SLOG(LOG_DEBUG, TAG_VCS, "Service enabled changed : engine appid(%s)", engine_appid);
  78
  79         if (NULL != g_engine_changed_cb) {
  80                 g_engine_changed_cb(engine_appid, g_engine_changed_user_data);
  81         }
  82
  83         return;
  84 }
  85
  86 int vc_setting_initialize(void)
  87 {
  88         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Initialize VC Setting");
  89
  90         if (VC_SETTING_STATE_READY == g_state) {
  91                 SLOG(LOG_WARN, TAG_VCS, "[WARNING] VC Setting has already been initialized.");
  92                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
  93                 return VC_ERROR_NONE;
  94         }
  95
  96         int ret = vc_config_mgr_initialize(getpid() + VC_SETTING_CONFIG_HANDLE);
  97         if (0 != ret) {
  98                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
  99                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 100                 return VC_ERROR_OPERATION_FAILED;
 101         }
 102
 103         ret = vc_config_mgr_set_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __config_lang_changed_cb);
 104         if (0 != ret) {
 105                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
 106                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 107                 vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
 108                 return VC_ERROR_OPERATION_FAILED;
 109         }
 110
 111         ret = vc_config_mgr_set_enabled_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_enabled_changed_cb);
 112         ret = vc_config_mgr_set_engine_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_engine_changed_cb);
 113
 114         g_state = VC_SETTING_STATE_READY;
 115
 116         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 117
 118         return VC_ERROR_NONE;
 119 }
 120
 121 int vc_setting_deinitialize()
 122 {
 123         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Deinitialize VC Setting");
 124
 125         if (VC_SETTING_STATE_READY != g_state) {
 126                 SLOG(LOG_WARN, TAG_VCS, "[WARNING] VC Setting is not initialized");
 127                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 128                 return VC_ERROR_INVALID_STATE;
 129         }
 130
 131         vc_config_mgr_unset_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
 132         vc_config_mgr_unset_engine_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
 133         vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
 134
 135         g_state = VC_SETTING_STATE_NONE;
 136
 137         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 138
 139         return VC_ERROR_NONE;
 140 }
 141
 142 static bool __config_mgr_get_engine_list(const char *engine_name, const char *engine_id, const char *setting_path, const char *default_lang, bool non_fixed_support, void *user_data)
 143 {
 144         return g_engine_cb(engine_name, engine_id, setting_path, default_lang, non_fixed_support, g_engine_user_data);
 145 }
 146
 147 int vc_setting_foreach_supported_engines(vc_setting_supported_engine_cb callback, void* user_data)
 148 {
 149         SLOG(LOG_DEBUG, TAG_VCS, "===== Foreach supported engines");
 150
 151         if (VC_SETTING_STATE_NONE == g_state) {
 152                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 153                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 154                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 155                 return VC_ERROR_INVALID_STATE;
 156         }
 157
 158         if (NULL == callback) {
 159                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Callback is NULL");
 160                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 161                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 162                 return VC_ERROR_INVALID_PARAMETER;
 163         }
 164
 165         SLOG(LOG_DEBUG, TAG_VCS, "===== Foreach supported engines 11");
 166         g_engine_cb = callback;
 167         g_engine_user_data = user_data;
 168
 169         int ret = vc_config_mgr_get_engine_list(__config_mgr_get_engine_list, NULL);
 170         if (0 != ret) {
 171                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 172         } else {
 173                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Foreach supported engines");
 174         }
 175
 176         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 177         SLOG(LOG_DEBUG, TAG_VCS, " ");
 178
 179         return ret;
 180 }
 181
 182 int vc_setting_get_engine(char** engine_id)
 183 {
 184         SLOG(LOG_DEBUG, TAG_VCS, "===== Get current engine");
 185
 186         if (VC_SETTING_STATE_NONE == g_state) {
 187                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 188                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 189                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 190                 return VC_ERROR_INVALID_STATE;
 191         }
 192
 193         if (NULL == engine_id) {
 194                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Engine id is NULL");
 195                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 196                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 197                 return VC_ERROR_INVALID_PARAMETER;
 198         }
 199
 200         int ret = vc_config_mgr_get_engine(engine_id);
 201         if (0 != ret) {
 202                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 203         } else {
 204                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get current engine");
 205         }
 206
 207         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 208         SLOG(LOG_DEBUG, TAG_VCS, " ");
 209
 210         return ret;
 211 }
 212
 213 int vc_setting_set_engine(const char* engine_appid)
 214 {
 215         SLOG(LOG_DEBUG, TAG_VCS, "===== Set current engine");
 216
 217         if (VC_SETTING_STATE_NONE == g_state) {
 218                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 219                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 220                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 221                 return VC_ERROR_INVALID_STATE;
 222         }
 223
 224         if (NULL == engine_appid) {
 225                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Engine appid is NULL");
 226                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 227                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 228                 return VC_ERROR_INVALID_PARAMETER;
 229         }
 230
 231         SECURE_SLOG(LOG_DEBUG, TAG_VCS, "New engine appid : %s", engine_appid);
 232
 233         int ret = vc_config_mgr_set_engine(engine_appid);
 234         if (0 != ret) {
 235                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 236         } else {
 237                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set current engine");
 238         }
 239
 240         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 241         SLOG(LOG_DEBUG, TAG_VCS, " ");
 242
 243         return ret;
 244 }
 245
 246 int vc_setting_foreach_supported_languages(vc_setting_supported_language_cb callback, void* user_data)
 247 {
 248         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Foreach supported languages");
 249
 250         if (VC_SETTING_STATE_NONE == g_state) {
 251                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 252                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 253                 return VC_ERROR_INVALID_STATE;
 254         }
 255
 256         if (NULL == callback) {
 257                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 258                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 259                 return VC_ERROR_INVALID_PARAMETER;
 260         }
 261
 262         int ret = vc_config_mgr_get_language_list((vc_supported_language_cb)callback, user_data);
 263         if (0 != ret) {
 264                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 265         } else {
 266                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Foreach supported languages");
 267         }
 268
 269         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 270
 271         return ret;
 272 }
 273
 274 int vc_setting_get_language(char** language)
 275 {
 276         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get default language");
 277
 278         if (VC_SETTING_STATE_NONE == g_state) {
 279                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 280                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 281                 return VC_ERROR_INVALID_STATE;
 282         }
 283
 284         if (NULL == language) {
 285                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Input parameter is NULL");
 286                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 287                 return VC_ERROR_INVALID_PARAMETER;
 288         }
 289
 290         int ret = vc_config_mgr_get_default_language(language);
 291         if (0 != ret) {
 292                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 293         } else {
 294                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get default language");
 295         }
 296
 297         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 298
 299         return ret;
 300 }
 301
 302 int vc_setting_set_language(const char* language)
 303 {
 304         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set default language");
 305
 306         if (VC_SETTING_STATE_NONE == g_state) {
 307                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 308                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 309                 return VC_ERROR_INVALID_STATE;
 310         }
 311
 312         if (NULL == language) {
 313                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Input parameter is NULL");
 314                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 315                 return VC_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         int ret = vc_config_mgr_set_default_language(language);
 319         if (0 != ret) {
 320                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 321         } else {
 322                 if (0 != vc_setting_dbus_open_connection()) {
 323                         SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to open connection");
 324                         return VC_ERROR_OPERATION_FAILED;
 325                 }
 326
 327                 if (0 != vc_setting_dbus_request_hello()) {
 328                         SLOG(LOG_DEBUG, TAG_VCS, "[DEBUG] Daemon is not available");
 329                 } else {
 330                         ret = vc_setting_dbus_request_set_language(getpid(), language);
 331                         SLOG(LOG_DEBUG, TAG_VCS, "[DEBUG] Set default language (%d)", ret);
 332                 }
 333
 334                 if (0 != vc_setting_dbus_close_connection()) {
 335                         SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to close connection");
 336                         return VC_ERROR_OPERATION_FAILED;
 337                 }
 338         }
 339
 340         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 341
 342         return ret;
 343 }
 344
 345 int vc_setting_set_auto_language(bool value)
 346 {
 347         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set auto voice");
 348
 349         if (VC_SETTING_STATE_NONE == g_state) {
 350                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 351                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 352                 return VC_ERROR_INVALID_STATE;
 353         }
 354
 355         if (value != true && value != false) {
 356                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 357                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 358                 return VC_ERROR_INVALID_PARAMETER;
 359         }
 360
 361         int ret = vc_config_mgr_set_auto_language(value);
 362         if (0 != ret) {
 363                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 364         } else {
 365                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set auto language (%s)", value ? "on" : "off");
 366         }
 367
 368         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 369
 370         return ret;
 371 }
 372
 373 int vc_setting_get_auto_language(bool* value)
 374 {
 375         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get auto language");
 376
 377         if (VC_SETTING_STATE_NONE == g_state) {
 378                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 379                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 380                 return VC_ERROR_INVALID_STATE;
 381         }
 382
 383         if (NULL == value) {
 384                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 385                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 386                 return VC_ERROR_INVALID_PARAMETER;
 387         }
 388
 389         int ret = vc_config_mgr_get_auto_language(value);
 390         if (0 != ret) {
 391                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 392         } else {
 393                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get auto language (%s)", *value ? "true" : "false");
 394         }
 395
 396         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 397
 398         return 0;
 399 }
 400
 401 int vc_setting_set_enabled(bool value)
 402 {
 403         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled");
 404
 405         if (VC_SETTING_STATE_NONE == g_state) {
 406                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 407                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 408                 return VC_ERROR_INVALID_STATE;
 409         }
 410
 411         if (value != true && value != false) {
 412                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 413                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 414                 return VC_ERROR_INVALID_PARAMETER;
 415         }
 416
 417         int ret = vc_config_mgr_set_enabled(value);
 418         if (0 != ret) {
 419                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 420         } else {
 421                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set service enabled (%s)", value ? "on" : "off");
 422         }
 423
 424         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 425
 426         return ret;
 427 }
 428
 429 int vc_setting_get_enabled(bool* value)
 430 {
 431         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get service enabled");
 432
 433         if (VC_SETTING_STATE_NONE == g_state) {
 434                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 435                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 436                 return VC_ERROR_INVALID_STATE;
 437         }
 438
 439         if (NULL == value) {
 440                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 441                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 442                 return VC_ERROR_INVALID_PARAMETER;
 443         }
 444
 445         int ret = vc_config_mgr_get_enabled(value);
 446         if (0 != ret) {
 447                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 448         } else {
 449                 /* Copy value */
 450                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get service enabled (%s)", *value ? "on" : "off");
 451         }
 452
 453         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 454
 455         return ret;
 456 }
 457
 458 int vc_setting_set_enabled_changed_cb(vc_setting_enabled_changed_cb callback, void* user_data)
 459 {
 460         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled callback");
 461
 462         if (VC_SETTING_STATE_NONE == g_state) {
 463                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 464                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 465                 return VC_ERROR_INVALID_STATE;
 466         }
 467
 468         if (NULL == callback) {
 469                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 470                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 471                 return VC_ERROR_INVALID_PARAMETER;
 472         }
 473
 474         g_enabled_changed_cb = callback;
 475         g_enabled_changed_user_data = user_data;
 476
 477         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 478
 479         return 0;
 480 }
 481
 482 int vc_setting_unset_enabled_changed_cb()
 483 {
 484         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset service enabled callback");
 485
 486         if (VC_SETTING_STATE_NONE == g_state) {
 487                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 488                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 489                 return VC_ERROR_INVALID_STATE;
 490         }
 491
 492         g_enabled_changed_cb = NULL;
 493         g_enabled_changed_user_data = NULL;
 494
 495         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 496
 497         return 0;
 498 }
 499
 500 int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data)
 501 {
 502         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set current language changed callback");
 503
 504         if (VC_SETTING_STATE_NONE == g_state) {
 505                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 506                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 507                 return VC_ERROR_INVALID_STATE;
 508         }
 509
 510         if (NULL == callback) {
 511                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 512                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 513                 return VC_ERROR_INVALID_PARAMETER;
 514         }
 515
 516         g_current_language_changed_cb = callback;
 517         g_current_language_changed_user_data = user_data;
 518
 519         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 520
 521         return 0;
 522 }
 523
 524 int vc_setting_unset_current_language_changed_cb()
 525 {
 526         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset current language changed callback");
 527
 528         if (VC_SETTING_STATE_NONE == g_state) {
 529                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 530                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 531                 return VC_ERROR_INVALID_STATE;
 532         }
 533
 534         g_current_language_changed_cb = NULL;
 535         g_current_language_changed_user_data = NULL;
 536
 537         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 538
 539         return 0;
 540 }
 541
 542 int vc_setting_set_engine_changed_cb(vc_setting_engine_changed_cb callback, void *user_data)
 543 {
 544         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set engine changed callback");
 545
 546         if (NULL == callback) {
 547                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Input param is NULL");
 548                 return VC_ERROR_INVALID_PARAMETER;
 549         }
 550
 551         g_engine_changed_cb = callback;
 552         g_engine_changed_user_data = user_data;
 553
 554         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 555         return 0;
 556 }
 557
 558 int vc_setting_unset_engine_changed_cb()
 559 {
 560         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset engine changed callback");
 561
 562         if (VC_SETTING_STATE_NONE == g_state) {
 563                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 564                 SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 565                 return VC_ERROR_INVALID_STATE;
 566         }
 567
 568         g_engine_changed_cb = NULL;
 569         g_engine_changed_user_data = NULL;
 570
 571         SLOG(LOG_DEBUG, TAG_VCS, "@@@");
 572         return 0;
 573 }