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 //LCOV_EXCL_START
 209 int vc_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data)
 210 {
 211         /* check handle */
 212         if (NULL == g_client)
 213                 return VC_ERROR_INVALID_PARAMETER;
 214
 215         *callback = g_client->service_state_changed_cb;
 216         *user_data = g_client->service_state_changed_user_data;
 217
 218         return VC_ERROR_NONE;
 219 }
 220 //LCOV_EXCL_STOP
 221
 222 int vc_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
 223 {
 224         /* check handle */
 225         if (NULL == g_client)
 226                 return VC_ERROR_INVALID_PARAMETER;
 227
 228         g_client->state_changed_cb = callback;
 229         g_client->state_changed_user_data = user_data;
 230
 231         return VC_ERROR_NONE;
 232 }
 233
 234 //LCOV_EXCL_START
 235 int vc_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data)
 236 {
 237         /* check handle */
 238         if (NULL == g_client)
 239                 return VC_ERROR_INVALID_PARAMETER;
 240
 241         *callback = g_client->state_changed_cb;
 242         *user_data = g_client->state_changed_user_data;
 243
 244         return VC_ERROR_NONE;
 245 }
 246 //LCOV_EXCL_STOP
 247
 248 int vc_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data)
 249 {
 250         /* check handle */
 251         if (NULL == g_client)
 252                 return VC_ERROR_INVALID_PARAMETER;
 253
 254         g_client->current_lang_changed_cb = callback;
 255         g_client->current_lang_changed_user_data = user_data;
 256
 257         return VC_ERROR_NONE;
 258 }
 259
 260 //LCOV_EXCL_START
 261 int vc_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data)
 262 {
 263         /* check handle */
 264         if (NULL == g_client)
 265                 return VC_ERROR_INVALID_PARAMETER;
 266
 267         *callback = g_client->current_lang_changed_cb;
 268         *user_data = g_client->current_lang_changed_user_data;
 269
 270         return VC_ERROR_NONE;
 271 }
 272 //LCOV_EXCL_STOP
 273
 274 int vc_client_set_error_cb(vc_error_cb callback, void* user_data)
 275 {
 276         /* check handle */
 277         if (NULL == g_client)
 278                 return VC_ERROR_INVALID_PARAMETER;
 279
 280         g_client->error_cb = callback;
 281         g_client->error_user_data = user_data;
 282
 283         return VC_ERROR_NONE;
 284 }
 285
 286 //LCOV_EXCL_START
 287 int vc_client_get_error_cb(vc_error_cb* callback, void** user_data)
 288 {
 289         /* check handle */
 290         if (NULL == g_client)
 291                 return VC_ERROR_INVALID_PARAMETER;
 292
 293         *callback = g_client->error_cb;
 294         *user_data = g_client->error_user_data;
 295
 296         return VC_ERROR_NONE;
 297 }
 298 //LCOV_EXCL_STOP
 299
 300 /* set/get option */
 301 int vc_client_set_service_state(vc_service_state_e state)
 302 {
 303         /* check handle */
 304         if (NULL == g_client)
 305                 return VC_ERROR_INVALID_PARAMETER;
 306
 307         g_client->service_state = state;
 308
 309         return VC_ERROR_NONE;
 310 }
 311
 312 int vc_client_get_service_state(vc_service_state_e* state)
 313 {
 314         /* check handle */
 315         if (NULL == g_client)
 316                 return VC_ERROR_INVALID_PARAMETER;
 317
 318         *state = g_client->service_state;
 319
 320         return VC_ERROR_NONE;
 321 }
 322
 323 int vc_client_set_client_state(vc_state_e state)
 324 {
 325         /* check handle */
 326         if (NULL == g_client)
 327                 return VC_ERROR_INVALID_PARAMETER;
 328
 329         g_client->previous_state = g_client->current_state;
 330         g_client->current_state = state;
 331
 332         return VC_ERROR_NONE;
 333 }
 334
 335 int vc_client_get_client_state(vc_state_e* state)
 336 {
 337         /* check handle */
 338         if (NULL == g_client)
 339                 return VC_ERROR_INVALID_PARAMETER;
 340
 341         *state = g_client->current_state;
 342
 343         return VC_ERROR_NONE;
 344 }
 345
 346 int vc_client_get_previous_state(vc_state_e* state, vc_state_e* previous_state)
 347 {
 348         /* check handle */
 349         if (NULL == g_client)
 350                 return VC_ERROR_INVALID_PARAMETER;
 351
 352         *previous_state = g_client->previous_state;
 353         *state = g_client->current_state;
 354
 355         return VC_ERROR_NONE;
 356 }
 357
 358 int vc_client_set_invocation_name(const char* invocation_name)
 359 {
 360         /* check handle */
 361         if (NULL == g_client)
 362                 return VC_ERROR_INVALID_PARAMETER;
 363
 364         if (NULL != g_client->invocation_name) {
 365                 free(g_client->invocation_name);
 366                 g_client->invocation_name = NULL;
 367         }
 368
 369         if (NULL != invocation_name) {
 370                 g_client->invocation_name = strdup(invocation_name);
 371         }
 372         return VC_ERROR_NONE;
 373 }
 374
 375 int vc_client_get_invocation_name(char** invocation_name)
 376 {
 377         /* check handle */
 378         if (NULL == g_client)
 379                 return VC_ERROR_INVALID_PARAMETER;
 380
 381         if (NULL != g_client->invocation_name)
 382                 *invocation_name = strdup(g_client->invocation_name);
 383         return VC_ERROR_NONE;
 384 }
 385
 386 int vc_client_set_is_foreground(bool value)
 387 {
 388         /* check handle */
 389         if (NULL == g_client)
 390                 return VC_ERROR_INVALID_PARAMETER;
 391
 392         g_client->is_foreground = value;
 393         return VC_ERROR_NONE;
 394 }
 395
 396 int vc_client_get_is_foreground(bool* value)
 397 {
 398         /* check handle */
 399         if (NULL == g_client)
 400                 return VC_ERROR_INVALID_PARAMETER;
 401
 402         *value = g_client->is_foreground;
 403
 404         return VC_ERROR_NONE;
 405 }
 406
 407 //LCOV_EXCL_START
 408 #if 0
 409 int vc_client_set_exclusive_cmd(vc_h vc, bool value)
 410 {
 411         vc_client_s* client = __client_get(vc);
 412
 413         /* check handle */
 414         if (NULL == client)
 415                 return VC_ERROR_INVALID_PARAMETER;
 416
 417         client->exclusive_cmd = value;
 418
 419         return VC_ERROR_NONE;
 420 }
 421
 422 int vc_client_get_exclusive_cmd(vc_h vc, bool* value)
 423 {
 424         vc_client_s* client = __client_get(vc);
 425
 426         /* check handle */
 427         if (NULL == client)
 428                 return VC_ERROR_INVALID_PARAMETER;
 429
 430         *value = client->exclusive_cmd;
 431
 432         return VC_ERROR_NONE;
 433 }
 434 #endif
 435 //LCOV_EXCL_STOP
 436
 437 int vc_client_set_error(int reason)
 438 {
 439         /* check handle */
 440         if (NULL == g_client)
 441                 return VC_ERROR_INVALID_PARAMETER;
 442
 443         g_client->reason = reason;
 444
 445         return VC_ERROR_NONE;
 446 }
 447
 448 int vc_client_get_error(int* reason)
 449 {
 450         /* check handle */
 451         if (NULL == g_client)
 452                 return VC_ERROR_INVALID_PARAMETER;
 453
 454         *reason = g_client->reason;
 455
 456         return VC_ERROR_NONE;
 457 }
 458
 459
 460 /* utils */
 461 int vc_client_use_callback(void)
 462 {
 463         /* check handle */
 464         if (NULL == g_client)
 465                 return VC_ERROR_INVALID_PARAMETER;
 466
 467         g_client->cb_ref_count++;
 468         return VC_ERROR_NONE;
 469 }
 470
 471 int vc_client_not_use_callback(void)
 472 {
 473         /* check handle */
 474         if (NULL == g_client)
 475                 return VC_ERROR_INVALID_PARAMETER;
 476
 477         g_client->cb_ref_count--;
 478         return VC_ERROR_NONE;
 479 }
 480
 481 //LCOV_EXCL_START
 482 /* Authority */
 483 int vc_client_set_auth_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
 484 {
 485         /* check handle */
 486         if (NULL == g_client)
 487                 return VC_ERROR_INVALID_PARAMETER;
 488
 489         g_client->auth_state_changed_cb = callback;
 490         g_client->auth_state_changed_user_data = user_data;
 491
 492         return VC_ERROR_NONE;
 493 }
 494
 495 int vc_client_get_auth_state_changed_cb(vc_auth_state_changed_cb* callback, void** user_data)
 496 {
 497         /* check handle */
 498         if (NULL == g_client)
 499                 return VC_ERROR_INVALID_PARAMETER;
 500
 501         *callback = g_client->auth_state_changed_cb;
 502         *user_data = g_client->auth_state_changed_user_data;
 503
 504         return VC_ERROR_NONE;
 505 }
 506
 507 int vc_client_unset_auth_state_changed_cb(void)
 508 {
 509         /* check handle */
 510         if (NULL == g_client)
 511                 return VC_ERROR_INVALID_PARAMETER;
 512
 513         g_client->auth_state_changed_cb = NULL;
 514         g_client->auth_state_changed_user_data = NULL;
 515
 516         return VC_ERROR_NONE;
 517 }
 518
 519 int vc_client_set_auth_state(vc_auth_state_e state)
 520 {
 521         /* check handle */
 522         if (NULL == g_client)
 523                 return VC_ERROR_INVALID_PARAMETER;
 524
 525         g_client->auth_previous_state = g_client->auth_current_state;
 526         g_client->auth_current_state = state;
 527
 528         return VC_ERROR_NONE;
 529 }
 530
 531 int vc_client_get_auth_state(vc_auth_state_e* state)
 532 {
 533         /* check handle */
 534         if (NULL == g_client)
 535                 return VC_ERROR_INVALID_PARAMETER;
 536
 537         *state = g_client->auth_current_state;
 538
 539         return VC_ERROR_NONE;
 540 }
 541
 542 int vc_client_get_previous_auth_state(vc_auth_state_e* previous, vc_auth_state_e* current)
 543 {
 544         /* check handle */
 545         if (NULL == g_client)
 546                 return VC_ERROR_INVALID_PARAMETER;
 547
 548         *previous = g_client->auth_previous_state;
 549         *current = g_client->auth_current_state;
 550
 551         return VC_ERROR_NONE;
 552 }
 553 //LCOV_EXCL_STOP
 554
 555 int vc_client_set_mgr_pid(int mgr_pid)
 556 {
 557         /* check handle */
 558         if (NULL == g_client)
 559                 return VC_ERROR_INVALID_PARAMETER;
 560
 561         g_client->mgr_pid = mgr_pid;
 562
 563         return VC_ERROR_NONE;
 564 }
 565
 566 int vc_client_get_mgr_pid(int* mgr_pid)
 567 {
 568         /* check handle */
 569         if (NULL == g_client)
 570                 return VC_ERROR_INVALID_PARAMETER;
 571
 572         *mgr_pid = g_client->mgr_pid;
 573
 574         return VC_ERROR_NONE;
 575 }
 576
 577 int vc_client_set_tts_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
 578 {
 579         /* check handle */
 580         if (NULL == g_client)
 581                 return VC_ERROR_INVALID_PARAMETER;
 582
 583         g_client->tts_streaming_cb = callback;
 584         g_client->tts_streaming_user_data = user_data;
 585
 586         return VC_ERROR_NONE;
 587 }
 588
 589 int vc_client_get_tts_streaming_cb(vc_tts_streaming_cb* callback, void** user_data)
 590 {
 591         /* check handle */
 592         if (NULL == g_client)
 593                 return VC_ERROR_INVALID_PARAMETER;
 594
 595         *callback = g_client->tts_streaming_cb;
 596         *user_data = g_client->tts_streaming_user_data;
 597
 598         return VC_ERROR_NONE;
 599 }
 600
 601 int vc_client_set_tts_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
 602 {
 603         /* check handle */
 604         if (NULL == g_client)
 605                 return VC_ERROR_INVALID_PARAMETER;
 606
 607         g_client->tts_utterance_status_cb = callback;
 608         g_client->tts_utterance_status_user_data = user_data;
 609
 610         return VC_ERROR_NONE;
 611 }
 612
 613 int vc_client_get_tts_utterance_status_cb(vc_tts_utterance_status_cb* callback, void** user_data)
 614 {
 615         /* check handle */
 616         if (NULL == g_client)
 617                 return VC_ERROR_INVALID_PARAMETER;
 618
 619         *callback = g_client->tts_utterance_status_cb;
 620         *user_data = g_client->tts_utterance_status_user_data;
 621
 622         return VC_ERROR_NONE;
 623 }
 624
 625 int vc_client_set_start_listening(bool is_listening_started)
 626 {
 627         if (NULL == g_client)
 628                 return VC_ERROR_INVALID_PARAMETER;
 629
 630         g_client->start_listening = is_listening_started;
 631         return VC_ERROR_NONE;
 632 }
 633
 634 bool vc_client_is_listening_started()
 635 {
 636         if (NULL == g_client)
 637                 return false;
 638
 639         return g_client->start_listening;
 640 }