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_tidl.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* previous_lang, const char* current_lang)
  49 {
  50         SLOG(LOG_DEBUG, TAG_VCS, "Lang changed : previous(%s) current(%s)", previous_lang, current_lang);
  51
  52         if (NULL != g_current_language_changed_cb) {
  53                 g_current_language_changed_cb(previous_lang, current_lang, g_current_language_changed_user_data);
  54         }
  55 }
  56
  57 void __vc_setting_state_changed_cb(int previous_state, int current_state, void* user_data)
  58 {
  59         SLOG(LOG_DEBUG, TAG_VCS, "Service State changed : previous(%d) current(%d)",
  60                  previous_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         RETVM_IF(VC_SETTING_STATE_READY == g_state, VC_ERROR_NONE, TAG_VCS, "[WARNING] VC Setting has already been initialized.");
  91
  92         int ret = vc_config_mgr_initialize(getpid() + VC_SETTING_CONFIG_HANDLE);
  93         if (0 != ret) {
  94                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
  95                 return VC_ERROR_OPERATION_FAILED;
  96         }
  97
  98         ret = vc_config_mgr_set_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __config_lang_changed_cb);
  99         if (0 != ret) {
 100                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
 101                 vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
 102                 return VC_ERROR_OPERATION_FAILED;
 103         }
 104
 105         ret = vc_config_mgr_set_enabled_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_enabled_changed_cb);
 106         ret = vc_config_mgr_set_engine_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_engine_changed_cb);
 107
 108         g_state = VC_SETTING_STATE_READY;
 109
 110         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Initialize VC Setting DONE");
 111
 112         return VC_ERROR_NONE;
 113 }
 114
 115 int vc_setting_deinitialize()
 116 {
 117         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Deinitialize VC Setting");
 118
 119         RETVM_IF(VC_SETTING_STATE_READY != g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[WARNING] VC Setting is not initialized");
 120
 121         vc_config_mgr_unset_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
 122         vc_config_mgr_unset_engine_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
 123         vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
 124
 125         g_state = VC_SETTING_STATE_NONE;
 126
 127         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Deinitialize VC Setting DONE");
 128
 129         return VC_ERROR_NONE;
 130 }
 131
 132 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)
 133 {
 134         return g_engine_cb(engine_name, engine_id, setting_path, default_lang, non_fixed_support, g_engine_user_data);
 135 }
 136
 137 int vc_setting_foreach_supported_engines(vc_setting_supported_engine_cb callback, void* user_data)
 138 {
 139         SLOG(LOG_DEBUG, TAG_VCS, "===== Foreach supported engines");
 140
 141         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 142
 143         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 144
 145         SLOG(LOG_DEBUG, TAG_VCS, "===== Foreach supported engines 11");
 146         g_engine_cb = callback;
 147         g_engine_user_data = user_data;
 148
 149         int ret = vc_config_mgr_get_engine_list(__config_mgr_get_engine_list, NULL);
 150         if (0 != ret) {
 151                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 152         } else {
 153                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Foreach supported engines");
 154         }
 155
 156
 157         return ret;
 158 }
 159
 160 int vc_setting_get_engine(char** engine_id)
 161 {
 162         SLOG(LOG_DEBUG, TAG_VCS, "===== Get current engine");
 163
 164         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 165
 166         RETVM_IF(NULL == engine_id, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Engine id is NULL");
 167
 168         int ret = vc_config_mgr_get_engine(engine_id);
 169         if (0 != ret) {
 170                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 171         } else {
 172                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get current engine");
 173         }
 174
 175
 176         return ret;
 177 }
 178
 179 int vc_setting_set_engine(const char* engine_appid)
 180 {
 181         SLOG(LOG_DEBUG, TAG_VCS, "===== Set current engine");
 182
 183         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 184
 185         RETVM_IF(NULL == engine_appid, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Engine appid is NULL");
 186
 187         SECURE_SLOG(LOG_DEBUG, TAG_VCS, "New engine appid : %s", engine_appid);
 188
 189         int ret = vc_config_mgr_set_engine(engine_appid);
 190         if (0 != ret) {
 191                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 192         } else {
 193                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set current engine");
 194         }
 195
 196
 197         return ret;
 198 }
 199
 200 int vc_setting_foreach_supported_languages(vc_setting_supported_language_cb callback, void* user_data)
 201 {
 202         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Foreach supported languages");
 203
 204         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 205
 206         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 207
 208         int ret = vc_config_mgr_get_language_list((vc_supported_language_cb)callback, user_data);
 209         if (0 != ret) {
 210                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 211         } else {
 212                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Foreach supported languages");
 213         }
 214
 215         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Foreach supported languages DONE");
 216
 217         return ret;
 218 }
 219
 220 int vc_setting_get_language(char** language)
 221 {
 222         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get default language");
 223
 224         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 225
 226         RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 227
 228         int ret = vc_config_mgr_get_default_language(language);
 229         if (0 != ret) {
 230                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 231         } else {
 232                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get default language");
 233         }
 234
 235         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get default language DONE");
 236
 237         return ret;
 238 }
 239
 240 int vc_setting_set_language(const char* language)
 241 {
 242         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set default language");
 243
 244         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 245
 246         RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 247
 248         int ret = vc_config_mgr_set_default_language(language);
 249         if (0 != ret) {
 250                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 251         } else {
 252                 // TODO: Need to reorder.
 253                 if (0 != vc_setting_tidl_open_connection()) {
 254                         SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to open connection");
 255                         return VC_ERROR_OPERATION_FAILED;
 256                 }
 257
 258                 if (0 != vc_setting_tidl_request_hello()) {
 259                         SLOG(LOG_DEBUG, TAG_VCS, "[DEBUG] Daemon is not available");
 260                 } else {
 261                         ret = vc_setting_tidl_request_set_language(getpid(), language);
 262                         SLOG(LOG_DEBUG, TAG_VCS, "[DEBUG] Set default language (%d)", ret);
 263                 }
 264
 265                 if (0 != vc_setting_tidl_close_connection()) {
 266                         SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to close connection");
 267                         return VC_ERROR_OPERATION_FAILED;
 268                 }
 269         }
 270
 271         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set default language DONE");
 272
 273         return ret;
 274 }
 275
 276 int vc_setting_set_auto_language(bool value)
 277 {
 278         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set auto voice");
 279
 280         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 281
 282         if (value != true && value != false) {
 283                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 284                 return VC_ERROR_INVALID_PARAMETER;
 285         }
 286
 287         int ret = vc_config_mgr_set_auto_language(value);
 288         if (0 != ret) {
 289                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 290         } else {
 291                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set auto language (%s)", value ? "on" : "off");
 292         }
 293
 294         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set auto voice DONE");
 295
 296         return ret;
 297 }
 298
 299 int vc_setting_get_auto_language(bool* value)
 300 {
 301         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get auto language");
 302
 303         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 304
 305         RETVM_IF(NULL == value, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 306
 307         int ret = vc_config_mgr_get_auto_language(value);
 308         if (0 != ret) {
 309                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 310         } else {
 311                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get auto language (%s)", *value ? "true" : "false");
 312         }
 313
 314         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get auto language DONE");
 315
 316         return VC_ERROR_NONE;
 317 }
 318
 319 int vc_setting_set_enabled(bool value)
 320 {
 321         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled");
 322
 323         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 324
 325         if (value != true && value != false) {
 326                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 327                 return VC_ERROR_INVALID_PARAMETER;
 328         }
 329
 330         int ret = vc_config_mgr_set_enabled(value);
 331         if (0 != ret) {
 332                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 333         } else {
 334                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set service enabled (%s)", value ? "on" : "off");
 335         }
 336
 337         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled DONE");
 338
 339         return ret;
 340 }
 341
 342 int vc_setting_get_enabled(bool* value)
 343 {
 344         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get service enabled");
 345
 346         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 347
 348         RETVM_IF(NULL == value, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 349
 350         int ret = vc_config_mgr_get_enabled(value);
 351         if (0 != ret) {
 352                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 353         } else {
 354                 /* Copy value */
 355                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get service enabled (%s)", *value ? "on" : "off");
 356         }
 357
 358         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Get service enabled DONE");
 359
 360         return ret;
 361 }
 362
 363 int vc_setting_set_enabled_changed_cb(vc_setting_enabled_changed_cb callback, void* user_data)
 364 {
 365         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled callback");
 366
 367         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 368
 369         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 370
 371         g_enabled_changed_cb = callback;
 372         g_enabled_changed_user_data = user_data;
 373
 374         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set service enabled callback DONE");
 375
 376         return VC_ERROR_NONE;
 377 }
 378
 379 int vc_setting_unset_enabled_changed_cb()
 380 {
 381         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset service enabled callback");
 382
 383         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 384
 385         g_enabled_changed_cb = NULL;
 386         g_enabled_changed_user_data = NULL;
 387
 388         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset service enabled callback DONE");
 389
 390         return VC_ERROR_NONE;
 391 }
 392
 393 int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data)
 394 {
 395         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set current language changed callback");
 396
 397         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 398
 399         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 400
 401         g_current_language_changed_cb = callback;
 402         g_current_language_changed_user_data = user_data;
 403
 404         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set current language changed callback DONE");
 405
 406         return VC_ERROR_NONE;
 407 }
 408
 409 int vc_setting_unset_current_language_changed_cb()
 410 {
 411         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset current language changed callback");
 412
 413         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 414
 415         g_current_language_changed_cb = NULL;
 416         g_current_language_changed_user_data = NULL;
 417
 418         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset current language changed callback");
 419
 420         return VC_ERROR_NONE;
 421 }
 422
 423 int vc_setting_set_engine_changed_cb(vc_setting_engine_changed_cb callback, void *user_data)
 424 {
 425         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set engine changed callback");
 426
 427         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCS, "[ERROR] Invalid parameter");
 428
 429         g_engine_changed_cb = callback;
 430         g_engine_changed_user_data = user_data;
 431
 432         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Set engine changed callback DONE");
 433         return VC_ERROR_NONE;
 434 }
 435
 436 int vc_setting_unset_engine_changed_cb()
 437 {
 438         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset engine changed callback");
 439
 440         RETVM_IF(VC_SETTING_STATE_NONE == g_state, VC_ERROR_INVALID_STATE, TAG_VCS, "[ERROR] Not initialized");
 441
 442         g_engine_changed_cb = NULL;
 443         g_engine_changed_user_data = NULL;
 444
 445         SLOG(LOG_DEBUG, TAG_VCS, "@@@ Unset engine changed callback DONE");
 446         return VC_ERROR_NONE;
 447 }