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_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
 306 {
 307         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Filter by type");
 308
 309         if (0 != __vc_cmd_get_feature_enabled()) {
 310                 return VC_ERROR_NOT_SUPPORTED;
 311         }
 312
 313         if (NULL == original) {
 314                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 315                 return VC_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
 319                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
 320                 return VC_ERROR_INVALID_PARAMETER;
 321         }
 322
 323         vc_cmd_list_s* list = NULL;
 324         list = (vc_cmd_list_s*)original;
 325
 326         vc_cmd_list_h temp_list;
 327         if (0 != vc_cmd_list_create(&temp_list)) {
 328                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
 329                 return VC_ERROR_OPERATION_FAILED;
 330         }
 331
 332         int count = g_slist_length(list->list);
 333         int i;
 334
 335         GSList *iter = NULL;
 336         vc_cmd_s *iter_cmd;
 337
 338         iter = g_slist_nth(list->list, 0);
 339
 340         for (i = 0; i < count; i++) {
 341                 if (NULL != iter->data) {
 342                         iter_cmd = iter->data;
 343
 344                         if (NULL != iter_cmd) {
 345                                 int iter_type;
 346                                 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
 347                                         SLOG(LOG_ERROR,TAG_VCCMD, "[ERROR] Fail to get command type");
 348                                         continue;
 349                                 }
 350
 351                                 if (iter_type == type) {
 352                                         vc_cmd_h temp_cmd;
 353                                         if (0 != vc_cmd_create(&temp_cmd)) {
 354                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
 355                                                 continue;
 356                                         }
 357
 358                                         memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
 359                                         if (NULL != iter_cmd->command) {
 360                                                 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
 361                                         }
 362                                         if (NULL != iter_cmd->parameter) {
 363                                                 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
 364                                         }
 365
 366                                         if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
 367                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
 368                                                 vc_cmd_destroy(temp_cmd);
 369                                                 continue;
 370                                         }
 371                                 }
 372                         }
 373                 }
 374                 iter = g_slist_next(iter);
 375         }
 376
 377         count = 0;
 378         if (0 != vc_cmd_list_get_count(temp_list, &count)) {
 379                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
 380         } else {
 381                 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
 382         }
 383
 384         *filtered = temp_list;
 385
 386         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 387
 388         return VC_ERROR_NONE;
 389 }
 390
 391 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
 392 {
 393         if (0 != __vc_cmd_get_feature_enabled()) {
 394                 return VC_ERROR_NOT_SUPPORTED;
 395         }
 396
 397         if (NULL == vc_cmd_list) {
 398                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 399                 return VC_ERROR_INVALID_PARAMETER;
 400         }
 401
 402         vc_cmd_list_s* list = NULL;
 403         list = (vc_cmd_list_s*)vc_cmd_list;
 404
 405         if (0 == g_slist_length(list->list)) {
 406                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 407                 return VC_ERROR_EMPTY;
 408         }
 409
 410         list->index = 0;
 411
 412         return VC_ERROR_NONE;
 413 }
 414
 415 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
 416 {
 417         if (0 != __vc_cmd_get_feature_enabled()) {
 418                 return VC_ERROR_NOT_SUPPORTED;
 419         }
 420
 421         if (NULL == vc_cmd_list) {
 422                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 423                 return VC_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         vc_cmd_list_s* list = NULL;
 427         list = (vc_cmd_list_s*)vc_cmd_list;
 428
 429         int count = g_slist_length(list->list);
 430
 431         if (0 == count) {
 432                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 433                 return VC_ERROR_EMPTY;
 434         } else {
 435                 list->index = count - 1;
 436                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 437         }
 438
 439         return VC_ERROR_NONE;
 440 }
 441
 442 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
 443 {
 444         if (0 != __vc_cmd_get_feature_enabled()) {
 445                 return VC_ERROR_NOT_SUPPORTED;
 446         }
 447
 448         if (NULL == vc_cmd_list) {
 449                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 450                 return VC_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         vc_cmd_list_s* list = NULL;
 454         list = (vc_cmd_list_s*)vc_cmd_list;
 455
 456         int count = g_slist_length(list->list);
 457
 458         if (list->index < count - 1) {
 459                 list->index = list->index + 1;
 460                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 461         } else {
 462                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 463                 return VC_ERROR_ITERATION_END;
 464         }
 465
 466         return VC_ERROR_NONE;
 467 }
 468
 469 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
 470 {
 471         if (0 != __vc_cmd_get_feature_enabled()) {
 472                 return VC_ERROR_NOT_SUPPORTED;
 473         }
 474
 475         if (NULL == vc_cmd_list) {
 476                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 477                 return VC_ERROR_INVALID_PARAMETER;
 478         }
 479
 480         vc_cmd_list_s* list = NULL;
 481         list = (vc_cmd_list_s*)vc_cmd_list;
 482
 483         if (list->index > 0) {
 484                 list->index = list->index - 1;
 485                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 486         } else {
 487                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 488                 return VC_ERROR_ITERATION_END;
 489         }
 490
 491         return VC_ERROR_NONE;
 492 }
 493
 494 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
 495 {
 496         if (0 != __vc_cmd_get_feature_enabled()) {
 497                 return VC_ERROR_NOT_SUPPORTED;
 498         }
 499
 500         if (NULL == vc_cmd_list || NULL == vc_command) {
 501                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 502                 return VC_ERROR_INVALID_PARAMETER;
 503         }
 504
 505         vc_cmd_list_s* list = NULL;
 506         list = (vc_cmd_list_s*)vc_cmd_list;
 507
 508         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
 509
 510         if (0 == g_slist_length(list->list)) {
 511                 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
 512                 *vc_command = NULL;
 513                 return VC_ERROR_EMPTY;
 514         }
 515
 516         vc_cmd_s *temp_cmd = NULL;
 517         temp_cmd = g_slist_nth_data(list->list, list->index);
 518
 519         *vc_command = (vc_cmd_h)temp_cmd;
 520
 521         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
 522
 523         return VC_ERROR_NONE;
 524 }
 525
 526
 527 int vc_cmd_create(vc_cmd_h* vc_command)
 528 {
 529         if (0 != __vc_cmd_get_feature_enabled()) {
 530                 return VC_ERROR_NOT_SUPPORTED;
 531         }
 532
 533         if (NULL == vc_command) {
 534                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 535                 return VC_ERROR_INVALID_PARAMETER;
 536         }
 537
 538         vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
 539
 540         if (NULL == command) {
 541                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 542                 return VC_ERROR_OUT_OF_MEMORY;
 543         }
 544
 545         command->pid = 0;
 546         command->id = 0;
 547         command->index = 0;
 548         command->type = VC_COMMAND_TYPE_NONE;
 549         command->format = VC_CMD_FORMAT_FIXED;
 550         command->command = NULL;
 551         command->parameter = NULL;
 552         command->domain = 0;
 553         command->key = VC_KEY_NONE;
 554         command->modifier = VC_MODIFIER_NONE;
 555
 556         *vc_command = (vc_cmd_h)command;
 557
 558         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 559
 560         return VC_ERROR_NONE;
 561 }
 562
 563 int vc_cmd_destroy(vc_cmd_h vc_command)
 564 {
 565         if (0 != __vc_cmd_get_feature_enabled()) {
 566                 return VC_ERROR_NOT_SUPPORTED;
 567         }
 568
 569         if (NULL == vc_command) {
 570                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 571                 return VC_ERROR_INVALID_PARAMETER;
 572         }
 573
 574         vc_cmd_s* command = NULL;
 575         command = (vc_cmd_s*)vc_command;
 576
 577         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 578
 579         if (NULL != command) {
 580                 if (NULL != command->command)   free(command->command);
 581                 if (NULL != command->parameter) free(command->parameter);
 582                 free(command);
 583                 command = NULL;
 584         }
 585
 586         return VC_ERROR_NONE;
 587 }
 588
 589 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 590 {
 591         if (0 != __vc_cmd_get_feature_enabled()) {
 592                 return VC_ERROR_NOT_SUPPORTED;
 593         }
 594
 595         if (NULL == vc_command) {
 596                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 597                 return VC_ERROR_INVALID_PARAMETER;
 598         }
 599
 600         vc_cmd_s* cmd = NULL;
 601         cmd = (vc_cmd_s*)vc_command;
 602
 603         if (NULL != cmd) {
 604                 cmd->id = id;
 605                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 606         }
 607
 608         return 0;
 609 }
 610
 611 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 612 {
 613         if (0 != __vc_cmd_get_feature_enabled()) {
 614                 return VC_ERROR_NOT_SUPPORTED;
 615         }
 616
 617         if (NULL == vc_command || NULL == id) {
 618                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 619                 return VC_ERROR_INVALID_PARAMETER;
 620         }
 621
 622         vc_cmd_s* cmd = NULL;
 623         cmd = (vc_cmd_s*)vc_command;
 624
 625         if (NULL != cmd) {
 626                 *id = cmd->id;
 627                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 628         }
 629
 630         return 0;
 631 }
 632
 633 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 634 {
 635         if (0 != __vc_cmd_get_feature_enabled()) {
 636                 return VC_ERROR_NOT_SUPPORTED;
 637         }
 638
 639         if (NULL == vc_command) {
 640                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 641                 return VC_ERROR_INVALID_PARAMETER;
 642         }
 643
 644         vc_cmd_s* cmd = NULL;
 645         cmd = (vc_cmd_s*)vc_command;
 646
 647         if (NULL != cmd->command) {
 648                 free(cmd->command);
 649         }
 650
 651         cmd->command = NULL;
 652
 653         if (NULL != command) {
 654                 cmd->command = strdup(command);
 655         }
 656
 657         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 658
 659         return 0;
 660 }
 661
 662 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 663 {
 664         if (0 != __vc_cmd_get_feature_enabled()) {
 665                 return VC_ERROR_NOT_SUPPORTED;
 666         }
 667
 668         if (NULL == vc_command || NULL == command) {
 669                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 670                 return VC_ERROR_INVALID_PARAMETER;
 671         }
 672
 673         vc_cmd_s* cmd = NULL;
 674         cmd = (vc_cmd_s*)vc_command;
 675
 676         if (NULL != cmd->command) {
 677                 *command = strdup(gettext(cmd->command));
 678         }
 679
 680         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 681
 682         return 0;
 683 }
 684
 685 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 686 {
 687         if (0 != __vc_cmd_get_feature_enabled()) {
 688                 return VC_ERROR_NOT_SUPPORTED;
 689         }
 690
 691         if (NULL == vc_command) {
 692                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 693                 return VC_ERROR_INVALID_PARAMETER;
 694         }
 695
 696         vc_cmd_s* cmd = NULL;
 697         cmd = (vc_cmd_s*)vc_command;
 698
 699         if (NULL != cmd->parameter) {
 700                 free(cmd->parameter);
 701         }
 702
 703         cmd->parameter = NULL;
 704
 705         if (NULL != command) {
 706                 cmd->parameter = strdup(command);
 707                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] parameter(%s)", vc_command, cmd->parameter);
 708         }
 709
 710         return 0;
 711 }
 712
 713 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 714 {
 715         if (0 != __vc_cmd_get_feature_enabled()) {
 716                 return VC_ERROR_NOT_SUPPORTED;
 717         }
 718
 719         if (NULL == vc_command || NULL == command) {
 720                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 721                 return VC_ERROR_INVALID_PARAMETER;
 722         }
 723
 724         vc_cmd_s* cmd = NULL;
 725         cmd = (vc_cmd_s*)vc_command;
 726
 727         if (NULL != cmd->parameter) {
 728                 *command = strdup(gettext(cmd->parameter));
 729                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get nonfixed command][%p] nonfixed command(%s)", vc_command, *command);
 730         }
 731
 732         return 0;
 733 }
 734
 735 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
 736 {
 737         if (0 != __vc_cmd_get_feature_enabled()) {
 738                 return VC_ERROR_NOT_SUPPORTED;
 739         }
 740
 741         if (NULL == vc_command) {
 742                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 743                 return VC_ERROR_INVALID_PARAMETER;
 744         }
 745
 746         vc_cmd_s* cmd = NULL;
 747         cmd = (vc_cmd_s*)vc_command;
 748
 749         cmd->type = type;
 750
 751         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
 752
 753         return 0;
 754 }
 755
 756 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
 757 {
 758         if (0 != __vc_cmd_get_feature_enabled()) {
 759                 return VC_ERROR_NOT_SUPPORTED;
 760         }
 761
 762         if (NULL == vc_command || NULL == type) {
 763                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 764                 return VC_ERROR_INVALID_PARAMETER;
 765         }
 766
 767         vc_cmd_s* cmd = NULL;
 768         cmd = (vc_cmd_s*)vc_command;
 769
 770         *type = cmd->type;
 771
 772         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
 773
 774         return 0;
 775 }
 776
 777 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
 778 {
 779         if (0 != __vc_cmd_get_feature_enabled()) {
 780                 return VC_ERROR_NOT_SUPPORTED;
 781         }
 782
 783         if (NULL == vc_command) {
 784                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 785                 return VC_ERROR_INVALID_PARAMETER;
 786         }
 787
 788         vc_cmd_s* cmd = NULL;
 789         cmd = (vc_cmd_s*)vc_command;
 790
 791         cmd->format = format;
 792
 793         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
 794
 795         return 0;
 796 }
 797
 798 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
 799 {
 800         if (0 != __vc_cmd_get_feature_enabled()) {
 801                 return VC_ERROR_NOT_SUPPORTED;
 802         }
 803
 804         if (NULL == vc_command || NULL == format) {
 805                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 806                 return VC_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         vc_cmd_s* cmd = NULL;
 810         cmd = (vc_cmd_s*)vc_command;
 811
 812         *format = cmd->format;
 813
 814         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
 815
 816         return 0;
 817 }
 818
 819 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
 820 {
 821         if (0 != __vc_cmd_get_feature_enabled()) {
 822                 return VC_ERROR_NOT_SUPPORTED;
 823         }
 824
 825         if (NULL == vc_command) {
 826                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 827                 return VC_ERROR_INVALID_PARAMETER;
 828         }
 829
 830         vc_cmd_s* cmd = NULL;
 831         cmd = (vc_cmd_s*)vc_command;
 832
 833         cmd->pid = pid;
 834
 835         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
 836
 837         return 0;
 838 }
 839
 840 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
 841 {
 842         if (0 != __vc_cmd_get_feature_enabled()) {
 843                 return VC_ERROR_NOT_SUPPORTED;
 844         }
 845
 846         if (NULL == vc_command || NULL == pid) {
 847                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 848                 return VC_ERROR_INVALID_PARAMETER;
 849         }
 850
 851         vc_cmd_s* cmd = NULL;
 852         cmd = (vc_cmd_s*)vc_command;
 853
 854         *pid = cmd->pid;
 855
 856         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
 857
 858         return 0;
 859 }
 860
 861 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
 862 {
 863         if (0 != __vc_cmd_get_feature_enabled()) {
 864                 return VC_ERROR_NOT_SUPPORTED;
 865         }
 866
 867         if (NULL == vc_command) {
 868                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 869                 return VC_ERROR_INVALID_PARAMETER;
 870         }
 871
 872         vc_cmd_s* cmd = NULL;
 873         cmd = (vc_cmd_s*)vc_command;
 874
 875         cmd->domain = domain;
 876
 877         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
 878
 879         return 0;
 880 }
 881
 882 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
 883 {
 884         if (0 != __vc_cmd_get_feature_enabled()) {
 885                 return VC_ERROR_NOT_SUPPORTED;
 886         }
 887
 888         if (NULL == vc_command || NULL == domain) {
 889                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 890                 return VC_ERROR_INVALID_PARAMETER;
 891         }
 892
 893         vc_cmd_s* cmd = NULL;
 894         cmd = (vc_cmd_s*)vc_command;
 895
 896         *domain = cmd->domain;
 897
 898         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
 899
 900         return 0;
 901 }
 902
 903 /**
 904 * @brief Sets key value of command.
 905 *
 906 * @param[in] vc_command Command handle
 907 * @param[in] key key value
 908 * @param[in] modifier modifier value
 909 *
 910 * @return 0 on success, otherwise a negative error value
 911 * @retval #VC_ERROR_NONE Successful
 912 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 913 *
 914 * @see vc_cmd_get_result_key()
 915 */
 916 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
 917 {
 918         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
 919
 920         if (NULL == vc_command) {
 921                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 922                 return VC_ERROR_INVALID_PARAMETER;
 923         }
 924
 925         vc_cmd_s* cmd = NULL;
 926         cmd = (vc_cmd_s*)vc_command;
 927
 928         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
 929
 930         cmd->key = key;
 931         cmd->modifier = modifier;
 932
 933         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 934         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 935
 936         return 0;
 937 }
 938
 939 /**
 940 * @brief Gets key value of command.
 941 *
 942 * @param[in] vc_command Command handle
 943 * @param[out] key key value
 944 * @param[out] modifier modifier value
 945 *
 946 * @return 0 on success, otherwise a negative error value
 947 * @retval #VC_ERROR_NONE Successful
 948 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 949 *
 950 * @see vc_cmd_add_result_key()
 951 */
 952 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
 953 {
 954         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
 955
 956         if (NULL == vc_command || NULL == key || NULL == modifier) {
 957                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 958                 return VC_ERROR_INVALID_PARAMETER;
 959         }
 960
 961         vc_cmd_s* cmd = NULL;
 962         cmd = (vc_cmd_s*)vc_command;
 963
 964         *key = cmd->key;
 965         *modifier = cmd->modifier;
 966
 967         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 968         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 969
 970         return 0;
 971 }
 972
 973 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
 974 {
 975         if (NULL == vc_cmd_list) {
 976                 return -1;
 977         }
 978
 979         vc_cmd_list_s* list = NULL;
 980         list = (vc_cmd_list_s*)vc_cmd_list;
 981
 982         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
 983         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
 984
 985         int count = g_slist_length(list->list);
 986
 987         int i;
 988         vc_cmd_s *temp_cmd = NULL;
 989
 990         for (i = 0; i < count ; i++) {
 991                 temp_cmd = g_slist_nth_data(list->list, i);
 992
 993                 if (NULL != temp_cmd) {
 994                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
 995                                  i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
 996                 }
 997         }
 998
 999         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1000         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1001
1002         return 0;
1003 }