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_main.h"
  26 #include "voice_control_command.h"
  27 #include "voice_control_command_expand.h"
  28 #include "voice_control_common.h"
  29 #include "voice_control_key_defines.h"
  30
  31 static int g_feature_enabled = -1;
  32
  33 static int g_privilege_allowed = -1;
  34 static cynara *p_cynara = NULL;
  35
  36 static int __vc_cmd_get_feature_enabled()
  37 {
  38         if (0 == g_feature_enabled) {
  39                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  40                 return VC_ERROR_NOT_SUPPORTED;
  41         } else if (-1 == g_feature_enabled) {
  42                 bool vc_supported = false;
  43                 bool mic_supported = false;
  44                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  45                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  46                                 if (false == vc_supported || false == mic_supported) {
  47                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  48                                         g_feature_enabled = 0;
  49                                         return VC_ERROR_NOT_SUPPORTED;
  50                                 }
  51
  52                                 g_feature_enabled = 1;
  53                         } else {
  54                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  55                                 return VC_ERROR_NOT_SUPPORTED;
  56                         }
  57                 } else {
  58                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  59                         return VC_ERROR_NOT_SUPPORTED;
  60                 }
  61         }
  62
  63         return 0;
  64 }
  65
  66 static int __check_privilege_initialize()
  67 {
  68         int ret = cynara_initialize(&p_cynara, NULL);
  69         if (CYNARA_API_SUCCESS != ret)
  70                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
  71
  72         return ret == CYNARA_API_SUCCESS;
  73 }
  74
  75 static int __check_privilege(const char* uid, const char * privilege)
  76 {
  77         FILE *fp = NULL;
  78         char smack_label[1024] = "/proc/self/attr/current";
  79
  80         if (!p_cynara) {
  81             return false;
  82         }
  83
  84         fp = fopen(smack_label, "r");
  85         if (fp != NULL) {
  86             if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
  87                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
  88
  89             fclose(fp);
  90         }
  91
  92         pid_t pid = getpid();
  93         char *session = cynara_session_from_pid(pid);
  94         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
  95         SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
  96         if (session)
  97             free(session);
  98
  99         if (ret != CYNARA_API_ACCESS_ALLOWED)
 100             return false;
 101         return true;
 102 }
 103
 104 static void __check_privilege_deinitialize()
 105 {
 106         if (p_cynara)
 107                 cynara_finish(p_cynara);
 108         p_cynara = NULL;
 109 }
 110
 111 static int __vc_cmd_check_privilege()
 112 {
 113 #if 0
 114         char uid[16];
 115         int ret = -1;
 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 #endif
 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->key = VC_KEY_NONE;
 684         command->modifier = VC_MODIFIER_NONE;
 685
 686         *vc_command = (vc_cmd_h)command;
 687
 688         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 689
 690         return VC_ERROR_NONE;
 691 }
 692
 693 int vc_cmd_destroy(vc_cmd_h vc_command)
 694 {
 695         if (0 != __vc_cmd_get_feature_enabled()) {
 696                 return VC_ERROR_NOT_SUPPORTED;
 697         }
 698         if (0 != __vc_cmd_check_privilege()) {
 699                 return VC_ERROR_PERMISSION_DENIED;
 700         }
 701
 702         if (NULL == vc_command) {
 703                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 704                 return VC_ERROR_INVALID_PARAMETER;
 705         }
 706
 707         vc_cmd_s* command = NULL;
 708         command = (vc_cmd_s*)vc_command;
 709
 710         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 711
 712         if (NULL != command) {
 713                 if (NULL != command->command)   free(command->command);
 714                 if (NULL != command->parameter) free(command->parameter);
 715                 free(command);
 716                 command = NULL;
 717         }
 718
 719         return VC_ERROR_NONE;
 720 }
 721
 722 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 723 {
 724         if (0 != __vc_cmd_get_feature_enabled()) {
 725                 return VC_ERROR_NOT_SUPPORTED;
 726         }
 727         if (0 != __vc_cmd_check_privilege()) {
 728                 return VC_ERROR_PERMISSION_DENIED;
 729         }
 730
 731         if (NULL == vc_command) {
 732                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 733                 return VC_ERROR_INVALID_PARAMETER;
 734         }
 735
 736         vc_cmd_s* cmd = NULL;
 737         cmd = (vc_cmd_s*)vc_command;
 738
 739         if (NULL != cmd) {
 740                 cmd->id = id;
 741                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 742         }
 743
 744         return 0;
 745 }
 746
 747 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 748 {
 749         if (0 != __vc_cmd_get_feature_enabled()) {
 750                 return VC_ERROR_NOT_SUPPORTED;
 751         }
 752         if (0 != __vc_cmd_check_privilege()) {
 753                 return VC_ERROR_PERMISSION_DENIED;
 754         }
 755
 756         if (NULL == vc_command || NULL == id) {
 757                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 758                 return VC_ERROR_INVALID_PARAMETER;
 759         }
 760
 761         vc_cmd_s* cmd = NULL;
 762         cmd = (vc_cmd_s*)vc_command;
 763
 764         if (NULL != cmd) {
 765                 *id = cmd->id;
 766                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 767         }
 768
 769         return 0;
 770 }
 771
 772 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 773 {
 774         if (0 != __vc_cmd_get_feature_enabled()) {
 775                 return VC_ERROR_NOT_SUPPORTED;
 776         }
 777         if (0 != __vc_cmd_check_privilege()) {
 778                 return VC_ERROR_PERMISSION_DENIED;
 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         if (NULL != cmd->command) {
 790                 free(cmd->command);
 791         }
 792
 793         cmd->command = NULL;
 794
 795         if (NULL != command) {
 796                 cmd->command = strdup(command);
 797         }
 798
 799         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 800
 801         return 0;
 802 }
 803
 804 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 805 {
 806         if (0 != __vc_cmd_get_feature_enabled()) {
 807                 return VC_ERROR_NOT_SUPPORTED;
 808         }
 809         if (0 != __vc_cmd_check_privilege()) {
 810                 return VC_ERROR_PERMISSION_DENIED;
 811         }
 812
 813         if (NULL == vc_command || NULL == command) {
 814                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 815                 return VC_ERROR_INVALID_PARAMETER;
 816         }
 817
 818         vc_cmd_s* cmd = NULL;
 819         cmd = (vc_cmd_s*)vc_command;
 820
 821         if (NULL != cmd->command) {
 822                 *command = strdup(gettext(cmd->command));
 823         }
 824
 825         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 826
 827         return 0;
 828 }
 829
 830 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 831 {
 832         if (0 != __vc_cmd_get_feature_enabled()) {
 833                 return VC_ERROR_NOT_SUPPORTED;
 834         }
 835         if (0 != __vc_cmd_check_privilege()) {
 836                 return VC_ERROR_PERMISSION_DENIED;
 837         }
 838
 839         if (NULL == vc_command) {
 840                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 841                 return VC_ERROR_INVALID_PARAMETER;
 842         }
 843
 844         vc_cmd_s* cmd = NULL;
 845         cmd = (vc_cmd_s*)vc_command;
 846
 847         if (NULL != cmd->parameter) {
 848                 free(cmd->parameter);
 849         }
 850
 851         cmd->parameter = NULL;
 852
 853         if (NULL != command) {
 854                 cmd->parameter = strdup(command);
 855                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] parameter(%s)", vc_command, cmd->parameter);
 856         }
 857
 858         return 0;
 859 }
 860
 861 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 862 {
 863         if (0 != __vc_cmd_get_feature_enabled()) {
 864                 return VC_ERROR_NOT_SUPPORTED;
 865         }
 866         if (0 != __vc_cmd_check_privilege()) {
 867                 return VC_ERROR_PERMISSION_DENIED;
 868         }
 869
 870         if (NULL == vc_command || NULL == command) {
 871                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 872                 return VC_ERROR_INVALID_PARAMETER;
 873         }
 874
 875         vc_cmd_s* cmd = NULL;
 876         cmd = (vc_cmd_s*)vc_command;
 877
 878         if (NULL != cmd->parameter) {
 879                 *command = strdup(gettext(cmd->parameter));
 880                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get nonfixed command][%p] nonfixed command(%s)", vc_command, *command);
 881         }
 882
 883         return 0;
 884 }
 885
 886 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
 887 {
 888         if (0 != __vc_cmd_get_feature_enabled()) {
 889                 return VC_ERROR_NOT_SUPPORTED;
 890         }
 891         if (0 != __vc_cmd_check_privilege()) {
 892                 return VC_ERROR_PERMISSION_DENIED;
 893         }
 894
 895         if (NULL == vc_command) {
 896                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 897                 return VC_ERROR_INVALID_PARAMETER;
 898         }
 899
 900         vc_cmd_s* cmd = NULL;
 901         cmd = (vc_cmd_s*)vc_command;
 902
 903         cmd->type = type;
 904
 905         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
 906
 907         return 0;
 908 }
 909
 910 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
 911 {
 912         if (0 != __vc_cmd_get_feature_enabled()) {
 913                 return VC_ERROR_NOT_SUPPORTED;
 914         }
 915         if (0 != __vc_cmd_check_privilege()) {
 916                 return VC_ERROR_PERMISSION_DENIED;
 917         }
 918
 919         if (NULL == vc_command || NULL == type) {
 920                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 921                 return VC_ERROR_INVALID_PARAMETER;
 922         }
 923
 924         vc_cmd_s* cmd = NULL;
 925         cmd = (vc_cmd_s*)vc_command;
 926
 927         *type = cmd->type;
 928
 929         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
 930
 931         return 0;
 932 }
 933
 934 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
 935 {
 936         if (0 != __vc_cmd_get_feature_enabled()) {
 937                 return VC_ERROR_NOT_SUPPORTED;
 938         }
 939         if (0 != __vc_cmd_check_privilege()) {
 940                 return VC_ERROR_PERMISSION_DENIED;
 941         }
 942
 943         if (NULL == vc_command) {
 944                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 945                 return VC_ERROR_INVALID_PARAMETER;
 946         }
 947
 948         vc_cmd_s* cmd = NULL;
 949         cmd = (vc_cmd_s*)vc_command;
 950
 951         cmd->format = format;
 952
 953         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
 954
 955         return 0;
 956 }
 957
 958 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
 959 {
 960         if (0 != __vc_cmd_get_feature_enabled()) {
 961                 return VC_ERROR_NOT_SUPPORTED;
 962         }
 963         if (0 != __vc_cmd_check_privilege()) {
 964                 return VC_ERROR_PERMISSION_DENIED;
 965         }
 966
 967         if (NULL == vc_command || NULL == format) {
 968                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 969                 return VC_ERROR_INVALID_PARAMETER;
 970         }
 971
 972         vc_cmd_s* cmd = NULL;
 973         cmd = (vc_cmd_s*)vc_command;
 974
 975         *format = cmd->format;
 976
 977         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
 978
 979         return 0;
 980 }
 981
 982 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
 983 {
 984         if (0 != __vc_cmd_get_feature_enabled()) {
 985                 return VC_ERROR_NOT_SUPPORTED;
 986         }
 987         if (0 != __vc_cmd_check_privilege()) {
 988                 return VC_ERROR_PERMISSION_DENIED;
 989         }
 990
 991         if (NULL == vc_command) {
 992                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 993                 return VC_ERROR_INVALID_PARAMETER;
 994         }
 995
 996         vc_cmd_s* cmd = NULL;
 997         cmd = (vc_cmd_s*)vc_command;
 998
 999         cmd->pid = pid;
1000
1001         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1002
1003         return 0;
1004 }
1005
1006 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1007 {
1008         if (0 != __vc_cmd_get_feature_enabled()) {
1009                 return VC_ERROR_NOT_SUPPORTED;
1010         }
1011         if (0 != __vc_cmd_check_privilege()) {
1012                 return VC_ERROR_PERMISSION_DENIED;
1013         }
1014
1015         if (NULL == vc_command || NULL == pid) {
1016                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1017                 return VC_ERROR_INVALID_PARAMETER;
1018         }
1019
1020         vc_cmd_s* cmd = NULL;
1021         cmd = (vc_cmd_s*)vc_command;
1022
1023         *pid = cmd->pid;
1024
1025         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1026
1027         return 0;
1028 }
1029
1030 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1031 {
1032         if (0 != __vc_cmd_get_feature_enabled()) {
1033                 return VC_ERROR_NOT_SUPPORTED;
1034         }
1035         if (0 != __vc_cmd_check_privilege()) {
1036                 return VC_ERROR_PERMISSION_DENIED;
1037         }
1038
1039         if (NULL == vc_command) {
1040                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1041                 return VC_ERROR_INVALID_PARAMETER;
1042         }
1043
1044         vc_cmd_s* cmd = NULL;
1045         cmd = (vc_cmd_s*)vc_command;
1046
1047         cmd->domain = domain;
1048
1049         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1050
1051         return 0;
1052 }
1053
1054 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1055 {
1056         if (0 != __vc_cmd_get_feature_enabled()) {
1057                 return VC_ERROR_NOT_SUPPORTED;
1058         }
1059         if (0 != __vc_cmd_check_privilege()) {
1060                 return VC_ERROR_PERMISSION_DENIED;
1061         }
1062
1063         if (NULL == vc_command || NULL == domain) {
1064                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1065                 return VC_ERROR_INVALID_PARAMETER;
1066         }
1067
1068         vc_cmd_s* cmd = NULL;
1069         cmd = (vc_cmd_s*)vc_command;
1070
1071         *domain = cmd->domain;
1072
1073         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1074
1075         return 0;
1076 }
1077
1078 /**
1079 * @brief Sets key value of command.
1080 *
1081 * @param[in] vc_command Command handle
1082 * @param[in] key key value
1083 * @param[in] modifier modifier value
1084 *
1085 * @return 0 on success, otherwise a negative error value
1086 * @retval #VC_ERROR_NONE Successful
1087 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1088 *
1089 * @see vc_cmd_get_result_key()
1090 */
1091 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1092 {
1093         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
1094
1095         if (NULL == vc_command) {
1096                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1097                 return VC_ERROR_INVALID_PARAMETER;
1098         }
1099
1100         vc_cmd_s* cmd = NULL;
1101         cmd = (vc_cmd_s*)vc_command;
1102
1103         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1104
1105         cmd->key = key;
1106         cmd->modifier = modifier;
1107
1108         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1109         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1110
1111         return 0;
1112 }
1113
1114 /**
1115 * @brief Gets key value of command.
1116 *
1117 * @param[in] vc_command Command handle
1118 * @param[out] key key value
1119 * @param[out] modifier modifier value
1120 *
1121 * @return 0 on success, otherwise a negative error value
1122 * @retval #VC_ERROR_NONE Successful
1123 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1124 *
1125 * @see vc_cmd_add_result_key()
1126 */
1127 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1128 {
1129         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
1130
1131         if (NULL == vc_command || NULL == key || NULL == modifier) {
1132                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1133                 return VC_ERROR_INVALID_PARAMETER;
1134         }
1135
1136         vc_cmd_s* cmd = NULL;
1137         cmd = (vc_cmd_s*)vc_command;
1138
1139         *key = cmd->key;
1140         *modifier = cmd->modifier;
1141
1142         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1143         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1144
1145         return 0;
1146 }
1147
1148 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1149 {
1150         if (NULL == vc_cmd_list) {
1151                 return -1;
1152         }
1153
1154         vc_cmd_list_s* list = NULL;
1155         list = (vc_cmd_list_s*)vc_cmd_list;
1156
1157         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
1158         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1159
1160         int count = g_slist_length(list->list);
1161
1162         int i;
1163         vc_cmd_s *temp_cmd = NULL;
1164
1165         for (i = 0; i < count ; i++) {
1166                 temp_cmd = g_slist_nth_data(list->list, i);
1167
1168                 if (NULL != temp_cmd) {
1169                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
1170                                  i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
1171                 }
1172         }
1173
1174         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1175         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1176
1177         return 0;
1178 }