client/tts_tidl.c

   1 /* *  Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   2 *  Licensed under the Apache License, Version 2.0 (the "License");
   3 *  you may not use this file except in compliance with the License.
   4 *  You may obtain a copy of the License at
   5 *  http://www.apache.org/licenses/LICENSE-2.0
   6 *  Unless required by applicable law or agreed to in writing, software
   7 *  distributed under the License is distributed on an "AS IS" BASIS,
   8 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   9 *  See the License for the specific language governing permissions and
  10 *  limitations under the License.
  11 */
  12
  13 #include <rpc-port.h>
  14 #include "tts_main.h"
  15 #include "tts_tidl.h"
  16 #include "tts_proxy.h"
  17 #include "tts_internal.h"
  18 #include "tts_client.h"
  19 #include "tts_core.h"
  20
  21 #define MAXSLEEP 128
  22 #define MAX_CONNECT_CHECK 100
  23
  24 typedef struct {
  25         int uid;
  26         bool connected;
  27         rpc_port_proxy_tts_h rpc_h;
  28         rpc_port_tts_notify_cb_h notify_cb_h;
  29         char* engine_app_id;
  30 } tts_tidl_info_s;
  31
  32 static GList* g_tidl_infos = NULL;
  33
  34 static tts_tidl_info_s* __get_tidl_info_s(int uid)
  35 {
  36         GList* iter = NULL;
  37         tts_tidl_info_s* info = NULL;
  38
  39         if (g_list_length(g_tidl_infos) > 0) {
  40                 /* Get a first item */
  41                 iter = g_list_first(g_tidl_infos);
  42
  43                 while (NULL != iter) {
  44                         info = iter->data;
  45
  46                         if (info->uid == uid) {
  47                                 return info;
  48                         }
  49
  50                         /* Next item */
  51                         iter = g_list_next(iter);
  52                 }
  53         }
  54
  55         return NULL;
  56 }
  57
  58 static void __reconnect(void *data)
  59 {
  60         int uid = (intptr_t)data;
  61
  62         tts_client_s *client = tts_client_get_by_uid(uid);
  63         if (!client)
  64                 return;
  65
  66         for (int nsec = 1; nsec <= MAXSLEEP; nsec <<= 1) {
  67                 if (0 == tts_tidl_open_connection(uid)) {
  68                         SLOG(LOG_DEBUG, TAG_TTSC, "Try to connect the service");
  69                         return;
  70                 }
  71
  72                 if (nsec <= MAXSLEEP/2)
  73                         sleep(nsec);
  74
  75                 SLOG(LOG_DEBUG, TAG_TTSC, "Retrying...");
  76         }
  77         return;
  78 }
  79
  80 static void __notify_cb(void *user_data, int pid, int uid, bundle *msg)
  81 {
  82         char *method = NULL;
  83         char *val = NULL;
  84         tts_client_s* client = tts_client_get_by_uid(uid);
  85         if (!client)
  86                 return;
  87
  88         SLOG(LOG_DEBUG, TAG_TTSC, "__notify_cb is invoked pid(%d) uid(%d)", pid, uid);
  89
  90         bundle_get_str(msg, TTS_BUNDLE_METHOD, &method);
  91
  92         if (0 == strncmp(TTSD_METHOD_HELLO, method, strlen(TTSD_METHOD_HELLO))) {
  93                 char* credential_needed = NULL;
  94                 char* ret = NULL;
  95                 bundle_get_str(msg, TTS_BUNDLE_CREDENTIAL_NEEDED, &credential_needed);
  96                 bundle_get_str(msg, TTS_BUNDLE_REASON, &ret);
  97
  98                 if (NULL != credential_needed && NULL != ret) {
  99                         tts_client_set_start_listening(uid, true);
 100                         tts_core_receive_hello(uid, atoi(ret), atoi(credential_needed));
 101                 } else {
 102                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get message(TTSD_METHOD_HELLO). pid(%d) uid(%d)", pid, uid);
 103                 }
 104         } else if (0 == strncmp(TTSD_METHOD_UTTERANCE_STARTED, method, strlen(TTSD_METHOD_UTTERANCE_STARTED))) {
 105                 bundle_get_str(msg, TTS_BUNDLE_UTTID, &val);
 106                 if (val) {
 107                         tts_core_notify_utt_started(client, atoi(val));
 108                 }
 109         } else if (0 == strncmp(TTSD_METHOD_UTTERANCE_COMPLETED, method, strlen(TTSD_METHOD_UTTERANCE_COMPLETED))) {
 110                 bundle_get_str(msg, TTS_BUNDLE_UTTID, &val);
 111                 if (val) {
 112                         tts_core_notify_utt_completeted(client, atoi(val));
 113                 }
 114         } else if (0 == strncmp(TTSD_METHOD_SET_STATE, method, strlen(TTSD_METHOD_SET_STATE))) {
 115                 bundle_get_str(msg, TTS_BUNDLE_STATE, &val);
 116                 if (val) {
 117                         tts_core_notify_state_changed_async(client, (tts_state_e)atoi(val));
 118                 }
 119         } else if (0 == strncmp(TTSD_METHOD_ERROR, method, strlen(TTSD_METHOD_ERROR))) {
 120                 char *uttid = NULL;
 121                 char *reason = NULL;
 122                 char *err_msg = NULL;
 123
 124                 bundle_get_str(msg, TTS_BUNDLE_REASON, &reason);
 125                 bundle_get_str(msg, TTS_BUNDLE_UTTID, &uttid);
 126                 bundle_get_str(msg, TTS_BUNDLE_ERR_MSG, &err_msg);
 127                 if (reason && uttid) {
 128                         tts_core_notify_error_async(client, atoi(reason), atoi(uttid), err_msg);
 129                 }
 130         } else {
 131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid msg");
 132         }
 133 }
 134
 135 static void __on_connected(rpc_port_proxy_tts_h h, void *user_data)
 136 {
 137         int uid = (intptr_t)user_data;
 138
 139         tts_client_s* client = tts_client_get_by_uid(uid);
 140         if (NULL == client) {
 141                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 142                 return;
 143         }
 144
 145         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 146         if (NULL == info) {
 147                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 148                 return;
 149         }
 150
 151         info->connected = true;
 152         if (0 != rpc_port_proxy_tts_invoke_set_mode(info->rpc_h, tts_client_get_mode(client))) {
 153                 SLOG(LOG_ERROR, TAG_TTSC, "Failed to set mode");
 154                 return;
 155         }
 156
 157         SLOG(LOG_DEBUG, TAG_TTSC, "Connected to server");
 158 }
 159
 160 static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
 161 {
 162         int uid = (intptr_t)user_data;
 163
 164         tts_client_s* client = tts_client_get_by_uid(uid);
 165         if (NULL == client) {
 166                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 167                 return;
 168         }
 169
 170         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 171         if (NULL == info) {
 172                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 173                 return;
 174         }
 175
 176         info->connected = false;
 177         if (tts_client_is_listening_started(uid)) {
 178                 tts_core_handle_service_reset();
 179                 SLOG(LOG_DEBUG, TAG_TTSC, "Disconnected from server");
 180
 181                 ecore_main_loop_thread_safe_call_async(__reconnect, user_data);
 182                 SLOG(LOG_DEBUG, TAG_TTSC, "Try to reconnect to server");
 183         }
 184 }
 185
 186 static void __on_rejected(rpc_port_proxy_tts_h h, void *user_data)
 187 {
 188         int uid = (intptr_t)user_data;
 189         tts_client_s *client = tts_client_get_by_uid(uid);
 190         if (!client)
 191                 return;
 192
 193         tts_core_notify_error_async(client, TTS_ERROR_PERMISSION_DENIED, client->utt_id, "Rejected");
 194         SLOG(LOG_DEBUG, TAG_TTSC, "Rejected from server");
 195 }
 196
 197 static void __get_engine_app_id(int mode, int size, char* app_id)
 198 {
 199         if (NULL == app_id) {
 200                 SLOG(LOG_ERROR, TAG_TTSC, "app_id is NULL");
 201                 return;
 202         }
 203
 204         char* engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
 205         if (NULL == engine_name) {
 206                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine name");
 207                 engine_name = strdup(TTS_SERVER_ENGINE_DEFAULT);
 208         }
 209
 210         char* mode_str = "";
 211         if (TTS_MODE_NOTIFICATION == mode) {
 212                 mode_str = TTS_NOTI_SERVER_MODE;
 213         } else if (TTS_MODE_SCREEN_READER == mode) {
 214                 mode_str = TTS_SR_SERVER_MODE;
 215         } else if (TTS_MODE_INTERRUPT == mode) {
 216                 mode_str = TTS_INTERRUPT_SERVER_MODE;
 217         }
 218
 219         snprintf(app_id, size, "%s%s", engine_name, mode_str);
 220         free(engine_name);
 221
 222         SLOG(LOG_INFO, TAG_TTSC, "engine app id : %s", app_id);
 223 }
 224
 225 static rpc_port_proxy_tts_h __create_rpc_port(int uid, const char* engine_app_id)
 226 {
 227         rpc_port_proxy_tts_callback_s rpc_callback = {
 228                 .connected = __on_connected,
 229                 .disconnected = __on_disconnected,
 230                 .rejected = __on_rejected
 231         };
 232
 233         rpc_port_proxy_tts_h handle = NULL;
 234         intptr_t ptr_uid = uid;
 235         if (0 != rpc_port_proxy_tts_create(engine_app_id, &rpc_callback, (void*)ptr_uid, &handle)) {
 236                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create proxy");
 237                 return NULL;
 238         }
 239
 240         return handle;
 241 }
 242
 243 int tts_tidl_open_connection(int uid)
 244 {
 245         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_open_connection");
 246
 247         tts_client_s* client = tts_client_get_by_uid(uid);
 248         if (NULL == client) {
 249                 SLOG(LOG_ERROR, TAG_TTSC, "[TIDL ERROR] Fail to get client");
 250                 return TTS_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         tts_tidl_info_s* info = (tts_tidl_info_s*)calloc(1, sizeof(tts_tidl_info_s));
 254         if (NULL == info) {
 255                 SLOG(LOG_ERROR, TAG_TTSC, "[TIDL ERROR] Fail to create tidl_info_s");
 256                 return TTS_ERROR_OUT_OF_MEMORY;
 257         }
 258
 259         tts_mode_e mode = tts_client_get_mode(client);
 260         char engine_app_id[256] = {0, };
 261         __get_engine_app_id(mode, 256, engine_app_id);
 262
 263         info->rpc_h = __create_rpc_port(uid, engine_app_id);
 264         if (NULL == info->rpc_h) {
 265                 SLOG(LOG_ERROR, TAG_TTSC, "[TIDL ERROR] Fail to create proxy");
 266                 free(info);
 267                 return TTS_ERROR_OPERATION_FAILED;
 268         }
 269
 270         info->engine_app_id = strdup(engine_app_id);
 271         info->uid = uid;
 272         g_tidl_infos = g_list_append(g_tidl_infos, info);
 273
 274         SLOG(LOG_ERROR, TAG_TTSC, "[TIDL] uid(%d) rpc_h(%p)", uid, info->rpc_h);
 275         return TTS_ERROR_NONE;
 276 }
 277
 278 int tts_tidl_close_connection(int uid)
 279 {
 280         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_close_connection");
 281
 282         tts_client_s* client = tts_client_get_by_uid(uid);
 283         if (NULL == client) {
 284                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 285                 return TTS_ERROR_INVALID_PARAMETER;
 286         }
 287
 288         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 289         if (NULL == info) {
 290                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 291                 return TTS_ERROR_INVALID_PARAMETER;
 292         }
 293
 294         if (0 != rpc_port_proxy_tts_destroy(info->rpc_h)) {
 295                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to disconnect");
 296                 return TTS_ERROR_OPERATION_FAILED;
 297         }
 298
 299         info->rpc_h = NULL;
 300         info->notify_cb_h = NULL;
 301
 302         free(info->engine_app_id);
 303         info->engine_app_id = NULL;
 304
 305         g_tidl_infos = g_list_remove(g_tidl_infos, info);
 306         free(info);
 307
 308         return TTS_ERROR_NONE;
 309 }
 310
 311 int tts_tidl_stop_listening(int uid)
 312 {
 313         if (false == tts_client_is_valid_uid(uid)) {
 314                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not valid");
 315                 return TTS_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         tts_client_set_start_listening(uid, false);
 319
 320         return TTS_ERROR_NONE;
 321 }
 322
 323 int tts_tidl_request_hello(int uid)
 324 {
 325         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 326
 327         tts_client_s* client = tts_client_get_by_uid(uid);
 328         if (NULL == client) {
 329                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 330                 return TTS_ERROR_INVALID_PARAMETER;
 331         }
 332
 333         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 334         if (NULL == info) {
 335                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 336                 return TTS_ERROR_INVALID_PARAMETER;
 337         }
 338
 339         tts_mode_e mode = tts_client_get_mode(client);
 340         char engine_app_id[256] = {0, };
 341         __get_engine_app_id(mode, 256, engine_app_id);
 342
 343         if (NULL == info->engine_app_id || 0 != strncmp(info->engine_app_id, engine_app_id, strlen(info->engine_app_id))) {
 344                 SLOG(LOG_INFO, TAG_TTSC, "[TIDL] tts engine is changed from (%s) to (%s)", info->engine_app_id, engine_app_id);
 345                 if (0 != rpc_port_proxy_tts_destroy(info->rpc_h)) {
 346                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to destroy old rpc_port");
 347                         return TTS_ERROR_OPERATION_FAILED;
 348                 }
 349
 350                 info->rpc_h = __create_rpc_port(uid, engine_app_id);
 351                 if (NULL == info->rpc_h) {
 352                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create proxy");
 353                         return TTS_ERROR_OPERATION_FAILED;
 354                 }
 355                 free(info->engine_app_id);
 356                 info->engine_app_id = strdup(engine_app_id);
 357         }
 358
 359         if (!info->connected) {
 360                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 361                 rpc_port_proxy_tts_connect(info->rpc_h);
 362                 return TTS_ERROR_OPERATION_FAILED;
 363         }
 364
 365         SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
 366         /* register callback - needed to create new client before adding callback */
 367         if (NULL != info->notify_cb_h) {
 368                 rpc_port_proxy_tts_notify_cb_dispose(info->rpc_h, info->notify_cb_h);
 369                 info->notify_cb_h = NULL;
 370         }
 371
 372         info->notify_cb_h = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
 373         rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, client->pid, uid, info->notify_cb_h);
 374
 375         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 376         return TTS_ERROR_NONE;
 377 }
 378
 379 static int __wait_tidl_connection(tts_tidl_info_s* info)
 380 {
 381         int cnt = 0;
 382         while (false == info->connected && MAX_CONNECT_CHECK > cnt) {
 383                 ecore_main_loop_iterate();
 384                 usleep(50000);
 385                 cnt++;
 386         }
 387
 388         if (false == info->connected) {
 389                 return TTS_ERROR_OPERATION_FAILED;
 390         }
 391
 392         return TTS_ERROR_NONE;
 393 }
 394
 395 int tts_tidl_request_hello_sync(int uid)
 396 {
 397         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 398
 399         tts_client_s* client = tts_client_get_by_uid(uid);
 400         if (NULL == client) {
 401                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 402                 return TTS_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 406         if (NULL == info) {
 407                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 408                 return TTS_ERROR_INVALID_PARAMETER;
 409         }
 410
 411         if (!info->connected) {
 412                 SLOG(LOG_WARN, TAG_TTSC, "[WARNNING] Stub is not Connected. Try to connect..");
 413                 rpc_port_proxy_tts_connect(info->rpc_h);
 414                 if (TTS_ERROR_NONE != __wait_tidl_connection(info)) {
 415                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect");
 416                         return TTS_ERROR_OPERATION_FAILED;
 417                 }
 418
 419                 SLOG(LOG_INFO, TAG_TTSC, "[TIDL] Stub is Connected");
 420         }
 421
 422         SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
 423         /* register callback - needed to create new client before adding callback */
 424         if (NULL != info->notify_cb_h) {
 425                 rpc_port_proxy_tts_notify_cb_dispose(info->rpc_h, info->notify_cb_h);
 426                 info->notify_cb_h = NULL;
 427         }
 428
 429         info->notify_cb_h = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
 430         if (0 != rpc_port_proxy_tts_invoke_register_cb_sync(info->rpc_h, client->pid, uid, info->notify_cb_h)) {
 431                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Failed to invoke register");
 432                 return TTS_ERROR_OPERATION_FAILED;
 433         }
 434
 435         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 436         return TTS_ERROR_NONE;
 437 }
 438
 439 int tts_tidl_request_initialize(int uid, bool* credential_needed)
 440 {
 441         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize");
 442
 443         tts_client_s* client = tts_client_get_by_uid(uid);
 444         if (NULL == client) {
 445                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 446                 return TTS_ERROR_INVALID_PARAMETER;
 447         }
 448
 449         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 450         if (NULL == info) {
 451                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 452                 return TTS_ERROR_INVALID_PARAMETER;
 453         }
 454
 455         bool temp;
 456
 457         if (!info->connected) {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 459                 return TTS_ERROR_OPERATION_FAILED;
 460         }
 461
 462         if (0 != rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, &temp)) {
 463                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
 464                 return TTS_ERROR_OPERATION_FAILED;
 465         }
 466
 467         *credential_needed = temp;
 468
 469         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : credential_needed(%d)", *credential_needed);
 470
 471         return TTS_ERROR_NONE;
 472 }
 473
 474 int tts_tidl_request_finalize(int uid)
 475 {
 476         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_finalize");
 477
 478         tts_client_s* client = tts_client_get_by_uid(uid);
 479         if (NULL == client) {
 480                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 481                 return TTS_ERROR_INVALID_PARAMETER;
 482         }
 483
 484         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 485         if (NULL == info) {
 486                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 487                 return TTS_ERROR_INVALID_PARAMETER;
 488         }
 489
 490         if (!info->connected) {
 491                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 492                 return TTS_ERROR_OPERATION_FAILED;
 493         }
 494
 495         if (0 != rpc_port_proxy_tts_invoke_finalize(info->rpc_h, uid)) {
 496                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
 497                 return TTS_ERROR_OPERATION_FAILED;
 498         }
 499
 500         tts_client_set_start_listening(uid, false);
 501         return TTS_ERROR_NONE;
 502 }
 503
 504 int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 505 {
 506         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_text");
 507
 508         tts_client_s* client = tts_client_get_by_uid(uid);
 509         if (NULL == client) {
 510                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 511                 return TTS_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 515         if (NULL == info) {
 516                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 517                 return TTS_ERROR_INVALID_PARAMETER;
 518         }
 519
 520         if (NULL == text || NULL == lang) {
 521                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 522                 return TTS_ERROR_INVALID_PARAMETER;
 523         }
 524
 525         if (!info->connected) {
 526                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 527                 return TTS_ERROR_OPERATION_FAILED;
 528         }
 529
 530         if (0 != rpc_port_proxy_tts_invoke_add_text(info->rpc_h, uid, text, lang, vctype, speed, uttid, credential)) {
 531                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request add text : Fail to invoke message");
 532                 return TTS_ERROR_OPERATION_FAILED;
 533         }
 534
 535         return TTS_ERROR_NONE;
 536 }
 537
 538 int tts_tidl_request_set_private_data(int uid, const char* key, const char* data)
 539 {
 540         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_private_data");
 541
 542         tts_client_s* client = tts_client_get_by_uid(uid);
 543         if (NULL == client) {
 544                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 545                 return TTS_ERROR_INVALID_PARAMETER;
 546         }
 547
 548         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 549         if (NULL == info) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 551                 return TTS_ERROR_INVALID_PARAMETER;
 552         }
 553
 554         if (NULL == key || NULL == data) {
 555                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 556                 return TTS_ERROR_INVALID_PARAMETER;
 557         }
 558
 559         if (!info->connected) {
 560                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 561                 return TTS_ERROR_OPERATION_FAILED;
 562         }
 563
 564         if (0 != rpc_port_proxy_tts_invoke_set_private(info->rpc_h, uid, key, data)) {
 565                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request set private data : Fail to invoke message");
 566                 return TTS_ERROR_OPERATION_FAILED;
 567         }
 568
 569         return TTS_ERROR_NONE;
 570 }
 571
 572 int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
 573 {
 574         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_get_private_data");
 575
 576         tts_client_s* client = tts_client_get_by_uid(uid);
 577         if (NULL == client) {
 578                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 579                 return TTS_ERROR_INVALID_PARAMETER;
 580         }
 581
 582         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 583         if (NULL == info) {
 584                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 585                 return TTS_ERROR_INVALID_PARAMETER;
 586         }
 587
 588         char *tmp = NULL;
 589
 590         if (NULL == key || NULL == data) {
 591                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 592                 return TTS_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         if (!info->connected) {
 596                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 597                 return TTS_ERROR_OPERATION_FAILED;
 598         }
 599
 600         if (0 != rpc_port_proxy_tts_invoke_get_private(info->rpc_h, uid, key, &tmp)) {
 601                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request get private data : Fail to invoke message");
 602                 free(tmp);
 603                 return TTS_ERROR_OPERATION_FAILED;
 604         }
 605         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 606
 607         *data = tmp;
 608
 609         return TTS_ERROR_NONE;
 610 }
 611
 612 int tts_tidl_request_play(int uid, const char* credential)
 613 {
 614         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play");
 615
 616         tts_client_s* client = tts_client_get_by_uid(uid);
 617         if (NULL == client) {
 618                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 619                 return TTS_ERROR_INVALID_PARAMETER;
 620         }
 621
 622         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 623         if (NULL == info) {
 624                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 625                 return TTS_ERROR_INVALID_PARAMETER;
 626         }
 627
 628         if (!info->connected) {
 629                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 630                 return TTS_ERROR_OPERATION_FAILED;
 631         }
 632
 633         if (0 != rpc_port_proxy_tts_invoke_play(info->rpc_h, uid, credential)) {
 634                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play : Fail to invoke message");
 635                 return TTS_ERROR_OPERATION_FAILED;
 636         }
 637
 638         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 639
 640         return TTS_ERROR_NONE;
 641 }
 642
 643 int tts_tidl_request_stop(int uid)
 644 {
 645         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop");
 646
 647         tts_client_s* client = tts_client_get_by_uid(uid);
 648         if (NULL == client) {
 649                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 650                 return TTS_ERROR_INVALID_PARAMETER;
 651         }
 652
 653         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 654         if (NULL == info) {
 655                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 656                 return TTS_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         if (!info->connected) {
 660                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 661                 return TTS_ERROR_OPERATION_FAILED;
 662         }
 663
 664         if (0 != rpc_port_proxy_tts_invoke_stop(info->rpc_h, uid)) {
 665                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request stop : Fail to invoke message");
 666                 return TTS_ERROR_OPERATION_FAILED;
 667         }
 668         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 669
 670         return TTS_ERROR_NONE;
 671 }
 672
 673 int tts_tidl_request_pause(int uid)
 674 {
 675         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_pause");
 676
 677         tts_client_s* client = tts_client_get_by_uid(uid);
 678         if (NULL == client) {
 679                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 680                 return TTS_ERROR_INVALID_PARAMETER;
 681         }
 682
 683         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 684         if (NULL == info) {
 685                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 686                 return TTS_ERROR_INVALID_PARAMETER;
 687         }
 688
 689         if (!info->connected) {
 690                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 691                 return TTS_ERROR_OPERATION_FAILED;
 692         }
 693
 694         if (0 != rpc_port_proxy_tts_invoke_pause(info->rpc_h, uid)) {
 695                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause : Fail to invoke message");
 696                 return TTS_ERROR_OPERATION_FAILED;
 697         }
 698
 699         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 700
 701         return TTS_ERROR_NONE;
 702 }
 703
 704 //LCOV_EXCL_START
 705 int tts_tidl_request_play_pcm(int uid)
 706 {
 707         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play_pcm");
 708
 709         tts_client_s* client = tts_client_get_by_uid(uid);
 710         if (NULL == client) {
 711                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 712                 return TTS_ERROR_INVALID_PARAMETER;
 713         }
 714
 715         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 716         if (NULL == info) {
 717                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 718                 return TTS_ERROR_INVALID_PARAMETER;
 719         }
 720
 721         if (!info->connected) {
 722                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 723                 return TTS_ERROR_OPERATION_FAILED;
 724         }
 725
 726         if (0 != rpc_port_proxy_tts_invoke_play_pcm(info->rpc_h, uid)) {
 727                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play pcm : Fail to invoke message");
 728                 return TTS_ERROR_OPERATION_FAILED;
 729         }
 730
 731         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 732
 733         return TTS_ERROR_NONE;
 734 }
 735
 736 int tts_tidl_request_stop_pcm(int uid)
 737 {
 738         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop_pcm");
 739
 740         tts_client_s* client = tts_client_get_by_uid(uid);
 741         if (NULL == client) {
 742                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 743                 return TTS_ERROR_INVALID_PARAMETER;
 744         }
 745
 746         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 747         if (NULL == info) {
 748                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 749                 return TTS_ERROR_INVALID_PARAMETER;
 750         }
 751
 752         if (!info->connected) {
 753                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 754                 return TTS_ERROR_OPERATION_FAILED;
 755         }
 756
 757         if (0 != rpc_port_proxy_tts_invoke_stop_pcm(info->rpc_h, uid)) {
 758                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message");
 759                 return TTS_ERROR_OPERATION_FAILED;
 760         }
 761
 762         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 763
 764         return TTS_ERROR_NONE;
 765 }
 766
 767 int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
 768 {
 769         SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_pcm");
 770
 771         tts_client_s* client = tts_client_get_by_uid(uid);
 772         if (NULL == client) {
 773                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 774                 return TTS_ERROR_INVALID_PARAMETER;
 775         }
 776
 777         tts_tidl_info_s* info = __get_tidl_info_s(uid);
 778         if (NULL == info) {
 779                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
 780                 return TTS_ERROR_INVALID_PARAMETER;
 781         }
 782
 783         if (!info->connected) {
 784                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
 785                 return TTS_ERROR_OPERATION_FAILED;
 786         }
 787
 788         rpc_port_array_char_h pcm_data = NULL;
 789         rpc_port_array_char_create(&pcm_data);
 790         if (NULL == pcm_data) {
 791                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create data handle");
 792                 return TTS_ERROR_OUT_OF_MEMORY;
 793         }
 794
 795         if (NULL != data && 0 < data_size) {
 796                 rpc_port_array_char_set_array_chars(pcm_data, (char*)data, data_size);
 797         } else {
 798                 SLOG(LOG_INFO, TAG_TTSC, "[TIDL] data is empty");
 799         }
 800
 801         int ret = rpc_port_proxy_tts_invoke_add_pcm(info->rpc_h, uid, event, pcm_data, data_size, audio_type, rate);
 802         rpc_port_array_char_destroy(pcm_data);
 803         if (0 != ret) {
 804                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message(%d)", ret);
 805                 return ret;
 806         }
 807
 808         SLOG(LOG_DEBUG, TAG_TTSC, "<<<<");
 809
 810         return TTS_ERROR_NONE;
 811 }
 812 // LCOV_EXCL_STOP