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