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