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 #include <cynara-client.h>
  18 #include <cynara-error.h>
  19 #include <cynara-session.h>
  20 #include <libintl.h>
  21 #include <stdlib.h>
  22 #include <system_info.h>
  23
  24 #include "vc_command.h"
  25 #include "vc_info_parser.h"
  26 #include "vc_main.h"
  27 #include "voice_control_command.h"
  28 #include "voice_control_command_expand.h"
  29 #include "voice_control_common.h"
  30 #include "voice_control_key_defines.h"
  31
  32 static int g_feature_enabled = -1;
  33
  34 static int g_privilege_allowed = 1; /* Always True */
  35 static cynara *p_cynara = NULL;
  36
  37 static int __vc_cmd_get_feature_enabled()
  38 {
  39         if (0 == g_feature_enabled) {
  40                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  41                 return VC_ERROR_NOT_SUPPORTED;
  42         } else if (-1 == g_feature_enabled) {
  43                 bool vc_supported = false;
  44                 bool mic_supported = false;
  45                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  46                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  47                                 if (false == vc_supported || false == mic_supported) {
  48                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  49                                         g_feature_enabled = 0;
  50                                         return VC_ERROR_NOT_SUPPORTED;
  51                                 }
  52
  53                                 g_feature_enabled = 1;
  54                         } else {
  55                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  56                                 return VC_ERROR_NOT_SUPPORTED;
  57                         }
  58                 } else {
  59                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  60                         return VC_ERROR_NOT_SUPPORTED;
  61                 }
  62         }
  63
  64         return 0;
  65 }
  66
  67 static int __check_privilege_initialize()
  68 {
  69         int ret = cynara_initialize(&p_cynara, NULL);
  70         if (CYNARA_API_SUCCESS != ret)
  71                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
  72
  73         return ret == CYNARA_API_SUCCESS;
  74 }
  75
  76 static int __check_privilege(const char* uid, const char * privilege)
  77 {
  78         FILE *fp = NULL;
  79         char label_path[1024] = "/proc/self/attr/current";
  80         char smack_label[1024] = {'\0',};
  81
  82         if (!p_cynara) {
  83             return false;
  84         }
  85
  86         fp = fopen(label_path, "r");
  87         if (fp != NULL) {
  88             if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
  89                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
  90
  91             fclose(fp);
  92         }
  93
  94         pid_t pid = getpid();
  95         char *session = cynara_session_from_pid(pid);
  96         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
  97         SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
  98         if (session)
  99             free(session);
 100
 101         if (ret != CYNARA_API_ACCESS_ALLOWED)
 102             return false;
 103         return true;
 104 }
 105
 106 static void __check_privilege_deinitialize()
 107 {
 108         if (p_cynara)
 109                 cynara_finish(p_cynara);
 110         p_cynara = NULL;
 111 }
 112
 113 static int __vc_cmd_check_privilege()
 114 {
 115         char uid[16];
 116
 117         if (0 == g_privilege_allowed) {
 118                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 119                 return VC_ERROR_PERMISSION_DENIED;
 120         } else if (-1 == g_privilege_allowed) {
 121                 if (false == __check_privilege_initialize()) {
 122                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
 123                         return VC_ERROR_PERMISSION_DENIED;
 124                 }
 125                 snprintf(uid, 16, "%d", getuid());
 126                 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
 127                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 128                         g_privilege_allowed = 0;
 129                         __check_privilege_deinitialize();
 130                         return VC_ERROR_PERMISSION_DENIED;
 131                 }
 132                 __check_privilege_deinitialize();
 133         }
 134
 135         g_privilege_allowed = 1;
 136
 137         return VC_ERROR_NONE;
 138 }
 139
 140 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
 141 {
 142         if (0 != __vc_cmd_get_feature_enabled()) {
 143                 return VC_ERROR_NOT_SUPPORTED;
 144         }
 145         if (0 != __vc_cmd_check_privilege()) {
 146                 return VC_ERROR_PERMISSION_DENIED;
 147         }
 148
 149         if (NULL == vc_cmd_list) {
 150                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 151                 return VC_ERROR_INVALID_PARAMETER;
 152         }
 153
 154         vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
 155
 156         if (NULL == list) {
 157                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 158                 return VC_ERROR_OUT_OF_MEMORY;
 159         }
 160
 161         list->index = -1;
 162         list->list = NULL;
 163
 164         *vc_cmd_list = (vc_cmd_list_h)list;
 165
 166         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
 167
 168         return VC_ERROR_NONE;
 169 }
 170
 171 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
 172 {
 173         if (0 != __vc_cmd_get_feature_enabled()) {
 174                 return VC_ERROR_NOT_SUPPORTED;
 175         }
 176         if (0 != __vc_cmd_check_privilege()) {
 177                 return VC_ERROR_PERMISSION_DENIED;
 178         }
 179
 180         if (NULL == vc_cmd_list) {
 181                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 182                 return VC_ERROR_INVALID_PARAMETER;
 183         }
 184
 185         vc_cmd_list_remove_all(vc_cmd_list, release_command);
 186
 187         vc_cmd_list_s* list = NULL;
 188         list = (vc_cmd_list_s*)vc_cmd_list;
 189
 190         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
 191
 192         if (NULL != list) {
 193                 free(list);
 194                 list = NULL;
 195         }
 196
 197         return VC_ERROR_NONE;
 198 }
 199
 200 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
 201 {
 202         if (0 != __vc_cmd_get_feature_enabled()) {
 203                 return VC_ERROR_NOT_SUPPORTED;
 204         }
 205         if (0 != __vc_cmd_check_privilege()) {
 206                 return VC_ERROR_PERMISSION_DENIED;
 207         }
 208
 209         if (NULL == vc_cmd_list || NULL == count) {
 210                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
 211                 return VC_ERROR_INVALID_PARAMETER;
 212         }
 213
 214         vc_cmd_list_s* list = NULL;
 215         list = (vc_cmd_list_s*)vc_cmd_list;
 216
 217         *count = g_slist_length(list->list);
 218
 219         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
 220
 221         return VC_ERROR_NONE;
 222 }
 223
 224 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 225 {
 226         if (0 != __vc_cmd_get_feature_enabled()) {
 227                 return VC_ERROR_NOT_SUPPORTED;
 228         }
 229         if (0 != __vc_cmd_check_privilege()) {
 230                 return VC_ERROR_PERMISSION_DENIED;
 231         }
 232
 233         if (NULL == vc_cmd_list || NULL == vc_command) {
 234                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 235                 return VC_ERROR_INVALID_PARAMETER;
 236         }
 237
 238         vc_cmd_list_s* list = NULL;
 239         list = (vc_cmd_list_s*)vc_cmd_list;
 240
 241         vc_cmd_s* cmd = NULL;
 242         cmd = (vc_cmd_s*)vc_command;
 243
 244         list->list = g_slist_append(list->list, cmd);
 245
 246         if (1 == g_slist_length(list->list)) {
 247                 list->index = 0;
 248         }
 249
 250         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 251
 252         return VC_ERROR_NONE;
 253 }
 254
 255 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 256 {
 257         if (0 != __vc_cmd_get_feature_enabled()) {
 258                 return VC_ERROR_NOT_SUPPORTED;
 259         }
 260         if (0 != __vc_cmd_check_privilege()) {
 261                 return VC_ERROR_PERMISSION_DENIED;
 262         }
 263
 264         if (NULL == vc_cmd_list || NULL == vc_command) {
 265                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 266                 return VC_ERROR_INVALID_PARAMETER;
 267         }
 268
 269         vc_cmd_list_s* list = NULL;
 270         list = (vc_cmd_list_s*)vc_cmd_list;
 271
 272         vc_cmd_s* cmd = NULL;
 273         cmd = (vc_cmd_s*)vc_command;
 274
 275         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 276
 277         vc_cmd_s* temp_cmd = NULL;
 278         GSList *iter = NULL;
 279
 280         iter = g_slist_nth(list->list, 0);
 281
 282         while (NULL != iter) {
 283                 temp_cmd = iter->data;
 284
 285                 if (NULL != temp_cmd && cmd == temp_cmd) {
 286                         list->list = g_slist_remove(list->list, temp_cmd);
 287                         /*
 288                         if (true == release_command) {
 289                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
 290                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 291                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 292                                 free(temp_cmd);
 293                                 temp_cmd = NULL;
 294                         }
 295                         */
 296                 }
 297
 298                 iter = g_slist_next(iter);
 299         }
 300
 301         int count = g_slist_length(list->list);
 302
 303         if (0 == count) {
 304                 list->index = -1;
 305         } else if (list->index == count) {
 306                 list->index = count - 1;
 307         }
 308
 309         return VC_ERROR_NONE;
 310 }
 311
 312 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
 313 {
 314         if (0 != __vc_cmd_get_feature_enabled()) {
 315                 return VC_ERROR_NOT_SUPPORTED;
 316         }
 317         if (0 != __vc_cmd_check_privilege()) {
 318                 return VC_ERROR_PERMISSION_DENIED;
 319         }
 320
 321         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Destroy all command");
 322
 323         if (NULL == vc_cmd_list) {
 324                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 325                 return VC_ERROR_INVALID_PARAMETER;
 326         }
 327
 328         vc_cmd_list_s* list = NULL;
 329         list = (vc_cmd_list_s*)vc_cmd_list;
 330
 331         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
 332                  , list, release_command ? "true" : "false");
 333
 334         int count = g_slist_length(list->list);
 335
 336         int i ;
 337         vc_cmd_s *temp_cmd;
 338
 339         for (i = 0; i < count ; i++) {
 340                 temp_cmd = g_slist_nth_data(list->list, 0);
 341
 342                 if (NULL != temp_cmd) {
 343                         list->list = g_slist_remove(list->list, temp_cmd);
 344
 345                         if (true == release_command) {
 346                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
 347                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 348                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 349                                 free(temp_cmd);
 350                                 temp_cmd = NULL;
 351                         }
 352                 }
 353         }
 354
 355         list->index = -1;
 356
 357         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 358         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 359
 360         return VC_ERROR_NONE;
 361 }
 362
 363 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
 364 {
 365         if (0 != __vc_cmd_get_feature_enabled()) {
 366                 return VC_ERROR_NOT_SUPPORTED;
 367         }
 368         if (0 != __vc_cmd_check_privilege()) {
 369                 return VC_ERROR_PERMISSION_DENIED;
 370         }
 371
 372         if (NULL == vc_cmd_list) {
 373                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 374                 return VC_ERROR_INVALID_PARAMETER;
 375         }
 376
 377         vc_cmd_list_s* list = NULL;
 378         list = (vc_cmd_list_s*)vc_cmd_list;
 379
 380         int count = g_slist_length(list->list);
 381         int i ;
 382
 383         GSList *iter = NULL;
 384         vc_cmd_s *temp_cmd;
 385
 386         iter = g_slist_nth(list->list, 0);
 387
 388         for (i = 0; i < count; i++) {
 389                 if (NULL == iter) {
 390                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
 391                         return VC_ERROR_OPERATION_FAILED;
 392                 }
 393
 394                 temp_cmd = iter->data;
 395
 396                 if (NULL != temp_cmd) {
 397                         if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
 398                                 break;
 399                         }
 400
 401                 }
 402                 iter = g_slist_next(iter);
 403         }
 404
 405         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Foreach commands Done");
 406
 407         return VC_ERROR_NONE;
 408 }
 409
 410 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
 411 {
 412         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Filter by type");
 413
 414         if (0 != __vc_cmd_get_feature_enabled()) {
 415                 return VC_ERROR_NOT_SUPPORTED;
 416         }
 417         if (0 != __vc_cmd_check_privilege()) {
 418                 return VC_ERROR_PERMISSION_DENIED;
 419         }
 420
 421         if (NULL == original) {
 422                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 423                 return VC_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
 427                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
 428                 return VC_ERROR_INVALID_PARAMETER;
 429         }
 430
 431         vc_cmd_list_s* list = NULL;
 432         list = (vc_cmd_list_s*)original;
 433
 434         vc_cmd_list_h temp_list;
 435         if (0 != vc_cmd_list_create(&temp_list)) {
 436                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
 437                 return VC_ERROR_OPERATION_FAILED;
 438         }
 439
 440         int count = g_slist_length(list->list);
 441         int i;
 442
 443         GSList *iter = NULL;
 444         vc_cmd_s *iter_cmd;
 445
 446         iter = g_slist_nth(list->list, 0);
 447
 448         for (i = 0; i < count; i++) {
 449                 if (NULL == iter) {
 450                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
 451                         return VC_ERROR_OPERATION_FAILED;
 452                 }
 453                 if (NULL != iter->data) {
 454                         iter_cmd = iter->data;
 455
 456                         if (NULL != iter_cmd) {
 457                                 int iter_type;
 458                                 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
 459                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
 460                                         continue;
 461                                 }
 462
 463                                 if (iter_type == type) {
 464                                         vc_cmd_h temp_cmd;
 465                                         if (0 != vc_cmd_create(&temp_cmd)) {
 466                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
 467                                                 continue;
 468                                         }
 469
 470                                         memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
 471                                         if (NULL != iter_cmd->command) {
 472                                                 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
 473                                         }
 474                                         if (NULL != iter_cmd->parameter) {
 475                                                 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
 476                                         }
 477
 478                                         if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
 479                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
 480                                                 vc_cmd_destroy(temp_cmd);
 481                                                 continue;
 482                                         }
 483                                 }
 484                         }
 485                 }
 486                 iter = g_slist_next(iter);
 487         }
 488
 489         count = 0;
 490         if (0 != vc_cmd_list_get_count(temp_list, &count)) {
 491                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
 492         } else {
 493                 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
 494         }
 495
 496         *filtered = temp_list;
 497
 498         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 499
 500         return VC_ERROR_NONE;
 501 }
 502
 503 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
 504 {
 505         if (0 != __vc_cmd_get_feature_enabled()) {
 506                 return VC_ERROR_NOT_SUPPORTED;
 507         }
 508         if (0 != __vc_cmd_check_privilege()) {
 509                 return VC_ERROR_PERMISSION_DENIED;
 510         }
 511
 512         if (NULL == vc_cmd_list) {
 513                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 514                 return VC_ERROR_INVALID_PARAMETER;
 515         }
 516
 517         vc_cmd_list_s* list = NULL;
 518         list = (vc_cmd_list_s*)vc_cmd_list;
 519
 520         if (0 == g_slist_length(list->list)) {
 521                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 522                 return VC_ERROR_EMPTY;
 523         }
 524
 525         list->index = 0;
 526
 527         return VC_ERROR_NONE;
 528 }
 529
 530 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
 531 {
 532         if (0 != __vc_cmd_get_feature_enabled()) {
 533                 return VC_ERROR_NOT_SUPPORTED;
 534         }
 535         if (0 != __vc_cmd_check_privilege()) {
 536                 return VC_ERROR_PERMISSION_DENIED;
 537         }
 538
 539         if (NULL == vc_cmd_list) {
 540                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 541                 return VC_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         vc_cmd_list_s* list = NULL;
 545         list = (vc_cmd_list_s*)vc_cmd_list;
 546
 547         int count = g_slist_length(list->list);
 548
 549         if (0 == count) {
 550                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 551                 return VC_ERROR_EMPTY;
 552         } else {
 553                 list->index = count - 1;
 554                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 555         }
 556
 557         return VC_ERROR_NONE;
 558 }
 559
 560 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
 561 {
 562         if (0 != __vc_cmd_get_feature_enabled()) {
 563                 return VC_ERROR_NOT_SUPPORTED;
 564         }
 565         if (0 != __vc_cmd_check_privilege()) {
 566                 return VC_ERROR_PERMISSION_DENIED;
 567         }
 568
 569         if (NULL == vc_cmd_list) {
 570                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 571                 return VC_ERROR_INVALID_PARAMETER;
 572         }
 573
 574         vc_cmd_list_s* list = NULL;
 575         list = (vc_cmd_list_s*)vc_cmd_list;
 576
 577         int count = g_slist_length(list->list);
 578
 579         if (list->index < count - 1) {
 580                 list->index = list->index + 1;
 581                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 582         } else {
 583                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 584                 return VC_ERROR_ITERATION_END;
 585         }
 586
 587         return VC_ERROR_NONE;
 588 }
 589
 590 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
 591 {
 592         if (0 != __vc_cmd_get_feature_enabled()) {
 593                 return VC_ERROR_NOT_SUPPORTED;
 594         }
 595         if (0 != __vc_cmd_check_privilege()) {
 596                 return VC_ERROR_PERMISSION_DENIED;
 597         }
 598
 599         if (NULL == vc_cmd_list) {
 600                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 601                 return VC_ERROR_INVALID_PARAMETER;
 602         }
 603
 604         vc_cmd_list_s* list = NULL;
 605         list = (vc_cmd_list_s*)vc_cmd_list;
 606
 607         if (list->index > 0) {
 608                 list->index = list->index - 1;
 609                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 610         } else {
 611                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 612                 return VC_ERROR_ITERATION_END;
 613         }
 614
 615         return VC_ERROR_NONE;
 616 }
 617
 618 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
 619 {
 620         if (0 != __vc_cmd_get_feature_enabled()) {
 621                 return VC_ERROR_NOT_SUPPORTED;
 622         }
 623         if (0 != __vc_cmd_check_privilege()) {
 624                 return VC_ERROR_PERMISSION_DENIED;
 625         }
 626
 627         if (NULL == vc_cmd_list || NULL == vc_command) {
 628                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 629                 return VC_ERROR_INVALID_PARAMETER;
 630         }
 631
 632         vc_cmd_list_s* list = NULL;
 633         list = (vc_cmd_list_s*)vc_cmd_list;
 634
 635         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
 636
 637         if (0 == g_slist_length(list->list)) {
 638                 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
 639                 *vc_command = NULL;
 640                 return VC_ERROR_EMPTY;
 641         }
 642
 643         vc_cmd_s *temp_cmd = NULL;
 644         temp_cmd = g_slist_nth_data(list->list, list->index);
 645
 646         *vc_command = (vc_cmd_h)temp_cmd;
 647
 648         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
 649
 650         return VC_ERROR_NONE;
 651 }
 652
 653
 654 int vc_cmd_create(vc_cmd_h* vc_command)
 655 {
 656         if (0 != __vc_cmd_get_feature_enabled()) {
 657                 return VC_ERROR_NOT_SUPPORTED;
 658         }
 659         if (0 != __vc_cmd_check_privilege()) {
 660                 return VC_ERROR_PERMISSION_DENIED;
 661         }
 662
 663         if (NULL == vc_command) {
 664                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 665                 return VC_ERROR_INVALID_PARAMETER;
 666         }
 667
 668         vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
 669
 670         if (NULL == command) {
 671                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 672                 return VC_ERROR_OUT_OF_MEMORY;
 673         }
 674
 675         command->pid = 0;
 676         command->id = 0;
 677         command->index = 0;
 678         command->type = VC_COMMAND_TYPE_NONE;
 679         command->format = VC_CMD_FORMAT_FIXED;
 680         command->command = NULL;
 681         command->parameter = NULL;
 682         command->domain = 0;
 683         command->priority = 0;
 684         command->key = VC_KEY_NONE;
 685         command->modifier = VC_MODIFIER_NONE;
 686
 687         *vc_command = (vc_cmd_h)command;
 688
 689         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 690
 691         return VC_ERROR_NONE;
 692 }
 693
 694 int vc_cmd_destroy(vc_cmd_h vc_command)
 695 {
 696         if (0 != __vc_cmd_get_feature_enabled()) {
 697                 return VC_ERROR_NOT_SUPPORTED;
 698         }
 699         if (0 != __vc_cmd_check_privilege()) {
 700                 return VC_ERROR_PERMISSION_DENIED;
 701         }
 702
 703         if (NULL == vc_command) {
 704                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 705                 return VC_ERROR_INVALID_PARAMETER;
 706         }
 707
 708         vc_cmd_s* command = NULL;
 709         command = (vc_cmd_s*)vc_command;
 710
 711         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 712
 713         if (NULL != command) {
 714                 if (NULL != command->command)   free(command->command);
 715                 if (NULL != command->parameter) free(command->parameter);
 716                 free(command);
 717                 command = NULL;
 718         }
 719
 720         return VC_ERROR_NONE;
 721 }
 722
 723 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 724 {
 725         if (0 != __vc_cmd_get_feature_enabled()) {
 726                 return VC_ERROR_NOT_SUPPORTED;
 727         }
 728         if (0 != __vc_cmd_check_privilege()) {
 729                 return VC_ERROR_PERMISSION_DENIED;
 730         }
 731
 732         if (NULL == vc_command) {
 733                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 734                 return VC_ERROR_INVALID_PARAMETER;
 735         }
 736
 737         vc_cmd_s* cmd = NULL;
 738         cmd = (vc_cmd_s*)vc_command;
 739
 740         if (NULL != cmd) {
 741                 cmd->id = id;
 742                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 743         }
 744
 745         return 0;
 746 }
 747
 748 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 749 {
 750         if (0 != __vc_cmd_get_feature_enabled()) {
 751                 return VC_ERROR_NOT_SUPPORTED;
 752         }
 753         if (0 != __vc_cmd_check_privilege()) {
 754                 return VC_ERROR_PERMISSION_DENIED;
 755         }
 756
 757         if (NULL == vc_command || NULL == id) {
 758                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 759                 return VC_ERROR_INVALID_PARAMETER;
 760         }
 761
 762         vc_cmd_s* cmd = NULL;
 763         cmd = (vc_cmd_s*)vc_command;
 764
 765         if (NULL != cmd) {
 766                 *id = cmd->id;
 767                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 768         }
 769
 770         return 0;
 771 }
 772
 773 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
 774 {
 775         if (0 != __vc_cmd_get_feature_enabled()) {
 776                 return VC_ERROR_NOT_SUPPORTED;
 777         }
 778
 779         if (NULL == vc_command) {
 780                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
 781                 return VC_ERROR_INVALID_PARAMETER;
 782         }
 783
 784         if (NULL == appid) {
 785                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
 786                 return VC_ERROR_INVALID_PARAMETER;
 787         }
 788
 789         vc_cmd_s* cmd = NULL;
 790         cmd = (vc_cmd_s*)vc_command;
 791
 792         if (NULL != cmd->appid) {
 793                 free(cmd->appid);
 794                 cmd->appid = NULL;
 795         }
 796
 797         cmd->appid = strdup(appid);
 798
 799         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
 800         return 0;
 801 }
 802
 803 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
 804 {
 805         if (0 != __vc_cmd_get_feature_enabled()) {
 806                 return VC_ERROR_NOT_SUPPORTED;
 807         }
 808
 809         if (NULL == vc_command || NULL == appid) {
 810                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 811                 return VC_ERROR_INVALID_PARAMETER;
 812         }
 813
 814         vc_cmd_s* cmd = NULL;
 815         cmd = (vc_cmd_s*)vc_command;
 816
 817         if (NULL != cmd->appid) {
 818                 *appid = strdup(gettext(cmd->appid));
 819         }
 820
 821         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
 822         return 0;
 823 }
 824
 825 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 826 {
 827         if (0 != __vc_cmd_get_feature_enabled()) {
 828                 return VC_ERROR_NOT_SUPPORTED;
 829         }
 830         if (0 != __vc_cmd_check_privilege()) {
 831                 return VC_ERROR_PERMISSION_DENIED;
 832         }
 833
 834         if (NULL == vc_command) {
 835                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 836                 return VC_ERROR_INVALID_PARAMETER;
 837         }
 838
 839         vc_cmd_s* cmd = NULL;
 840         cmd = (vc_cmd_s*)vc_command;
 841
 842         if (NULL != cmd->command) {
 843                 free(cmd->command);
 844         }
 845
 846         cmd->command = NULL;
 847
 848         if (NULL != command) {
 849                 cmd->command = strdup(command);
 850         }
 851
 852         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 853
 854         return 0;
 855 }
 856
 857 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 858 {
 859         if (0 != __vc_cmd_get_feature_enabled()) {
 860                 return VC_ERROR_NOT_SUPPORTED;
 861         }
 862         if (0 != __vc_cmd_check_privilege()) {
 863                 return VC_ERROR_PERMISSION_DENIED;
 864         }
 865
 866         if (NULL == vc_command || NULL == command) {
 867                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 868                 return VC_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         vc_cmd_s* cmd = NULL;
 872         cmd = (vc_cmd_s*)vc_command;
 873
 874         if (NULL != cmd->command) {
 875                 *command = strdup(gettext(cmd->command));
 876         }
 877
 878         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 879
 880         return 0;
 881 }
 882
 883 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 884 {
 885         if (0 != __vc_cmd_get_feature_enabled()) {
 886                 return VC_ERROR_NOT_SUPPORTED;
 887         }
 888         if (0 != __vc_cmd_check_privilege()) {
 889                 return VC_ERROR_PERMISSION_DENIED;
 890         }
 891
 892         if (NULL == vc_command) {
 893                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 894                 return VC_ERROR_INVALID_PARAMETER;
 895         }
 896
 897         vc_cmd_s* cmd = NULL;
 898         cmd = (vc_cmd_s*)vc_command;
 899
 900         if (NULL != cmd->parameter) {
 901                 free(cmd->parameter);
 902         }
 903
 904         cmd->parameter = NULL;
 905
 906         if (NULL != command) {
 907                 cmd->parameter = strdup(command);
 908                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
 909         }
 910
 911         return 0;
 912 }
 913
 914 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 915 {
 916         if (0 != __vc_cmd_get_feature_enabled()) {
 917                 return VC_ERROR_NOT_SUPPORTED;
 918         }
 919         if (0 != __vc_cmd_check_privilege()) {
 920                 return VC_ERROR_PERMISSION_DENIED;
 921         }
 922
 923         if (NULL == vc_command || NULL == command) {
 924                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 925                 return VC_ERROR_INVALID_PARAMETER;
 926         }
 927
 928         vc_cmd_s* cmd = NULL;
 929         cmd = (vc_cmd_s*)vc_command;
 930
 931         if (NULL != cmd->parameter) {
 932                 *command = strdup(gettext(cmd->parameter));
 933                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
 934         }
 935
 936         return 0;
 937 }
 938
 939 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
 940 {
 941         if (0 != __vc_cmd_get_feature_enabled()) {
 942                 return VC_ERROR_NOT_SUPPORTED;
 943         }
 944
 945         if (NULL == vc_command) {
 946                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 947                 return VC_ERROR_INVALID_PARAMETER;
 948         }
 949
 950         if (NULL == fixed) {
 951                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
 952                 return VC_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         vc_cmd_s* cmd = NULL;
 956         cmd = (vc_cmd_s*)vc_command;
 957
 958         if (NULL != cmd->fixed) {
 959                 free(cmd->fixed);
 960                 cmd->fixed = NULL;
 961         }
 962
 963         cmd->fixed = strdup(fixed);
 964
 965         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
 966         return 0;
 967 }
 968
 969 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
 970 {
 971         if (0 != __vc_cmd_get_feature_enabled()) {
 972                 return VC_ERROR_NOT_SUPPORTED;
 973         }
 974
 975         if (NULL == vc_command || NULL == fixed) {
 976                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 977                 return VC_ERROR_INVALID_PARAMETER;
 978         }
 979
 980         vc_cmd_s* cmd = NULL;
 981         cmd = (vc_cmd_s*)vc_command;
 982
 983         if (NULL != cmd->fixed) {
 984                 *fixed = strdup(gettext(cmd->fixed));
 985                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
 986         }
 987
 988         return 0;
 989 }
 990
 991 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
 992 {
 993         if (0 != __vc_cmd_get_feature_enabled()) {
 994                 return VC_ERROR_NOT_SUPPORTED;
 995         }
 996
 997         if (NULL == vc_command) {
 998                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
 999                 return VC_ERROR_INVALID_PARAMETER;
1000         }
1001
1002         if (NULL == invocation_name) {
1003                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1004                 return VC_ERROR_INVALID_PARAMETER;
1005         }
1006
1007         vc_cmd_s* cmd = NULL;
1008         cmd = (vc_cmd_s*)vc_command;
1009
1010         if (NULL != cmd->invocation_name) {
1011                 free(cmd->invocation_name);
1012                 cmd->invocation_name = NULL;
1013         }
1014
1015         cmd->invocation_name = strdup(invocation_name);
1016
1017         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1018         return 0;
1019 }
1020
1021 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1022 {
1023         if (0 != __vc_cmd_get_feature_enabled()) {
1024                 return VC_ERROR_NOT_SUPPORTED;
1025         }
1026
1027         if (NULL == vc_command || NULL == invocation_name) {
1028                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1029                 return VC_ERROR_INVALID_PARAMETER;
1030         }
1031
1032         vc_cmd_s* cmd = NULL;
1033         cmd = (vc_cmd_s*)vc_command;
1034
1035         if (NULL != cmd->invocation_name) {
1036                 *invocation_name = strdup(gettext(cmd->invocation_name));
1037         }
1038
1039         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1040         return 0;
1041 }
1042
1043 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1044 {
1045         if (0 != __vc_cmd_get_feature_enabled()) {
1046                 return VC_ERROR_NOT_SUPPORTED;
1047         }
1048         if (0 != __vc_cmd_check_privilege()) {
1049                 return VC_ERROR_PERMISSION_DENIED;
1050         }
1051
1052         if (NULL == vc_command) {
1053                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1054                 return VC_ERROR_INVALID_PARAMETER;
1055         }
1056
1057         vc_cmd_s* cmd = NULL;
1058         cmd = (vc_cmd_s*)vc_command;
1059
1060         cmd->type = type;
1061
1062         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1063
1064         return 0;
1065 }
1066
1067 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1068 {
1069         if (0 != __vc_cmd_get_feature_enabled()) {
1070                 return VC_ERROR_NOT_SUPPORTED;
1071         }
1072         if (0 != __vc_cmd_check_privilege()) {
1073                 return VC_ERROR_PERMISSION_DENIED;
1074         }
1075
1076         if (NULL == vc_command || NULL == type) {
1077                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1078                 return VC_ERROR_INVALID_PARAMETER;
1079         }
1080
1081         vc_cmd_s* cmd = NULL;
1082         cmd = (vc_cmd_s*)vc_command;
1083
1084         *type = cmd->type;
1085
1086         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1087
1088         return 0;
1089 }
1090
1091 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
1092 {
1093         if (0 != __vc_cmd_get_feature_enabled()) {
1094                 return VC_ERROR_NOT_SUPPORTED;
1095         }
1096         if (0 != __vc_cmd_check_privilege()) {
1097                 return VC_ERROR_PERMISSION_DENIED;
1098         }
1099
1100         if (NULL == vc_command) {
1101                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1102                 return VC_ERROR_INVALID_PARAMETER;
1103         }
1104
1105         vc_cmd_s* cmd = NULL;
1106         cmd = (vc_cmd_s*)vc_command;
1107
1108         cmd->format = format;
1109
1110         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1111
1112         return 0;
1113 }
1114
1115 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
1116 {
1117         if (0 != __vc_cmd_get_feature_enabled()) {
1118                 return VC_ERROR_NOT_SUPPORTED;
1119         }
1120         if (0 != __vc_cmd_check_privilege()) {
1121                 return VC_ERROR_PERMISSION_DENIED;
1122         }
1123
1124         if (NULL == vc_command || NULL == format) {
1125                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1126                 return VC_ERROR_INVALID_PARAMETER;
1127         }
1128
1129         vc_cmd_s* cmd = NULL;
1130         cmd = (vc_cmd_s*)vc_command;
1131
1132         *format = cmd->format;
1133
1134         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1135
1136         return 0;
1137 }
1138
1139 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1140 {
1141         if (0 != __vc_cmd_get_feature_enabled()) {
1142                 return VC_ERROR_NOT_SUPPORTED;
1143         }
1144         if (0 != __vc_cmd_check_privilege()) {
1145                 return VC_ERROR_PERMISSION_DENIED;
1146         }
1147
1148         if (NULL == vc_command) {
1149                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1150                 return VC_ERROR_INVALID_PARAMETER;
1151         }
1152
1153         vc_cmd_s* cmd = NULL;
1154         cmd = (vc_cmd_s*)vc_command;
1155
1156         cmd->pid = pid;
1157
1158         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1159
1160         return 0;
1161 }
1162
1163 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1164 {
1165         if (0 != __vc_cmd_get_feature_enabled()) {
1166                 return VC_ERROR_NOT_SUPPORTED;
1167         }
1168         if (0 != __vc_cmd_check_privilege()) {
1169                 return VC_ERROR_PERMISSION_DENIED;
1170         }
1171
1172         if (NULL == vc_command || NULL == pid) {
1173                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1174                 return VC_ERROR_INVALID_PARAMETER;
1175         }
1176
1177         vc_cmd_s* cmd = NULL;
1178         cmd = (vc_cmd_s*)vc_command;
1179
1180         *pid = cmd->pid;
1181
1182         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1183
1184         return 0;
1185 }
1186
1187 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1188 {
1189         if (0 != __vc_cmd_get_feature_enabled()) {
1190                 return VC_ERROR_NOT_SUPPORTED;
1191         }
1192         if (0 != __vc_cmd_check_privilege()) {
1193                 return VC_ERROR_PERMISSION_DENIED;
1194         }
1195
1196         if (NULL == vc_command) {
1197                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1198                 return VC_ERROR_INVALID_PARAMETER;
1199         }
1200
1201         vc_cmd_s* cmd = NULL;
1202         cmd = (vc_cmd_s*)vc_command;
1203
1204         cmd->domain = domain;
1205
1206         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1207
1208         return 0;
1209 }
1210
1211 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1212 {
1213         if (0 != __vc_cmd_get_feature_enabled()) {
1214                 return VC_ERROR_NOT_SUPPORTED;
1215         }
1216         if (0 != __vc_cmd_check_privilege()) {
1217                 return VC_ERROR_PERMISSION_DENIED;
1218         }
1219
1220         if (NULL == vc_command || NULL == domain) {
1221                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1222                 return VC_ERROR_INVALID_PARAMETER;
1223         }
1224
1225         vc_cmd_s* cmd = NULL;
1226         cmd = (vc_cmd_s*)vc_command;
1227
1228         *domain = cmd->domain;
1229
1230         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1231
1232         return 0;
1233 }
1234
1235 /**
1236 * @brief Sets key value of command.
1237 *
1238 * @param[in] vc_command Command handle
1239 * @param[in] key key value
1240 * @param[in] modifier modifier value
1241 *
1242 * @return 0 on success, otherwise a negative error value
1243 * @retval #VC_ERROR_NONE Successful
1244 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1245 *
1246 * @see vc_cmd_get_result_key()
1247 */
1248 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1249 {
1250         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
1251
1252         if (NULL == vc_command) {
1253                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1254                 return VC_ERROR_INVALID_PARAMETER;
1255         }
1256
1257         vc_cmd_s* cmd = NULL;
1258         cmd = (vc_cmd_s*)vc_command;
1259
1260         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1261
1262         cmd->key = key;
1263         cmd->modifier = modifier;
1264
1265         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1266         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1267
1268         return 0;
1269 }
1270
1271 /**
1272 * @brief Gets key value of command.
1273 *
1274 * @param[in] vc_command Command handle
1275 * @param[out] key key value
1276 * @param[out] modifier modifier value
1277 *
1278 * @return 0 on success, otherwise a negative error value
1279 * @retval #VC_ERROR_NONE Successful
1280 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1281 *
1282 * @see vc_cmd_add_result_key()
1283 */
1284 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1285 {
1286         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
1287
1288         if (NULL == vc_command || NULL == key || NULL == modifier) {
1289                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1290                 return VC_ERROR_INVALID_PARAMETER;
1291         }
1292
1293         vc_cmd_s* cmd = NULL;
1294         cmd = (vc_cmd_s*)vc_command;
1295
1296         *key = cmd->key;
1297         *modifier = cmd->modifier;
1298
1299         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1300         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1301
1302         return 0;
1303 }
1304
1305 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1306 {
1307         if (NULL == vc_cmd_list) {
1308                 return -1;
1309         }
1310
1311         vc_cmd_list_s* list = NULL;
1312         list = (vc_cmd_list_s*)vc_cmd_list;
1313
1314         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
1315         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1316
1317         int count = g_slist_length(list->list);
1318
1319         int i;
1320         vc_cmd_s *cmd = NULL;
1321
1322         for (i = 0; i < count ; i++) {
1323                 cmd = g_slist_nth_data(list->list, i);
1324
1325                 if (NULL != cmd) {
1326                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Command(%s) Param(%s) Appid(%s) Invocation(%s) Fixed(%s)",
1327                          i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1328                 }
1329         }
1330
1331         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1332         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1333
1334         return 0;
1335 }
1336
1337 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1338 {
1339         if (0 != __vc_cmd_get_feature_enabled()) {
1340                 return VC_ERROR_NOT_SUPPORTED;
1341         }
1342
1343         if (NULL == vc_cmd || NULL == json) {
1344                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NULL parameter");
1345                 return VC_ERROR_INVALID_PARAMETER;
1346         }
1347
1348         vc_cmd_s* cmd = NULL;
1349         cmd = (vc_cmd_s*)vc_cmd;
1350
1351         if (VC_CMD_FORMAT_ACTION != cmd->format) {
1352                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Action format");
1353                 return VC_ERROR_INVALID_PARAMETER;
1354         }
1355
1356         if (0 != vc_info_parser_get_nlu_result(json)) {
1357                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get nlu result");
1358                 return VC_ERROR_OPERATION_FAILED;
1359         }
1360
1361         return 0;
1362 }