common/vc_command.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 <libintl.h>
  19 #include <stdlib.h>
  20
  21 #include "vc_command.h"
  22 #include "vc_main.h"
  23 #include "voice_control_command.h"
  24 #include "voice_control_command_expand.h"
  25 #include "voice_control_common.h"
  26 #include "voice_control_key_defines.h"
  27
  28
  29 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
  30 {
  31         if (NULL == vc_cmd_list) {
  32                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
  33                 return VC_ERROR_INVALID_PARAMETER;
  34         }
  35
  36         vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
  37
  38         if (NULL == list) {
  39                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
  40                 return VC_ERROR_OUT_OF_MEMORY;
  41         }
  42
  43         list->index = -1;
  44         list->list = NULL;
  45
  46         *vc_cmd_list = (vc_cmd_list_h)list;
  47
  48         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
  49
  50         return VC_ERROR_NONE;
  51 }
  52
  53 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
  54 {
  55         if (NULL == vc_cmd_list) {
  56                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
  57                 return VC_ERROR_INVALID_PARAMETER;
  58         }
  59
  60         vc_cmd_list_remove_all(vc_cmd_list, release_command);
  61
  62         vc_cmd_list_s* list = NULL;
  63         list = (vc_cmd_list_s*)vc_cmd_list;
  64
  65         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
  66
  67         if (NULL != list) {
  68                 free(list);
  69                 list = NULL;
  70         }
  71
  72         return VC_ERROR_NONE;
  73 }
  74
  75 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
  76 {
  77         if (NULL == vc_cmd_list || NULL == count) {
  78                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
  79                 return VC_ERROR_INVALID_PARAMETER;
  80         }
  81
  82         vc_cmd_list_s* list = NULL;
  83         list = (vc_cmd_list_s*)vc_cmd_list;
  84
  85         *count = g_slist_length(list->list);
  86
  87         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
  88
  89         return VC_ERROR_NONE;
  90 }
  91
  92 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
  93 {
  94         if (NULL == vc_cmd_list || NULL == vc_command) {
  95                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
  96                 return VC_ERROR_INVALID_PARAMETER;
  97         }
  98
  99         vc_cmd_list_s* list = NULL;
 100         list = (vc_cmd_list_s*)vc_cmd_list;
 101
 102         vc_cmd_s* cmd = NULL;
 103         cmd = (vc_cmd_s*)vc_command;
 104
 105         list->list = g_slist_append(list->list, cmd);
 106
 107         if (1 == g_slist_length(list->list)) {
 108                 list->index = 0;
 109         }
 110
 111         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 112
 113         return VC_ERROR_NONE;
 114 }
 115
 116 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 117 {
 118         if (NULL == vc_cmd_list || NULL == vc_command) {
 119                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 120                 return VC_ERROR_INVALID_PARAMETER;
 121         }
 122
 123         vc_cmd_list_s* list = NULL;
 124         list = (vc_cmd_list_s*)vc_cmd_list;
 125
 126         vc_cmd_s* cmd = NULL;
 127         cmd = (vc_cmd_s*)vc_command;
 128
 129         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 130
 131         vc_cmd_s* temp_cmd = NULL;
 132         GSList *iter = NULL;
 133
 134         iter = g_slist_nth(list->list, 0);
 135
 136         while (NULL != iter) {
 137                 temp_cmd = iter->data;
 138
 139                 if (NULL != temp_cmd && cmd == temp_cmd) {
 140                         list->list = g_slist_remove(list->list, temp_cmd);
 141                         /*
 142                         if (true == release_command) {
 143                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
 144                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 145                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 146                                 free(temp_cmd);
 147                                 temp_cmd = NULL;
 148                         }
 149                         */
 150                 }
 151
 152                 iter = g_slist_next(iter);
 153         }
 154
 155         int count = g_slist_length(list->list);
 156
 157         if (0 == count) {
 158                 list->index = -1;
 159         } else if (list->index == count) {
 160                 list->index = count - 1;
 161         }
 162
 163         return VC_ERROR_NONE;
 164 }
 165
 166 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
 167 {
 168         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Destroy all command");
 169
 170         if (NULL == vc_cmd_list) {
 171                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 172                 return VC_ERROR_INVALID_PARAMETER;
 173         }
 174
 175         vc_cmd_list_s* list = NULL;
 176         list = (vc_cmd_list_s*)vc_cmd_list;
 177
 178         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
 179                 , list, release_command ? "true" : "false");
 180
 181         int count = g_slist_length(list->list);
 182
 183         int i ;
 184         vc_cmd_s *temp_cmd;
 185
 186         for (i = 0;i < count ;i++) {
 187                 temp_cmd = g_slist_nth_data(list->list, 0);
 188
 189                 if (NULL != temp_cmd) {
 190                         list->list = g_slist_remove(list->list, temp_cmd);
 191
 192                         if (true == release_command) {
 193                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
 194                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 195                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 196                                 free(temp_cmd);
 197                                 temp_cmd = NULL;
 198                         }
 199                 }
 200         }
 201
 202         list->index = -1;
 203
 204         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 205         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 206
 207         return VC_ERROR_NONE;
 208 }
 209
 210 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
 211 {
 212         if (NULL == vc_cmd_list) {
 213                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 214                 return VC_ERROR_INVALID_PARAMETER;
 215         }
 216
 217         vc_cmd_list_s* list = NULL;
 218         list = (vc_cmd_list_s*)vc_cmd_list;
 219
 220         int count = g_slist_length(list->list);
 221         int i ;
 222
 223         GSList *iter = NULL;
 224         vc_cmd_s *temp_cmd;
 225
 226         iter = g_slist_nth(list->list, 0);
 227
 228         for (i = 0;i < count;i++) {
 229                 temp_cmd = iter->data;
 230
 231                 if (NULL != temp_cmd) {
 232                         if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
 233                                 break;
 234                         }
 235
 236                 }
 237                 iter = g_slist_next(iter);
 238         }
 239
 240         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Foreach commands Done");
 241
 242         return VC_ERROR_NONE;
 243 }
 244
 245 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
 246 {
 247         if (NULL == vc_cmd_list) {
 248                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 249                 return VC_ERROR_INVALID_PARAMETER;
 250         }
 251
 252         vc_cmd_list_s* list = NULL;
 253         list = (vc_cmd_list_s*)vc_cmd_list;
 254
 255         if (0 == g_slist_length(list->list)) {
 256                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 257                 return VC_ERROR_EMPTY;
 258         }
 259
 260         list->index = 0;
 261
 262         return VC_ERROR_NONE;
 263 }
 264
 265 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
 266 {
 267         if (NULL == vc_cmd_list) {
 268                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 269                 return VC_ERROR_INVALID_PARAMETER;
 270         }
 271
 272         vc_cmd_list_s* list = NULL;
 273         list = (vc_cmd_list_s*)vc_cmd_list;
 274
 275         int count = g_slist_length(list->list);
 276
 277         if (0 == count) {
 278                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 279                 return VC_ERROR_EMPTY;
 280         } else {
 281                 list->index = count - 1;
 282                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 283         }
 284
 285         return VC_ERROR_NONE;
 286 }
 287
 288 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
 289 {
 290         if (NULL == vc_cmd_list) {
 291                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 292                 return VC_ERROR_INVALID_PARAMETER;
 293         }
 294
 295         vc_cmd_list_s* list = NULL;
 296         list = (vc_cmd_list_s*)vc_cmd_list;
 297
 298         int count = g_slist_length(list->list);
 299
 300         if (list->index < count - 1) {
 301                 list->index = list->index + 1;
 302                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 303         } else {
 304                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 305                 return VC_ERROR_ITERATION_END;
 306         }
 307
 308         return VC_ERROR_NONE;
 309 }
 310
 311 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
 312 {
 313         if (NULL == vc_cmd_list) {
 314                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 315                 return VC_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         vc_cmd_list_s* list = NULL;
 319         list = (vc_cmd_list_s*)vc_cmd_list;
 320
 321         if (list->index > 0) {
 322                 list->index = list->index - 1;
 323                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 324         } else {
 325                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 326                 return VC_ERROR_ITERATION_END;
 327         }
 328
 329         return VC_ERROR_NONE;
 330 }
 331
 332 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
 333 {
 334         if (NULL == vc_cmd_list || NULL == vc_command) {
 335                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 336                 return VC_ERROR_INVALID_PARAMETER;
 337         }
 338
 339         vc_cmd_list_s* list = NULL;
 340         list = (vc_cmd_list_s*)vc_cmd_list;
 341
 342         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
 343
 344         if (0 == g_slist_length(list->list)) {
 345                 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
 346                 *vc_command = NULL;
 347                 return VC_ERROR_EMPTY;
 348         }
 349
 350         vc_cmd_s *temp_cmd = NULL;
 351         temp_cmd = g_slist_nth_data(list->list, list->index);
 352
 353         *vc_command = (vc_cmd_h)temp_cmd;
 354
 355         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
 356
 357         return VC_ERROR_NONE;
 358 }
 359
 360
 361 int vc_cmd_create(vc_cmd_h* vc_command)
 362 {
 363         if (NULL == vc_command) {
 364                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 365                 return VC_ERROR_INVALID_PARAMETER;
 366         }
 367
 368         vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
 369
 370         if (NULL == command) {
 371                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 372                 return VC_ERROR_OUT_OF_MEMORY;
 373         }
 374
 375         command->pid = 0;
 376         command->id = 0;
 377         command->index = 0;
 378         command->type = VC_COMMAND_TYPE_NONE;
 379         command->format = VC_CMD_FORMAT_FIXED;
 380         command->command = NULL;
 381         command->parameter = NULL;
 382         command->domain = 0;
 383         command->key = VC_KEY_NONE;
 384         command->modifier = VC_MODIFIER_NONE;
 385
 386         *vc_command = (vc_cmd_h)command;
 387
 388         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 389
 390         return VC_ERROR_NONE;
 391 }
 392
 393 int vc_cmd_destroy(vc_cmd_h vc_command)
 394 {
 395         if (NULL == vc_command) {
 396                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 397                 return VC_ERROR_INVALID_PARAMETER;
 398         }
 399
 400         vc_cmd_s* command = NULL;
 401         command = (vc_cmd_s*)vc_command;
 402
 403         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 404
 405         if (NULL != command) {
 406                 if (NULL != command->command)   free(command->command);
 407                 if (NULL != command->parameter) free(command->parameter);
 408                 free(command);
 409                 command = NULL;
 410         }
 411
 412         return VC_ERROR_NONE;
 413 }
 414
 415 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 416 {
 417         if (NULL == vc_command) {
 418                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 419                 return VC_ERROR_INVALID_PARAMETER;
 420         }
 421
 422         vc_cmd_s* cmd = NULL;
 423         cmd = (vc_cmd_s*)vc_command;
 424
 425         if (NULL != cmd) {
 426                 cmd->id = id;
 427                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 428         }
 429
 430         return 0;
 431 }
 432
 433 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 434 {
 435         if (NULL == vc_command || NULL == id) {
 436                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 437                 return VC_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         vc_cmd_s* cmd = NULL;
 441         cmd = (vc_cmd_s*)vc_command;
 442
 443         if (NULL != cmd) {
 444                 *id = cmd->id;
 445                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 446         }
 447
 448         return 0;
 449 }
 450
 451 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 452 {
 453         if (NULL == vc_command) {
 454                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 455                 return VC_ERROR_INVALID_PARAMETER;
 456         }
 457
 458         vc_cmd_s* cmd = NULL;
 459         cmd = (vc_cmd_s*)vc_command;
 460
 461         if (NULL != cmd->command) {
 462                 free(cmd->command);
 463         }
 464
 465         cmd->command = NULL;
 466
 467         if (NULL != command) {
 468                 cmd->command = strdup(command);
 469         }
 470
 471         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 472
 473         return 0;
 474 }
 475
 476 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 477 {
 478         if (NULL == vc_command || NULL == command) {
 479                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 480                 return VC_ERROR_INVALID_PARAMETER;
 481         }
 482
 483         vc_cmd_s* cmd = NULL;
 484         cmd = (vc_cmd_s*)vc_command;
 485
 486         if (NULL != cmd->command) {
 487                 *command = strdup(gettext(cmd->command));
 488         }
 489
 490         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 491
 492         return 0;
 493 }
 494
 495 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 496 {
 497         if (NULL == vc_command) {
 498                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 499                 return VC_ERROR_INVALID_PARAMETER;
 500         }
 501
 502         vc_cmd_s* cmd = NULL;
 503         cmd = (vc_cmd_s*)vc_command;
 504
 505         if (NULL != cmd->parameter) {
 506                 free(cmd->parameter);
 507         }
 508
 509         cmd->parameter = NULL;
 510
 511         if (NULL != command) {
 512                 cmd->parameter = strdup(command);
 513                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] parameter(%s)", vc_command, cmd->parameter);
 514         }
 515
 516         return 0;
 517 }
 518
 519 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 520 {
 521         if (NULL == vc_command || NULL == command) {
 522                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 523                 return VC_ERROR_INVALID_PARAMETER;
 524         }
 525
 526         vc_cmd_s* cmd = NULL;
 527         cmd = (vc_cmd_s*)vc_command;
 528
 529         if (NULL != cmd->parameter) {
 530                 *command = strdup(gettext(cmd->parameter));
 531                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get nonfixed command][%p] nonfixed command(%s)", vc_command, *command);
 532         }
 533
 534         return 0;
 535 }
 536
 537 //int vc_cmd_set_type(vc_cmd_h vc_command, vc_cmd_type_e type)
 538 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
 539 {
 540         if (NULL == vc_command) {
 541                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 542                 return VC_ERROR_INVALID_PARAMETER;
 543         }
 544
 545         vc_cmd_s* cmd = NULL;
 546         cmd = (vc_cmd_s*)vc_command;
 547
 548         cmd->type = type;
 549
 550         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
 551
 552         return 0;
 553 }
 554
 555 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
 556 {
 557         if (NULL == vc_command || NULL == type) {
 558                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 559                 return VC_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         vc_cmd_s* cmd = NULL;
 563         cmd = (vc_cmd_s*)vc_command;
 564
 565         *type = cmd->type;
 566
 567         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
 568
 569         return 0;
 570 }
 571
 572 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
 573 {
 574         if (NULL == vc_command) {
 575                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 576                 return VC_ERROR_INVALID_PARAMETER;
 577         }
 578
 579         vc_cmd_s* cmd = NULL;
 580         cmd = (vc_cmd_s*)vc_command;
 581
 582         cmd->format = format;
 583
 584         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
 585
 586         return 0;
 587 }
 588
 589 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
 590 {
 591         if (NULL == vc_command || NULL == format) {
 592                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 593                 return VC_ERROR_INVALID_PARAMETER;
 594         }
 595
 596         vc_cmd_s* cmd = NULL;
 597         cmd = (vc_cmd_s*)vc_command;
 598
 599         *format = cmd->format;
 600
 601         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
 602
 603         return 0;
 604 }
 605
 606 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
 607 {
 608         if (NULL == vc_command) {
 609                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 610                 return VC_ERROR_INVALID_PARAMETER;
 611         }
 612
 613         vc_cmd_s* cmd = NULL;
 614         cmd = (vc_cmd_s*)vc_command;
 615
 616         cmd->pid = pid;
 617
 618         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
 619
 620         return 0;
 621 }
 622
 623 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
 624 {
 625         if (NULL == vc_command || NULL == pid) {
 626                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 627                 return VC_ERROR_INVALID_PARAMETER;
 628         }
 629
 630         vc_cmd_s* cmd = NULL;
 631         cmd = (vc_cmd_s*)vc_command;
 632
 633         *pid = cmd->pid;
 634
 635         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
 636
 637         return 0;
 638 }
 639
 640 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
 641 {
 642         if (NULL == vc_command) {
 643                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 644                 return VC_ERROR_INVALID_PARAMETER;
 645         }
 646
 647         vc_cmd_s* cmd = NULL;
 648         cmd = (vc_cmd_s*)vc_command;
 649
 650         cmd->domain = domain;
 651
 652         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
 653
 654         return 0;
 655 }
 656
 657 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
 658 {
 659         if (NULL == vc_command || NULL == domain) {
 660                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 661                 return VC_ERROR_INVALID_PARAMETER;
 662         }
 663
 664         vc_cmd_s* cmd = NULL;
 665         cmd = (vc_cmd_s*)vc_command;
 666
 667         *domain = cmd->domain;
 668
 669         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
 670
 671         return 0;
 672 }
 673
 674 /**
 675 * @brief Sets key value of command.
 676 *
 677 * @param[in] vc_command Command handle
 678 * @param[in] key key value
 679 * @param[in] modifier modifier value
 680 *
 681 * @return 0 on success, otherwise a negative error value
 682 * @retval #VC_ERROR_NONE Successful
 683 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 684 *
 685 * @see vc_cmd_get_result_key()
 686 */
 687 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
 688 {
 689         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
 690
 691         if (NULL == vc_command) {
 692                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 693                 return VC_ERROR_INVALID_PARAMETER;
 694         }
 695
 696         vc_cmd_s* cmd = NULL;
 697         cmd = (vc_cmd_s*)vc_command;
 698
 699         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
 700
 701         cmd->key = key;
 702         cmd->modifier = modifier;
 703
 704         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 705         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 706
 707         return 0;
 708 }
 709
 710 /**
 711 * @brief Gets key value of command.
 712 *
 713 * @param[in] vc_command Command handle
 714 * @param[out] key key value
 715 * @param[out] modifier modifier value
 716 *
 717 * @return 0 on success, otherwise a negative error value
 718 * @retval #VC_ERROR_NONE Successful
 719 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 720 *
 721 * @see vc_cmd_add_result_key()
 722 */
 723 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
 724 //int vc_command_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
 725 {
 726         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
 727
 728         if (NULL == vc_command || NULL == key || NULL == modifier) {
 729                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 730                 return VC_ERROR_INVALID_PARAMETER;
 731         }
 732
 733         vc_cmd_s* cmd = NULL;
 734         cmd = (vc_cmd_s*)vc_command;
 735
 736         *key = cmd->key;
 737         *modifier = cmd->modifier;
 738
 739         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 740         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 741
 742         return 0;
 743 }
 744
 745 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
 746 {
 747         if (NULL == vc_cmd_list) {
 748                 return -1;
 749         }
 750
 751         vc_cmd_list_s* list = NULL;
 752         list = (vc_cmd_list_s*)vc_cmd_list;
 753
 754         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
 755         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
 756
 757         int count = g_slist_length(list->list);
 758
 759         int i;
 760         vc_cmd_s *temp_cmd = NULL;
 761
 762         for (i = 0;i < count ;i++) {
 763                 temp_cmd = g_slist_nth_data(list->list, i);
 764
 765                 if (NULL != temp_cmd) {
 766                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
 767                                 i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
 768                 }
 769         }
 770
 771         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
 772         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 773
 774         return 0;
 775 }