client/vc_setting.c

   1 /*
   2 * Copyright (c) 2011-2015 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 "voice_control_common.h"
  21 #include "voice_control_setting.h"
  22
  23 /**
  24 * @brief Enumerations of mode.
  25 */
  26 typedef enum {
  27         VC_SETTING_STATE_NONE = 0,
  28         VC_SETTING_STATE_READY
  29 } vc_setting_state_e;
  30
  31 #define VC_SETTING_CONFIG_HANDLE        300000
  32
  33 static vc_setting_state_e g_state = VC_SETTING_STATE_NONE;
  34
  35 static vc_setting_enabled_changed_cb g_callback = NULL;
  36
  37 static void* g_user_data = NULL;
  38
  39 static vc_setting_current_language_changed_cb g_lang_callback = NULL;
  40
  41 static void* g_lang_user_data = NULL;
  42
  43 const char* vc_tag()
  44 {
  45         return TAG_VCS;
  46 }
  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_lang_callback) {
  53                 g_lang_callback(before_lang, current_lang, g_lang_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_callback) {
  69                 g_callback(enabled, g_user_data);
  70         }
  71
  72         return;
  73 }
  74
  75 int vc_setting_initialize(void)
  76 {
  77         SLOG(LOG_DEBUG, TAG_VCS, "===== Initialize VC Setting");
  78
  79         if (VC_SETTING_STATE_READY == g_state) {
  80                 SLOG(LOG_WARN, TAG_VCS, "[WARNING] VC Setting has already been initialized.");
  81                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
  82                 SLOG(LOG_DEBUG, TAG_VCS, " ");
  83                 return VC_ERROR_NONE;
  84         }
  85
  86         int ret = vc_config_mgr_initialize(getpid() + VC_SETTING_CONFIG_HANDLE);
  87         if (0 != ret) {
  88                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
  89                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
  90                 SLOG(LOG_DEBUG, TAG_VCS, " ");
  91                 return VC_ERROR_OPERATION_FAILED;
  92         }
  93
  94         ret = vc_config_mgr_set_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __config_lang_changed_cb);
  95         if (0 != ret) {
  96                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
  97                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
  98                 SLOG(LOG_DEBUG, TAG_VCS, " ");
  99                 return VC_ERROR_OPERATION_FAILED;
 100         }
 101
 102         ret = vc_config_mgr_set_enabled_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_enabled_changed_cb);
 103
 104         g_state = VC_SETTING_STATE_READY;
 105
 106         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 107         SLOG(LOG_DEBUG, TAG_VCS, " ");
 108
 109         return VC_ERROR_NONE;
 110 }
 111
 112 int vc_setting_deinitialize()
 113 {
 114         SLOG(LOG_DEBUG, TAG_VCS, "===== Deinitialize VC Setting");
 115
 116         vc_config_mgr_unset_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
 117         vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
 118
 119         g_state = VC_SETTING_STATE_NONE;
 120
 121         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 122         SLOG(LOG_DEBUG, TAG_VCS, " ");
 123
 124         return VC_ERROR_NONE;
 125 }
 126
 127 int vc_setting_foreach_supported_languages(vc_setting_supported_language_cb callback, void* user_data)
 128 {
 129         SLOG(LOG_DEBUG, TAG_VCS, "===== Foreach supported languages");
 130
 131         if (VC_SETTING_STATE_NONE == g_state) {
 132                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 133                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 134                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 135                 return VC_ERROR_INVALID_STATE;
 136         }
 137
 138         if (NULL == callback) {
 139                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 140                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 141                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 142                 return VC_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         int ret = vc_config_mgr_get_language_list((vc_supported_language_cb)callback, user_data);
 146         if (0 != ret) {
 147                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 148         } else {
 149                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Foreach supported languages");
 150         }
 151
 152         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 153         SLOG(LOG_DEBUG, TAG_VCS, " ");
 154
 155         return ret;
 156 }
 157
 158 int vc_setting_get_language(char** language)
 159 {
 160         SLOG(LOG_DEBUG, TAG_VCS, "===== Get default language");
 161
 162         if (VC_SETTING_STATE_NONE == g_state) {
 163                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 164                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 165                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 166                 return VC_ERROR_INVALID_STATE;
 167         }
 168
 169         if (NULL == language) {
 170                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Input parameter is NULL");
 171                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 172                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 173                 return VC_ERROR_INVALID_PARAMETER;
 174         }
 175
 176         int ret = vc_config_mgr_get_default_language(language);
 177         if (0 != ret) {
 178                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 179         } else {
 180                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get default language");
 181         }
 182
 183         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 184         SLOG(LOG_DEBUG, TAG_VCS, " ");
 185
 186         return ret;
 187 }
 188
 189 int vc_setting_set_language(const char* language)
 190 {
 191         SLOG(LOG_DEBUG, TAG_VCS, "===== Set default language");
 192
 193         if (VC_SETTING_STATE_NONE == g_state) {
 194                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 195                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 196                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 197                 return VC_ERROR_INVALID_STATE;
 198         }
 199
 200         if (NULL == language) {
 201                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Input parameter is NULL");
 202                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 203                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 204                 return VC_ERROR_INVALID_PARAMETER;
 205         }
 206
 207         int ret = vc_config_mgr_set_default_language(language);
 208         if (0 != ret) {
 209                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 210         } else {
 211                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set default language");
 212         }
 213
 214         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 215         SLOG(LOG_DEBUG, TAG_VCS, " ");
 216
 217         return ret;
 218 }
 219
 220 int vc_setting_set_auto_language(bool value)
 221 {
 222         SLOG(LOG_DEBUG, TAG_VCS, "===== Set auto voice");
 223
 224         if (VC_SETTING_STATE_NONE == g_state) {
 225                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 226                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 227                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 228                 return VC_ERROR_INVALID_STATE;
 229         }
 230
 231         if (value != true && value != false) {
 232                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 233                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 234                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 235                 return VC_ERROR_INVALID_PARAMETER;
 236         }
 237
 238         int ret = vc_config_mgr_set_auto_language(value);
 239         if (0 != ret) {
 240                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 241         } else {
 242                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set auto language (%s)", value ? "on" : "off");
 243         }
 244
 245         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 246         SLOG(LOG_DEBUG, TAG_VCS, " ");
 247
 248         return ret;
 249 }
 250
 251 int vc_setting_get_auto_language(bool* value)
 252 {
 253         SLOG(LOG_DEBUG, TAG_VCS, "===== Get auto language");
 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                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 259                 return VC_ERROR_INVALID_STATE;
 260         }
 261
 262         if (NULL == value) {
 263                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 264                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 265                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 266                 return VC_ERROR_INVALID_PARAMETER;
 267         }
 268
 269         int ret = vc_config_mgr_get_auto_language(value);
 270         if (0 != ret) {
 271                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 272         } else {
 273                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get auto language (%s)", *value ? "true" : "false");
 274         }
 275
 276         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 277         SLOG(LOG_DEBUG, TAG_VCS, " ");
 278
 279         return 0;
 280 }
 281
 282 int vc_setting_set_enabled(bool value)
 283 {
 284         SLOG(LOG_DEBUG, TAG_VCS, "===== Set service enabled");
 285
 286         if (VC_SETTING_STATE_NONE == g_state) {
 287                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 288                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 289                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 290                 return VC_ERROR_INVALID_STATE;
 291         }
 292
 293         if (value != true && value != false) {
 294                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Invalid value");
 295                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 296                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 297                 return VC_ERROR_INVALID_PARAMETER;
 298         }
 299
 300         int ret = vc_config_mgr_set_enabled(value);
 301         if (0 != ret) {
 302                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 303         } else {
 304                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Set service enabled (%s)", value ? "on" : "off");
 305         }
 306
 307         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 308         SLOG(LOG_DEBUG, TAG_VCS, " ");
 309
 310         return ret;
 311 }
 312
 313 int vc_setting_get_enabled(bool* value)
 314 {
 315         SLOG(LOG_DEBUG, TAG_VCS, "===== Get service enabled");
 316
 317         if (VC_SETTING_STATE_NONE == g_state) {
 318                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 319                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 320                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 321                 return VC_ERROR_INVALID_STATE;
 322         }
 323
 324         if (NULL == value) {
 325                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 326                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 327                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 328                 return VC_ERROR_INVALID_PARAMETER;
 329         }
 330
 331         int ret = vc_config_mgr_get_enabled(value);
 332         if (0 != ret) {
 333                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
 334         } else {
 335                 /* Copy value */
 336                 SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get service enabled (%s)", *value ? "on" : "off");
 337         }
 338
 339         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 340         SLOG(LOG_DEBUG, TAG_VCS, " ");
 341
 342         return ret;
 343 }
 344
 345 int vc_setting_set_enabled_changed_cb(vc_setting_enabled_changed_cb callback, void* user_data)
 346 {
 347         SLOG(LOG_DEBUG, TAG_VCS, "===== Set service enabled callback");
 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                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 353                 return VC_ERROR_INVALID_STATE;
 354         }
 355
 356         if (NULL == callback) {
 357                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 358                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 359                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 360                 return VC_ERROR_INVALID_PARAMETER;
 361         }
 362
 363         g_callback = callback;
 364         g_user_data = user_data;
 365
 366         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 367         SLOG(LOG_DEBUG, TAG_VCS, " ");
 368
 369         return 0;
 370 }
 371
 372 int vc_setting_unset_enabled_changed_cb()
 373 {
 374         SLOG(LOG_DEBUG, TAG_VCS, "===== Unset service enabled callback");
 375
 376         if (VC_SETTING_STATE_NONE == g_state) {
 377                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 378                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 379                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 380                 return VC_ERROR_INVALID_STATE;
 381         }
 382
 383         g_callback = NULL;
 384         g_user_data = NULL;
 385
 386         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 387         SLOG(LOG_DEBUG, TAG_VCS, " ");
 388
 389         return 0;
 390 }
 391
 392 int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data)
 393 {
 394         SLOG(LOG_DEBUG, TAG_VCS, "===== Set current language changed callback");
 395
 396         if (VC_SETTING_STATE_NONE == g_state) {
 397                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 398                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 399                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 400                 return VC_ERROR_INVALID_STATE;
 401         }
 402
 403         if (NULL == callback) {
 404                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
 405                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 406                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 407                 return VC_ERROR_INVALID_PARAMETER;
 408         }
 409
 410         g_lang_callback = callback;
 411         g_lang_user_data = user_data;
 412
 413         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 414         SLOG(LOG_DEBUG, TAG_VCS, " ");
 415
 416         return 0;
 417 }
 418
 419 int vc_setting_unset_current_language_changed_cb()
 420 {
 421         SLOG(LOG_DEBUG, TAG_VCS, "===== Unset current language changed callback");
 422
 423         if (VC_SETTING_STATE_NONE == g_state) {
 424                 SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
 425                 SLOG(LOG_DEBUG, TAG_VCS, "=====");
 426                 SLOG(LOG_DEBUG, TAG_VCS, " ");
 427                 return VC_ERROR_INVALID_STATE;
 428         }
 429
 430         g_lang_callback = NULL;
 431         g_lang_user_data = NULL;
 432
 433         SLOG(LOG_DEBUG, TAG_VCS, "=====");
 434         SLOG(LOG_DEBUG, TAG_VCS, " ");
 435
 436         return 0;
 437 }
 438