server/vce.c

   1 /*
   2 * Copyright (c) 2011-2017 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 <cynara-client.h>
  19 #include <cynara-error.h>
  20 #include <cynara-session.h>
  21 #include <system_info.h>
  22 #include "vcd_tidl.h"
  23 #include "vcd_main.h"
  24 #include "vcd_server.h"
  25
  26 #include "vce.h"
  27
  28 static int g_feature_enabled = -1;
  29 static bool g_privilege_allowed = false;
  30
  31 static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER;
  32 static cynara *p_cynara = NULL;
  33
  34 static int __vce_get_feature_enabled()
  35 {
  36         if (0 == g_feature_enabled) {
  37                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Voice control feature NOT supported");
  38                 return VCE_ERROR_NOT_SUPPORTED;
  39         } else if (-1 == g_feature_enabled) {
  40                 bool vc_supported = false;
  41                 bool mic_supported = false;
  42                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  43                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  44                                 if (false == vc_supported || false == mic_supported) {
  45                                         SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Voice control feature NOT supported");
  46                                         g_feature_enabled = 0;
  47                                         return VCE_ERROR_NOT_SUPPORTED;
  48                                 }
  49
  50                                 g_feature_enabled = 1;
  51                         } else {
  52                                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get feature value");
  53                                 return VCE_ERROR_NOT_SUPPORTED;
  54                         }
  55                 } else {
  56                         SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get feature value");
  57                         return VCE_ERROR_NOT_SUPPORTED;
  58                 }
  59         }
  60
  61         return VCE_ERROR_NONE;
  62 }
  63
  64 static int __check_privilege_initialize()
  65 {
  66         int ret = cynara_initialize(&p_cynara, NULL);
  67         if (CYNARA_API_SUCCESS != ret)
  68                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] fail to initialize");
  69
  70         return ret == CYNARA_API_SUCCESS;
  71 }
  72
  73 static int __check_privilege(const char* uid, const char * privilege)
  74 {
  75         FILE *fp = NULL;
  76         char label_path[1024] = "/proc/self/attr/current";
  77         char smack_label[1024] = {'\0',};
  78
  79         if (!p_cynara) {
  80                 return false;
  81         }
  82
  83         fp = fopen(label_path, "r");
  84         if (fp != NULL) {
  85                 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
  86                         SLOG(LOG_ERROR, TAG_VCD, "[ERROR] fail to fread");
  87
  88                 fclose(fp);
  89         }
  90
  91         pid_t pid = getpid();
  92         char *session = cynara_session_from_pid(pid);
  93         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
  94         SLOG(LOG_INFO, TAG_VCD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
  95         if (session)
  96                 free(session);
  97
  98         if (ret != CYNARA_API_ACCESS_ALLOWED)
  99                 return false;
 100         return true;
 101 }
 102
 103 static void __check_privilege_deinitialize()
 104 {
 105         if (p_cynara)
 106         {
 107                 int ret = cynara_finish(p_cynara);
 108                 if (ret != CYNARA_API_SUCCESS)
 109                         SLOG(LOG_ERROR, TAG_VCD, "[ERROR] cynara finish %d", ret);
 110         }
 111         p_cynara = NULL;
 112 }
 113
 114 static int __vce_check_privilege()
 115 {
 116         pthread_mutex_lock(&g_cynara_mutex);
 117
 118         if (true == g_privilege_allowed) {
 119                 pthread_mutex_unlock(&g_cynara_mutex);
 120                 return VC_ERROR_NONE;
 121         }
 122
 123         bool ret = true;
 124         ret = __check_privilege_initialize();
 125         if (false == ret) {
 126                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] privilege initialize is failed");
 127                 pthread_mutex_unlock(&g_cynara_mutex);
 128                 return VCE_ERROR_PERMISSION_DENIED;
 129         }
 130
 131         char uid[32];
 132         snprintf(uid, 32, "%d", getuid());
 133         ret = true;
 134         ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
 135         if (false == ret) {
 136                 //LCOV_EXCL_START
 137                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
 138                 __check_privilege_deinitialize();
 139                 g_privilege_allowed = false;
 140                 pthread_mutex_unlock(&g_cynara_mutex);
 141                 return VCE_ERROR_PERMISSION_DENIED;
 142                 //LCOV_EXCL_STOP
 143         }
 144
 145         ret = __check_privilege(uid, VC_PRIVILEGE_APPMGR_LAUNCH);
 146         if (false == ret) {
 147                 //LCOV_EXCL_START
 148                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_APPMGR_LAUNCH, uid);
 149                 __check_privilege_deinitialize();
 150                 g_privilege_allowed = false;
 151                 pthread_mutex_unlock(&g_cynara_mutex);
 152                 return VCE_ERROR_PERMISSION_DENIED;
 153                 //LCOV_EXCL_STOP
 154         }
 155
 156         ret = __check_privilege(uid, VC_PRIVILEGE_DATASHARING);
 157         if (false == ret) {
 158                 //LCOV_EXCL_START
 159                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_DATASHARING, uid);
 160                 __check_privilege_deinitialize();
 161                 g_privilege_allowed = false;
 162                 pthread_mutex_unlock(&g_cynara_mutex);
 163                 return VCE_ERROR_PERMISSION_DENIED;
 164                 //LCOV_EXCL_STOP
 165         }
 166
 167         __check_privilege_deinitialize();
 168
 169         g_privilege_allowed = true;
 170         pthread_mutex_unlock(&g_cynara_mutex);
 171         return VCE_ERROR_NONE;
 172 }
 173
 174 int __check_engine_feature_privilege()
 175 {
 176         if (0 != __vce_get_feature_enabled()) {
 177                 return VCE_ERROR_NOT_SUPPORTED;
 178         }
 179         if (0 != __vce_check_privilege()) {
 180                 return VCE_ERROR_PERMISSION_DENIED;
 181         }
 182
 183         return VCE_ERROR_NONE;
 184 }
 185
 186 int vce_main(int argc, char** argv, vce_request_callback_s *callback)
 187 {
 188         int ret;
 189         ret = __check_engine_feature_privilege();
 190         if (VCE_ERROR_NONE != ret)
 191                 return ret;
 192
 193         SLOG(LOG_DEBUG, TAG_VCD, "  ");
 194         SLOG(LOG_DEBUG, TAG_VCD, "  ");
 195         SLOG(LOG_INFO, TAG_VCD, "===== VC Engine Service Initialize");
 196
 197         ret = VCE_ERROR_NONE;
 198
 199         if (!ecore_init()) {
 200                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail ecore_init()");
 201                 return VCE_ERROR_OPERATION_FAILED;
 202         }
 203
 204         ret = vcd_initialize(callback);
 205         if (0 != ret) {
 206                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to initialize");
 207                 ecore_shutdown();
 208                 return ret;
 209         }
 210
 211         SLOG(LOG_INFO, TAG_VCD, "[Main] VC Engine Service start...");
 212
 213         SLOG(LOG_DEBUG, TAG_VCD, "=====");
 214         SLOG(LOG_DEBUG, TAG_VCD, "  ");
 215         SLOG(LOG_DEBUG, TAG_VCD, "  ");
 216
 217         return VCE_ERROR_NONE;
 218 }
 219
 220 int vce_send_result(vce_result_event_e event, int* result_id, int count, const char* all_result, const char* non_fixed_result, const char* nlu_result, const char* msg, int* user_info, void *user_data)
 221 {
 222         int ret = VCE_ERROR_NONE;
 223         ret = __check_engine_feature_privilege();
 224         if (VCE_ERROR_NONE != ret)
 225                 return ret;
 226
 227         if (event < VCE_RESULT_EVENT_SUCCESS || event > VCE_RESULT_EVENT_ERROR) {
 228                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 229                 return VCE_ERROR_INVALID_PARAMETER;
 230         }
 231
 232         if (NULL == all_result || NULL == non_fixed_result || NULL == nlu_result) {
 233                 SLOG(LOG_ERROR, TAG_VCD, "[INFO] Input parameter is NULL. (no result)");
 234         }
 235
 236         ret = vcd_send_result(event, result_id, count, all_result, non_fixed_result, nlu_result, msg, user_info, user_data);
 237         if (0 != ret) {
 238                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send result");
 239         } else {
 240                 SLOG(LOG_INFO, TAG_VCD, "[INFO] Success to send result");
 241         }
 242
 243         return ret;
 244 }
 245
 246
 247 int vce_send_asr_result(vce_asr_result_event_e event, const char* asr_result, void *user_data)
 248 {
 249         int ret = VCE_ERROR_NONE;
 250         ret = __check_engine_feature_privilege();
 251         if (VCE_ERROR_NONE != ret)
 252                 return ret;
 253
 254         if (event < VCE_ASR_RESULT_EVENT_FINAL_RESULT || event > VCE_ASR_RESULT_EVENT_ERROR) {
 255                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 256                 return VCE_ERROR_INVALID_PARAMETER;
 257         }
 258
 259         if (NULL == asr_result) {
 260                 SLOG(LOG_ERROR, TAG_VCD, "[INFO] Input parameter is NULL. (no result)");
 261         }
 262
 263         ret = vcd_send_asr_result(event, asr_result, user_data);
 264         if (0 != ret) {
 265                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send ASR result");
 266         } else {
 267                 SLOG(LOG_INFO, TAG_VCD, "[INFO] Success to send ASR result");
 268         }
 269
 270         return ret;
 271 }
 272
 273 int vce_send_specific_engine_result(const char* engine_app_id, const char* event, const char* result, void *user_info)
 274 {
 275         int ret = VCE_ERROR_NONE;
 276         ret = __check_engine_feature_privilege();
 277         if (VCE_ERROR_NONE != ret)
 278                 return ret;
 279
 280         if (NULL == engine_app_id || NULL == event) {
 281                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 282                 return VCE_ERROR_INVALID_PARAMETER;
 283         }
 284
 285         if (NULL == result) {
 286                 SLOG(LOG_ERROR, TAG_VCD, "[INFO] Input parameter is NULL. (no result)");
 287         }
 288
 289         ret = vcd_send_specific_engine_result(engine_app_id, event, result, user_info);
 290         if (0 != ret) {
 291                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send specific engine result, ret(%d)", ret);
 292         } else {
 293                 SLOG(LOG_INFO, TAG_VCD, "[INFO] Success to send specific engine result, event(%s), result(%s)", event, result);
 294         }
 295
 296         return ret;
 297 }
 298
 299 int vce_send_nlg_result(const char* nlg_result, void *user_data)
 300 {
 301         int ret = VCE_ERROR_NONE;
 302         ret = __check_engine_feature_privilege();
 303         if (VCE_ERROR_NONE != ret)
 304                 return ret;
 305
 306         if (NULL == nlg_result) {
 307                 SLOG(LOG_ERROR, TAG_VCD, "[INFO] Input parameter is NULL. (no result)");
 308         }
 309
 310         ret = vcd_send_nlg_result(nlg_result, user_data);
 311         if (0 != ret) {
 312                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send NLG result");
 313         } else {
 314                 SLOG(LOG_INFO, TAG_VCD, "[INFO] Success to send NLG result");
 315         }
 316
 317         return ret;
 318 }
 319
 320 int vce_send_error(vce_error_e error, const char* msg, void *user_data)
 321 {
 322         int ret = VCE_ERROR_NONE;
 323         ret = __check_engine_feature_privilege();
 324         if (VCE_ERROR_NONE != ret)
 325                 return ret;
 326
 327         if (NULL == msg) {
 328                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Input parameter is NULL. (no error message)");
 329         }
 330
 331         ret = vcd_send_error(error, msg, user_data);
 332
 333         if (0 != ret) {
 334                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send error");
 335         }
 336
 337         return ret;
 338 }
 339
 340
 341 /* Daemon API */
 342 int vce_get_foreach_command(vce_cmd_h vce_command, vce_command_cb callback, void* user_data)
 343 {
 344         if (0 != __vce_get_feature_enabled()) {
 345                 return VCE_ERROR_NOT_SUPPORTED;
 346         }
 347
 348         int ret = VCE_ERROR_NONE;
 349
 350         ret = vcd_get_foreach_command(vce_command, callback, user_data);
 351         if (0 != ret) {
 352                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get foreach command");
 353         }
 354
 355         return ret;
 356 }
 357
 358 int vce_get_command_count(vce_cmd_h vce_command, int* count)
 359 {
 360         if (0 != __vce_get_feature_enabled()) {
 361                 return VCE_ERROR_NOT_SUPPORTED;
 362         }
 363
 364         int ret = VCE_ERROR_NONE;
 365
 366         if (NULL == count) {
 367                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 368                 return VCE_ERROR_INVALID_PARAMETER;
 369         }
 370         ret = vcd_get_command_count(vce_command, count);
 371         if (0 != ret) {
 372                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get command count");
 373         }
 374
 375         return ret;
 376 }
 377
 378 int vce_get_audio_type(char** audio_type)
 379 {
 380         int ret;
 381         ret = __check_engine_feature_privilege();
 382         if (VCE_ERROR_NONE != ret)
 383                 return ret;
 384
 385         ret = vcd_get_audio_type(audio_type);
 386         if (0 != ret) {
 387                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get audio type");
 388         }
 389
 390         return ret;
 391 }
 392
 393 int vce_set_private_data(const char* key, const char* data)
 394 {
 395         int ret;
 396         ret = __check_engine_feature_privilege();
 397         if (VCE_ERROR_NONE != ret)
 398                 return ret;
 399
 400         if (NULL == key || NULL == data) {
 401                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 402                 return VCE_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         // TODO: Shoud be added updateEvent to client, need to ACR for update state.
 406         // if (!strncmp(key, "UpdateEventStart", strlen(key)))
 407         //      ret = vce_send_update_status(VCE_UPDATE_EVENT_START, NULL);
 408         // else if (!strncmp(key, "UpdateEventComplete", strlen(key)))
 409         //      ret = vce_send_update_status(VCE_UPDATE_EVENT_FINISH, NULL);
 410         // else if (!strncmp(key, "UpdateEventFail", strlen(key)))
 411         //      ret = vce_send_update_status(VCE_UPDATE_EVENT_FAIL, data);
 412         // if (0 != ret) {
 413         //      SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send update status, event(%s), msg(%s): ret(%d)", key, data, ret);
 414         //      return ret;
 415         // }
 416
 417         ret = vcd_set_private_data(key, data);
 418         if (0 != ret) {
 419                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data to vc manager");
 420         }
 421
 422         return ret;
 423 }
 424
 425 int vce_get_private_data(const char* key, char** data)
 426 {
 427         int ret;
 428         ret = __check_engine_feature_privilege();
 429         if (VCE_ERROR_NONE != ret)
 430                 return ret;
 431
 432         if (NULL == key || NULL == data) {
 433                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 434                 return VCE_ERROR_INVALID_PARAMETER;
 435         }
 436
 437         ret = vcd_get_private_data(key, data);
 438         if (0 != ret) {
 439                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get private data from vc manager");
 440         }
 441
 442         return ret;
 443 }
 444
 445 int vce_start_recording()
 446 {
 447         int ret;
 448         ret = __check_engine_feature_privilege();
 449         if (VCE_ERROR_NONE != ret)
 450                 return ret;
 451
 452         ret = vcd_start_recording();
 453         if (0 != ret) {
 454                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to start recording");
 455         }
 456
 457         return ret;
 458 }
 459
 460 int vce_stop_recording()
 461 {
 462         int ret;
 463         ret = __check_engine_feature_privilege();
 464         if (VCE_ERROR_NONE != ret)
 465                 return ret;
 466
 467         ret = vcd_stop_recording();
 468         if (0 != ret) {
 469                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to stop recording");
 470         }
 471
 472         return ret;
 473 }
 474
 475 int vce_send_update_status(vce_update_event_e update_event, const char* msg)
 476 {
 477         int ret;
 478         ret = __check_engine_feature_privilege();
 479         if (VCE_ERROR_NONE != ret)
 480                 return ret;
 481
 482         ret = vcd_send_update_status(update_event, msg);
 483         if (0 != ret) {
 484                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send update status");
 485         }
 486
 487         return ret;
 488 }
 489
 490 int vce_set_private_data_set_cb(vce_private_data_set_cb callback_func)
 491 {
 492         int ret;
 493         ret = __check_engine_feature_privilege();
 494         if (VCE_ERROR_NONE != ret)
 495                 return ret;
 496
 497         if (NULL == callback_func) {
 498                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 499                 return VCE_ERROR_INVALID_PARAMETER;
 500         }
 501
 502         ret = vcd_set_private_data_set_cb(callback_func);
 503         if (0 != ret) {
 504                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data set cb");
 505         }
 506
 507         return ret;
 508 }
 509
 510 int vce_set_private_data_requested_cb(vce_private_data_requested_cb callback_func)
 511 {
 512         int ret;
 513         ret = __check_engine_feature_privilege();
 514         if (VCE_ERROR_NONE != ret)
 515                 return ret;
 516
 517         if (NULL == callback_func) {
 518                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 519                 return VCE_ERROR_INVALID_PARAMETER;
 520         }
 521
 522         ret = vcd_set_private_data_requested_cb(callback_func);
 523         if (0 != ret) {
 524                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data requested cb");
 525         }
 526
 527         return ret;
 528 }
 529
 530 int vce_set_nlu_base_info_requested_cb(vce_nlu_base_info_requested_cb callback_func)
 531 {
 532         if (0 != __vce_get_feature_enabled()) {
 533                 return VCE_ERROR_NOT_SUPPORTED;
 534         }
 535
 536         if (NULL == callback_func) {
 537                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 538                 return VCE_ERROR_INVALID_PARAMETER;
 539         }
 540
 541         int ret = vcd_set_nlu_base_info_requested_cb(callback_func);
 542         if (0 != ret) {
 543                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set nlu-base info requested cb");
 544         }
 545
 546         return ret;
 547 }
 548
 549 int vce_set_specific_engine_request_cb(vce_specific_engine_request_cb callback_func)
 550 {
 551         if (0 != __vce_get_feature_enabled()) {
 552                 return VCE_ERROR_NOT_SUPPORTED;
 553         }
 554
 555         if (NULL == callback_func) {
 556                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 557                 return VCE_ERROR_INVALID_PARAMETER;
 558         }
 559
 560         int ret = vcd_set_specific_engine_request_cb(callback_func);
 561         if (0 != ret) {
 562                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set specific engine request cb");
 563         }
 564
 565         return ret;
 566 }
 567
 568 int vce_unset_specific_engine_request_cb(void)
 569 {
 570         if (0 != __vce_get_feature_enabled()) {
 571                 return VCE_ERROR_NOT_SUPPORTED;
 572         }
 573
 574         int ret = vcd_set_specific_engine_request_cb(NULL);
 575         if (0 != ret) {
 576                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset specific engine request cb");
 577         }
 578
 579         return ret;
 580 }
 581
 582 /* for TTS feedback */
 583 int vce_send_feedback_audio_format(int rate, vce_audio_channel_e channel, vce_audio_type_e audio_type)
 584 {
 585         int ret = VCE_ERROR_NONE;
 586         ret = __check_engine_feature_privilege();
 587         if (VCE_ERROR_NONE != ret)
 588                 return ret;
 589
 590         if (channel < VCE_AUDIO_CHANNEL_MONO || channel > VCE_AUDIO_CHANNEL_STEREO) {
 591                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 592                 return VCE_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         if (audio_type < VCE_AUDIO_TYPE_PCM_S16_LE || audio_type > VCE_AUDIO_TYPE_PCM_U8) {
 596                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 597                 return VCE_ERROR_INVALID_PARAMETER;
 598         }
 599
 600         ret = vcd_send_feedback_audio_format(rate, channel, audio_type);
 601         if (0 != ret) {
 602                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send feedback audio format");
 603         }
 604
 605         return ret;
 606 }
 607
 608 int vce_send_feedback_streaming(vce_feedback_event_e event, char* buffer, int len)
 609 {
 610         int ret = VCE_ERROR_NONE;
 611         ret = __check_engine_feature_privilege();
 612         if (VCE_ERROR_NONE != ret)
 613                 return ret;
 614
 615         if (NULL == buffer) {
 616                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Input parameter is NULL");
 617                 return VCE_ERROR_INVALID_PARAMETER;
 618         }
 619
 620         ret = vcd_send_feedback_streaming(event, buffer, len);
 621         if (0 != ret) {
 622                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send feedback streaming");
 623         }
 624
 625         return ret;
 626 }
 627
 628 int vce_set_request_tts_cb(vce_request_tts_cb callback_func, void* user_data)
 629 {
 630         if (NULL == callback_func) {
 631                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 632                 return VCE_ERROR_INVALID_PARAMETER;
 633         }
 634
 635         int ret = vcd_set_request_tts_cb(callback_func, user_data);
 636         if (0 != ret) {
 637                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set request tts cb");
 638         }
 639
 640         return ret;
 641 }
 642
 643 int vce_unset_request_tts_cb(void)
 644 {
 645         int ret = vcd_set_request_tts_cb(NULL, NULL);
 646         if (0 != ret) {
 647                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset request tts cb");
 648         }
 649
 650         return ret;
 651 }
 652
 653 int vce_set_cancel_tts_cb(vce_cancel_tts_cb callback_func, void* user_data)
 654 {
 655         if (NULL == callback_func) {
 656                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 657                 return VCE_ERROR_INVALID_PARAMETER;
 658         }
 659
 660         int ret = vcd_set_cancel_tts_cb(callback_func, user_data);
 661         if (0 != ret) {
 662                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set cancel tts cb");
 663         }
 664
 665         return ret;
 666 }
 667
 668 int vce_unset_cancel_tts_cb(void)
 669 {
 670         int ret = vcd_set_cancel_tts_cb(NULL, NULL);
 671         if (0 != ret) {
 672                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset cancel tts cb");
 673         }
 674
 675         return ret;
 676 }
 677
 678 int vce_set_tts_audio_format_request_cb(vce_tts_audio_format_request_cb callback_func, void* user_data)
 679 {
 680         if (NULL == callback_func) {
 681                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid parameter");
 682                 return VCE_ERROR_INVALID_PARAMETER;
 683         }
 684
 685         int ret = vcd_set_tts_audio_format_request_cb(callback_func, user_data);
 686         if (0 != ret) {
 687                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set get tts audio format cb");
 688         }
 689
 690         return ret;
 691 }
 692
 693 int vce_unset_get_tts_audio_format_cb(void)
 694 {
 695         int ret = vcd_set_tts_audio_format_request_cb(NULL, NULL);
 696         if (0 != ret) {
 697                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset request tts cb");
 698         }
 699
 700         return ret;
 701 }