client/vc_client.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_client.h"
  19
  20 typedef struct {
  21         /* base info */
  22         int     pid;
  23
  24         vc_result_cb                    result_cb;
  25         void*                           result_user_data;
  26         vc_error_cb                     error_cb;
  27         void*                           error_user_data;
  28         vc_service_state_changed_cb     service_state_changed_cb;
  29         void*                           service_state_changed_user_data;
  30         vc_state_changed_cb             state_changed_cb;
  31         void*                           state_changed_user_data;
  32         vc_current_language_changed_cb  current_lang_changed_cb;
  33         void*                           current_lang_changed_user_data;
  34
  35         /* tts feedback */
  36         vc_tts_streaming_cb tts_streaming_cb;
  37         void*                           tts_streaming_user_data;
  38         vc_tts_utterance_status_cb      tts_utterance_status_cb;
  39         void*                                           tts_utterance_status_user_data;
  40
  41 #if 0
  42         /* exclusive option */
  43         bool                    exclusive_cmd;
  44 #endif
  45
  46         /* service state */
  47         vc_service_state_e      service_state;
  48
  49         /* state */
  50         vc_state_e      previous_state;
  51         vc_state_e      current_state;
  52
  53         /* mutex */
  54         int     cb_ref_count;
  55
  56         /* error data */
  57         int     reason;
  58
  59         /* Authority */
  60         vc_auth_state_e         auth_previous_state;
  61         vc_auth_state_e         auth_current_state;
  62         vc_auth_state_changed_cb        auth_state_changed_cb;
  63         void*                           auth_state_changed_user_data;
  64
  65         int     mgr_pid;
  66
  67         /* is foreground */
  68         bool    is_foreground;
  69
  70         /* Invocation name */
  71         char*   invocation_name;
  72
  73         /* Listening IPC message from service */
  74         bool    start_listening;
  75 } vc_client_s;
  76
  77 static vc_client_s *g_client = NULL;
  78
  79
  80 int vc_client_create(void)
  81 {
  82         if (NULL != g_client) {
  83                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] A client is already exist.");
  84                 return VC_ERROR_NONE;
  85         }
  86
  87         g_client = (vc_client_s*)calloc(1, sizeof(vc_client_s));
  88         if (NULL == g_client) {
  89                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
  90                 return VC_ERROR_OUT_OF_MEMORY;
  91         }
  92
  93         /* initialize client data */
  94         g_client->pid = getpid();
  95
  96         g_client->result_cb = NULL;
  97         g_client->result_user_data = NULL;
  98         g_client->service_state_changed_cb = NULL;
  99         g_client->service_state_changed_user_data = NULL;
 100         g_client->state_changed_cb = NULL;
 101         g_client->state_changed_user_data = NULL;
 102         g_client->current_lang_changed_cb = NULL;
 103         g_client->current_lang_changed_user_data = NULL;
 104         g_client->error_cb = NULL;
 105         g_client->error_user_data = NULL;
 106         g_client->tts_streaming_cb = NULL;
 107         g_client->tts_streaming_user_data = NULL;
 108         g_client->tts_utterance_status_cb = NULL;
 109         g_client->tts_utterance_status_user_data = NULL;
 110
 111 #if 0
 112         g_client->exclusive_cmd = false;
 113 #endif
 114
 115         g_client->service_state = VC_RUNTIME_INFO_NO_FOREGROUND;
 116
 117         g_client->previous_state = VC_STATE_INITIALIZED;
 118         g_client->current_state = VC_STATE_INITIALIZED;
 119
 120         g_client->cb_ref_count = 0;
 121
 122         /* Authority */
 123         g_client->auth_previous_state = VC_AUTH_STATE_NONE;
 124         g_client->auth_current_state = VC_AUTH_STATE_NONE;
 125         g_client->auth_state_changed_cb = NULL;
 126         g_client->auth_state_changed_user_data = NULL;
 127
 128         g_client->is_foreground = false;
 129         g_client->invocation_name = NULL;
 130         g_client->start_listening = false;
 131
 132         SLOG(LOG_INFO, TAG_VCC, "[INFO] client create. pid(%u)", g_client->pid);
 133
 134         return VC_ERROR_NONE;
 135 }
 136
 137 int vc_client_destroy(void)
 138 {
 139         if (NULL == g_client) {
 140                 SLOG(LOG_ERROR, TAG_VCC, "A client is already NULL"); //LCOV_EXCL_LINE
 141                 return VC_ERROR_NONE;
 142         }
 143
 144         while (0 != g_client->cb_ref_count) {
 145                 /* wait for release callback function */
 146                 usleep(10000);
 147         }
 148         if (NULL != g_client->invocation_name) {
 149                 free(g_client->invocation_name);
 150                 g_client->invocation_name = NULL;
 151         }
 152         free(g_client);
 153         g_client = NULL;
 154
 155         return VC_ERROR_NONE;
 156 }
 157
 158 bool vc_client_is_valid(void)
 159 {
 160         /* check handle */
 161         if (NULL == g_client) {
 162                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The current client is not valid");
 163                 return false;
 164         }
 165
 166         return true;
 167 }
 168
 169 /* set/get callback function */
 170 int vc_client_set_result_cb(vc_result_cb callback, void* user_data)
 171 {
 172         /* check handle */
 173         if (NULL == g_client)
 174                 return VC_ERROR_INVALID_PARAMETER;
 175
 176         g_client->result_cb = callback;
 177         g_client->result_user_data = user_data;
 178
 179         return VC_ERROR_NONE;
 180 }
 181
 182 //LCOV_EXCL_START
 183 int vc_client_get_result_cb(vc_result_cb* callback, void** user_data)
 184 {
 185         /* check handle */
 186         if (NULL == g_client)
 187                 return VC_ERROR_INVALID_PARAMETER;
 188
 189         *callback = g_client->result_cb;
 190         *user_data = g_client->result_user_data;
 191
 192         return VC_ERROR_NONE;
 193 }
 194 //LCOV_EXCL_STOP
 195
 196 int vc_client_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
 197 {
 198         /* check handle */
 199         if (NULL == g_client)
 200                 return VC_ERROR_INVALID_PARAMETER;
 201
 202         g_client->service_state_changed_cb = callback;
 203         g_client->service_state_changed_user_data = user_data;
 204
 205         return VC_ERROR_NONE;
 206 }
 207
 208 int vc_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data)
 209 {
 210         /* check handle */
 211         if (NULL == g_client)
 212                 return VC_ERROR_INVALID_PARAMETER;
 213
 214         *callback = g_client->service_state_changed_cb;
 215         *user_data = g_client->service_state_changed_user_data;
 216
 217         return VC_ERROR_NONE;
 218 }
 219
 220 int vc_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
 221 {
 222         /* check handle */
 223         if (NULL == g_client)
 224                 return VC_ERROR_INVALID_PARAMETER;
 225
 226         g_client->state_changed_cb = callback;
 227         g_client->state_changed_user_data = user_data;
 228
 229         return VC_ERROR_NONE;
 230 }
 231
 232 int vc_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data)
 233 {
 234         /* check handle */
 235         if (NULL == g_client)
 236                 return VC_ERROR_INVALID_PARAMETER;
 237
 238         *callback = g_client->state_changed_cb;
 239         *user_data = g_client->state_changed_user_data;
 240
 241         return VC_ERROR_NONE;
 242 }
 243
 244 int vc_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data)
 245 {
 246         /* check handle */
 247         if (NULL == g_client)
 248                 return VC_ERROR_INVALID_PARAMETER;
 249
 250         g_client->current_lang_changed_cb = callback;
 251         g_client->current_lang_changed_user_data = user_data;
 252
 253         return VC_ERROR_NONE;
 254 }
 255
 256 //LCOV_EXCL_START
 257 int vc_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data)
 258 {
 259         /* check handle */
 260         if (NULL == g_client)
 261                 return VC_ERROR_INVALID_PARAMETER;
 262
 263         *callback = g_client->current_lang_changed_cb;
 264         *user_data = g_client->current_lang_changed_user_data;
 265
 266         return VC_ERROR_NONE;
 267 }
 268 //LCOV_EXCL_STOP
 269
 270 int vc_client_set_error_cb(vc_error_cb callback, void* user_data)
 271 {
 272         /* check handle */
 273         if (NULL == g_client)
 274                 return VC_ERROR_INVALID_PARAMETER;
 275
 276         g_client->error_cb = callback;
 277         g_client->error_user_data = user_data;
 278
 279         return VC_ERROR_NONE;
 280 }
 281
 282 int vc_client_get_error_cb(vc_error_cb* callback, void** user_data)
 283 {
 284         /* check handle */
 285         if (NULL == g_client)
 286                 return VC_ERROR_INVALID_PARAMETER;
 287
 288         *callback = g_client->error_cb;
 289         *user_data = g_client->error_user_data;
 290
 291         return VC_ERROR_NONE;
 292 }
 293
 294 /* set/get option */
 295 int vc_client_set_service_state(vc_service_state_e state)
 296 {
 297         /* check handle */
 298         if (NULL == g_client)
 299                 return VC_ERROR_INVALID_PARAMETER;
 300
 301         g_client->service_state = state;
 302
 303         return VC_ERROR_NONE;
 304 }
 305
 306 int vc_client_get_service_state(vc_service_state_e* state)
 307 {
 308         /* check handle */
 309         if (NULL == g_client)
 310                 return VC_ERROR_INVALID_PARAMETER;
 311
 312         *state = g_client->service_state;
 313
 314         return VC_ERROR_NONE;
 315 }
 316
 317 int vc_client_set_client_state(vc_state_e state)
 318 {
 319         /* check handle */
 320         if (NULL == g_client)
 321                 return VC_ERROR_INVALID_PARAMETER;
 322
 323         g_client->previous_state = g_client->current_state;
 324         g_client->current_state = state;
 325
 326         return VC_ERROR_NONE;
 327 }
 328
 329 int vc_client_get_client_state(vc_state_e* state)
 330 {
 331         /* check handle */
 332         if (NULL == g_client)
 333                 return VC_ERROR_INVALID_PARAMETER;
 334
 335         *state = g_client->current_state;
 336
 337         return VC_ERROR_NONE;
 338 }
 339
 340 int vc_client_get_previous_state(vc_state_e* state, vc_state_e* previous_state)
 341 {
 342         /* check handle */
 343         if (NULL == g_client)
 344                 return VC_ERROR_INVALID_PARAMETER;
 345
 346         *previous_state = g_client->previous_state;
 347         *state = g_client->current_state;
 348
 349         return VC_ERROR_NONE;
 350 }
 351
 352 int vc_client_set_invocation_name(const char* invocation_name)
 353 {
 354         /* check handle */
 355         if (NULL == g_client)
 356                 return VC_ERROR_INVALID_PARAMETER;
 357
 358         if (NULL != g_client->invocation_name) {
 359                 free(g_client->invocation_name);
 360                 g_client->invocation_name = NULL;
 361         }
 362
 363         if (NULL != invocation_name) {
 364                 g_client->invocation_name = strdup(invocation_name);
 365         }
 366         return VC_ERROR_NONE;
 367 }
 368
 369 int vc_client_get_invocation_name(char** invocation_name)
 370 {
 371         /* check handle */
 372         if (NULL == g_client)
 373                 return VC_ERROR_INVALID_PARAMETER;
 374
 375         if (NULL != g_client->invocation_name)
 376                 *invocation_name = strdup(g_client->invocation_name);
 377         return VC_ERROR_NONE;
 378 }
 379
 380 //LCOV_EXCL_START
 381 int vc_client_set_is_foreground(bool value)
 382 {
 383         /* check handle */
 384         if (NULL == g_client)
 385                 return VC_ERROR_INVALID_PARAMETER;
 386
 387         g_client->is_foreground = value;
 388         return VC_ERROR_NONE;
 389 }
 390
 391 int vc_client_get_is_foreground(bool* value)
 392 {
 393         /* check handle */
 394         if (NULL == g_client)
 395                 return VC_ERROR_INVALID_PARAMETER;
 396
 397         *value = g_client->is_foreground;
 398
 399         return VC_ERROR_NONE;
 400 }
 401
 402 #if 0
 403 int vc_client_set_exclusive_cmd(vc_h vc, bool value)
 404 {
 405         vc_client_s* client = __client_get(vc);
 406
 407         /* check handle */
 408         if (NULL == client)
 409                 return VC_ERROR_INVALID_PARAMETER;
 410
 411         client->exclusive_cmd = value;
 412
 413         return VC_ERROR_NONE;
 414 }
 415
 416 int vc_client_get_exclusive_cmd(vc_h vc, bool* value)
 417 {
 418         vc_client_s* client = __client_get(vc);
 419
 420         /* check handle */
 421         if (NULL == client)
 422                 return VC_ERROR_INVALID_PARAMETER;
 423
 424         *value = client->exclusive_cmd;
 425
 426         return VC_ERROR_NONE;
 427 }
 428 #endif
 429 //LCOV_EXCL_STOP
 430
 431 int vc_client_set_error(int reason)
 432 {
 433         /* check handle */
 434         if (NULL == g_client)
 435                 return VC_ERROR_INVALID_PARAMETER;
 436
 437         g_client->reason = reason;
 438
 439         return VC_ERROR_NONE;
 440 }
 441
 442 int vc_client_get_error(int* reason)
 443 {
 444         /* check handle */
 445         if (NULL == g_client)
 446                 return VC_ERROR_INVALID_PARAMETER;
 447
 448         *reason = g_client->reason;
 449
 450         return VC_ERROR_NONE;
 451 }
 452
 453
 454 /* utils */
 455 int vc_client_use_callback(void)
 456 {
 457         /* check handle */
 458         if (NULL == g_client)
 459                 return VC_ERROR_INVALID_PARAMETER;
 460
 461         g_client->cb_ref_count++;
 462         return VC_ERROR_NONE;
 463 }
 464
 465 int vc_client_not_use_callback(void)
 466 {
 467         /* check handle */
 468         if (NULL == g_client)
 469                 return VC_ERROR_INVALID_PARAMETER;
 470
 471         g_client->cb_ref_count--;
 472         return VC_ERROR_NONE;
 473 }
 474
 475 //LCOV_EXCL_START
 476 /* Authority */
 477 int vc_client_set_auth_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
 478 {
 479         /* check handle */
 480         if (NULL == g_client)
 481                 return VC_ERROR_INVALID_PARAMETER;
 482
 483         g_client->auth_state_changed_cb = callback;
 484         g_client->auth_state_changed_user_data = user_data;
 485
 486         return VC_ERROR_NONE;
 487 }
 488
 489 int vc_client_get_auth_state_changed_cb(vc_auth_state_changed_cb* callback, void** user_data)
 490 {
 491         /* check handle */
 492         if (NULL == g_client)
 493                 return VC_ERROR_INVALID_PARAMETER;
 494
 495         *callback = g_client->auth_state_changed_cb;
 496         *user_data = g_client->auth_state_changed_user_data;
 497
 498         return VC_ERROR_NONE;
 499 }
 500
 501 int vc_client_unset_auth_state_changed_cb(void)
 502 {
 503         /* check handle */
 504         if (NULL == g_client)
 505                 return VC_ERROR_INVALID_PARAMETER;
 506
 507         g_client->auth_state_changed_cb = NULL;
 508         g_client->auth_state_changed_user_data = NULL;
 509
 510         return VC_ERROR_NONE;
 511 }
 512
 513 int vc_client_set_auth_state(vc_auth_state_e state)
 514 {
 515         /* check handle */
 516         if (NULL == g_client)
 517                 return VC_ERROR_INVALID_PARAMETER;
 518
 519         g_client->auth_previous_state = g_client->auth_current_state;
 520         g_client->auth_current_state = state;
 521
 522         return VC_ERROR_NONE;
 523 }
 524
 525 int vc_client_get_auth_state(vc_auth_state_e* state)
 526 {
 527         /* check handle */
 528         if (NULL == g_client)
 529                 return VC_ERROR_INVALID_PARAMETER;
 530
 531         *state = g_client->auth_current_state;
 532
 533         return VC_ERROR_NONE;
 534 }
 535
 536 int vc_client_get_previous_auth_state(vc_auth_state_e* previous, vc_auth_state_e* current)
 537 {
 538         /* check handle */
 539         if (NULL == g_client)
 540                 return VC_ERROR_INVALID_PARAMETER;
 541
 542         *previous = g_client->auth_previous_state;
 543         *current = g_client->auth_current_state;
 544
 545         return VC_ERROR_NONE;
 546 }
 547 //LCOV_EXCL_STOP
 548
 549 int vc_client_set_mgr_pid(int mgr_pid)
 550 {
 551         /* check handle */
 552         if (NULL == g_client)
 553                 return VC_ERROR_INVALID_PARAMETER;
 554
 555         g_client->mgr_pid = mgr_pid;
 556
 557         return VC_ERROR_NONE;
 558 }
 559
 560 int vc_client_get_mgr_pid(int* mgr_pid)
 561 {
 562         /* check handle */
 563         if (NULL == g_client)
 564                 return VC_ERROR_INVALID_PARAMETER;
 565
 566         *mgr_pid = g_client->mgr_pid;
 567
 568         return VC_ERROR_NONE;
 569 }
 570
 571 int vc_client_set_tts_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
 572 {
 573         /* check handle */
 574         if (NULL == g_client)
 575                 return VC_ERROR_INVALID_PARAMETER;
 576
 577         g_client->tts_streaming_cb = callback;
 578         g_client->tts_streaming_user_data = user_data;
 579
 580         return VC_ERROR_NONE;
 581 }
 582
 583 //LCOV_EXCL_START
 584 int vc_client_get_tts_streaming_cb(vc_tts_streaming_cb* callback, void** user_data)
 585 {
 586         /* check handle */
 587         if (NULL == g_client)
 588                 return VC_ERROR_INVALID_PARAMETER;
 589
 590         *callback = g_client->tts_streaming_cb;
 591         *user_data = g_client->tts_streaming_user_data;
 592
 593         return VC_ERROR_NONE;
 594 }
 595 //LCOV_EXCL_STOP
 596
 597 int vc_client_set_tts_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
 598 {
 599         /* check handle */
 600         if (NULL == g_client)
 601                 return VC_ERROR_INVALID_PARAMETER;
 602
 603         g_client->tts_utterance_status_cb = callback;
 604         g_client->tts_utterance_status_user_data = user_data;
 605
 606         return VC_ERROR_NONE;
 607 }
 608
 609 //LCOV_EXCL_START
 610 int vc_client_get_tts_utterance_status_cb(vc_tts_utterance_status_cb* callback, void** user_data)
 611 {
 612         /* check handle */
 613         if (NULL == g_client)
 614                 return VC_ERROR_INVALID_PARAMETER;
 615
 616         *callback = g_client->tts_utterance_status_cb;
 617         *user_data = g_client->tts_utterance_status_user_data;
 618
 619         return VC_ERROR_NONE;
 620 }
 621 //LCOV_EXCL_STOP
 622
 623 int vc_client_set_start_listening(bool is_listening_started)
 624 {
 625         if (NULL == g_client)
 626                 return VC_ERROR_INVALID_PARAMETER;
 627
 628         g_client->start_listening = is_listening_started;
 629         return VC_ERROR_NONE;
 630 }
 631
 632 bool vc_client_is_listening_started()
 633 {
 634         if (NULL == g_client)
 635                 return false;
 636
 637         return g_client->start_listening;
 638 }