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, int type)
 538 {
 539         if (NULL == vc_command) {
 540                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 541                 return VC_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         vc_cmd_s* cmd = NULL;
 545         cmd = (vc_cmd_s*)vc_command;
 546
 547         cmd->type = type;
 548
 549         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
 550
 551         return 0;
 552 }
 553
 554 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
 555 {
 556         if (NULL == vc_command || NULL == type) {
 557                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 558                 return VC_ERROR_INVALID_PARAMETER;
 559         }
 560
 561         vc_cmd_s* cmd = NULL;
 562         cmd = (vc_cmd_s*)vc_command;
 563
 564         *type = cmd->type;
 565
 566         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
 567
 568         return 0;
 569 }
 570
 571 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
 572 {
 573         if (NULL == vc_command) {
 574                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 575                 return VC_ERROR_INVALID_PARAMETER;
 576         }
 577
 578         vc_cmd_s* cmd = NULL;
 579         cmd = (vc_cmd_s*)vc_command;
 580
 581         cmd->format = format;
 582
 583         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
 584
 585         return 0;
 586 }
 587
 588 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
 589 {
 590         if (NULL == vc_command || NULL == format) {
 591                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 592                 return VC_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         vc_cmd_s* cmd = NULL;
 596         cmd = (vc_cmd_s*)vc_command;
 597
 598         *format = cmd->format;
 599
 600         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
 601
 602         return 0;
 603 }
 604
 605 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
 606 {
 607         if (NULL == vc_command) {
 608                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 609                 return VC_ERROR_INVALID_PARAMETER;
 610         }
 611
 612         vc_cmd_s* cmd = NULL;
 613         cmd = (vc_cmd_s*)vc_command;
 614
 615         cmd->pid = pid;
 616
 617         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
 618
 619         return 0;
 620 }
 621
 622 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
 623 {
 624         if (NULL == vc_command || NULL == pid) {
 625                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 626                 return VC_ERROR_INVALID_PARAMETER;
 627         }
 628
 629         vc_cmd_s* cmd = NULL;
 630         cmd = (vc_cmd_s*)vc_command;
 631
 632         *pid = cmd->pid;
 633
 634         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
 635
 636         return 0;
 637 }
 638
 639 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
 640 {
 641         if (NULL == vc_command) {
 642                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 643                 return VC_ERROR_INVALID_PARAMETER;
 644         }
 645
 646         vc_cmd_s* cmd = NULL;
 647         cmd = (vc_cmd_s*)vc_command;
 648
 649         cmd->domain = domain;
 650
 651         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
 652
 653         return 0;
 654 }
 655
 656 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
 657 {
 658         if (NULL == vc_command || NULL == domain) {
 659                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 660                 return VC_ERROR_INVALID_PARAMETER;
 661         }
 662
 663         vc_cmd_s* cmd = NULL;
 664         cmd = (vc_cmd_s*)vc_command;
 665
 666         *domain = cmd->domain;
 667
 668         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
 669
 670         return 0;
 671 }
 672
 673 /**
 674 * @brief Sets key value of command.
 675 *
 676 * @param[in] vc_command Command handle
 677 * @param[in] key key value
 678 * @param[in] modifier modifier value
 679 *
 680 * @return 0 on success, otherwise a negative error value
 681 * @retval #VC_ERROR_NONE Successful
 682 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 683 *
 684 * @see vc_cmd_get_result_key()
 685 */
 686 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
 687 {
 688         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
 689
 690         if (NULL == vc_command) {
 691                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 692                 return VC_ERROR_INVALID_PARAMETER;
 693         }
 694
 695         vc_cmd_s* cmd = NULL;
 696         cmd = (vc_cmd_s*)vc_command;
 697
 698         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
 699
 700         cmd->key = key;
 701         cmd->modifier = modifier;
 702
 703         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 704         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 705
 706         return 0;
 707 }
 708
 709 /**
 710 * @brief Gets key value of command.
 711 *
 712 * @param[in] vc_command Command handle
 713 * @param[out] key key value
 714 * @param[out] modifier modifier value
 715 *
 716 * @return 0 on success, otherwise a negative error value
 717 * @retval #VC_ERROR_NONE Successful
 718 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 719 *
 720 * @see vc_cmd_add_result_key()
 721 */
 722 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
 723 {
 724         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
 725
 726         if (NULL == vc_command || NULL == key || NULL == modifier) {
 727                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 728                 return VC_ERROR_INVALID_PARAMETER;
 729         }
 730
 731         vc_cmd_s* cmd = NULL;
 732         cmd = (vc_cmd_s*)vc_command;
 733
 734         *key = cmd->key;
 735         *modifier = cmd->modifier;
 736
 737         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 738         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 739
 740         return 0;
 741 }
 742
 743 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
 744 {
 745         if (NULL == vc_cmd_list) {
 746                 return -1;
 747         }
 748
 749         vc_cmd_list_s* list = NULL;
 750         list = (vc_cmd_list_s*)vc_cmd_list;
 751
 752         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
 753         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
 754
 755         int count = g_slist_length(list->list);
 756
 757         int i;
 758         vc_cmd_s *temp_cmd = NULL;
 759
 760         for (i = 0; i < count ; i++) {
 761                 temp_cmd = g_slist_nth_data(list->list, i);
 762
 763                 if (NULL != temp_cmd) {
 764                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
 765                                  i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
 766                 }
 767         }
 768
 769         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
 770         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 771
 772         return 0;
 773 }