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