* limitations under the License.
*/
-
+#include <cynara-client.h>
+#include <cynara-error.h>
+#include <cynara-session.h>
#include <libintl.h>
#include <stdlib.h>
+#include <system_info.h>
#include "vc_command.h"
#include "vc_main.h"
#include "voice_control_common.h"
#include "voice_control_key_defines.h"
+static int g_feature_enabled = -1;
+
+static int g_privilege_allowed = 1; /* Always True */
+static cynara *p_cynara = NULL;
+
+static int __vc_cmd_get_feature_enabled()
+{
+ if (0 == g_feature_enabled) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ } else if (-1 == g_feature_enabled) {
+ bool vc_supported = false;
+ bool mic_supported = false;
+ if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
+ if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
+ if (false == vc_supported || false == mic_supported) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
+ g_feature_enabled = 0;
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
+ g_feature_enabled = 1;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ } else {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ }
+
+ return 0;
+}
+
+static int __check_privilege_initialize()
+{
+ int ret = cynara_initialize(&p_cynara, NULL);
+ if (CYNARA_API_SUCCESS != ret)
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
+
+ return ret == CYNARA_API_SUCCESS;
+}
+
+static int __check_privilege(const char* uid, const char * privilege)
+{
+ FILE *fp = NULL;
+ char smack_label[1024] = "/proc/self/attr/current";
+
+ if (!p_cynara) {
+ return false;
+ }
+
+ fp = fopen(smack_label, "r");
+ if (fp != NULL) {
+ if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
+
+ fclose(fp);
+ }
+
+ pid_t pid = getpid();
+ char *session = cynara_session_from_pid(pid);
+ int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
+ SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
+ if (session)
+ free(session);
+
+ if (ret != CYNARA_API_ACCESS_ALLOWED)
+ return false;
+ return true;
+}
+
+static void __check_privilege_deinitialize()
+{
+ if (p_cynara)
+ cynara_finish(p_cynara);
+ p_cynara = NULL;
+}
+
+static int __vc_cmd_check_privilege()
+{
+ char uid[16];
+
+ if (0 == g_privilege_allowed) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
+ return VC_ERROR_PERMISSION_DENIED;
+ } else if (-1 == g_privilege_allowed) {
+ if (false == __check_privilege_initialize()){
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+ snprintf(uid, 16, "%d", getuid());
+ if (false == __check_privilege(uid, VC_PRIVILEGE)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
+ g_privilege_allowed = 0;
+ __check_privilege_deinitialize();
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+ __check_privilege_deinitialize();
+ }
+
+ g_privilege_allowed = 1;
+
+ return VC_ERROR_NONE;
+}
int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list || NULL == count) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list || NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list || NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
SLOG(LOG_DEBUG, TAG_VCCMD, "===== Destroy all command");
if (NULL == vc_cmd_list) {
list = (vc_cmd_list_s*)vc_cmd_list;
SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
- , list, release_command ? "true" : "false");
+ , list, release_command ? "true" : "false");
int count = g_slist_length(list->list);
int i ;
vc_cmd_s *temp_cmd;
- for (i = 0;i < count ;i++) {
+ for (i = 0; i < count ; i++) {
temp_cmd = g_slist_nth_data(list->list, 0);
if (NULL != temp_cmd) {
free(temp_cmd);
temp_cmd = NULL;
}
- }
+ }
}
list->index = -1;
int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
iter = g_slist_nth(list->list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
+ if (NULL == iter) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
temp_cmd = iter->data;
if (NULL != temp_cmd) {
break;
}
- }
+ }
iter = g_slist_next(iter);
}
return VC_ERROR_NONE;
}
+int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
+{
+ SLOG(LOG_DEBUG, TAG_VCCMD, "===== Filter by type");
+
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
+ if (NULL == original) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ vc_cmd_list_s* list = NULL;
+ list = (vc_cmd_list_s*)original;
+
+ vc_cmd_list_h temp_list;
+ if (0 != vc_cmd_list_create(&temp_list)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ int count = g_slist_length(list->list);
+ int i;
+
+ GSList *iter = NULL;
+ vc_cmd_s *iter_cmd;
+
+ iter = g_slist_nth(list->list, 0);
+
+ for (i = 0; i < count; i++) {
+ if (NULL == iter) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+ if (NULL != iter->data) {
+ iter_cmd = iter->data;
+
+ if (NULL != iter_cmd) {
+ int iter_type;
+ if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
+ SLOG(LOG_ERROR,TAG_VCCMD, "[ERROR] Fail to get command type");
+ continue;
+ }
+
+ if (iter_type == type) {
+ vc_cmd_h temp_cmd;
+ if (0 != vc_cmd_create(&temp_cmd)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
+ continue;
+ }
+
+ memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
+ if (NULL != iter_cmd->command) {
+ ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
+ }
+ if (NULL != iter_cmd->parameter) {
+ ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
+ }
+
+ if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
+ vc_cmd_destroy(temp_cmd);
+ continue;
+ }
+ }
+ }
+ }
+ iter = g_slist_next(iter);
+ }
+
+ count = 0;
+ if (0 != vc_cmd_list_get_count(temp_list, &count)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
+ }
+
+ *filtered = temp_list;
+
+ SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
+
+ return VC_ERROR_NONE;
+}
+
int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_cmd_list || NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_create(vc_cmd_h* vc_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_destroy(vc_cmd_h vc_command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_id(vc_cmd_h vc_command, int id)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
}
- return 0;
+ return 0;
}
int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == id) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_type(vc_cmd_h vc_command, int type)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == type) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == format) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == pid) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
{
+ if (0 != __vc_cmd_get_feature_enabled()) {
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+ if (0 != __vc_cmd_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
if (NULL == vc_command || NULL == domain) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
int i;
vc_cmd_s *temp_cmd = NULL;
- for (i = 0;i < count ;i++) {
+ for (i = 0; i < count ; i++) {
temp_cmd = g_slist_nth_data(list->list, i);
if (NULL != temp_cmd) {
- SLOG(LOG_DEBUG, TAG_VCCMD, " [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
- i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
- }
+ SLOG(LOG_DEBUG, TAG_VCCMD, " [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
+ i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
+ }
}
SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
projects / platform / core / uifw / voice-control.git / blobdiff