Fix state bug

Change-Id: I103fa682ea3602b85a36fbbe814983e4970e197d

diff --git a/daemon/icd-payload.c b/daemon/icd-payload.c
index 3df9083..bdc2f06 100644 (file)
--- a/daemon/icd-payload.c
+++ b/daemon/icd-payload.c
@@ -41,6 +41,8 @@ struct icd_state_list_s {
 };
 
 static GVariant* _icd_payload_representation_to_gvariant(OCRepPayload *repr, gboolean is_parent);
+static void _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *iter);
+static GVariantBuilder* _icd_state_value_to_gvariant_builder(OCRepPayload *repr);
 
 GVariant** icd_payload_res_to_gvariant(OCPayload *payload, OCDevAddr *dev_addr)
 {
@@ -158,7 +160,8 @@ static GVariant* _icd_state_array_attr_to_gvariant(OCRepPayloadValueArray *arr,
                break;
        case OCREP_PROP_OBJECT:
                for (i = 0; i < len; i++) {
-                       var = _icd_payload_representation_to_gvariant(arr->objArray[index + i], TRUE);
+                       GVariantBuilder *state_var = _icd_state_value_to_gvariant_builder(arr->objArray[index + i]);
+                       var = g_variant_builder_end(state_var);
                        g_variant_builder_add(&builder, "v", var);
                }
                break;
@@ -197,8 +200,18 @@ static GVariant* _icd_state_array_to_gvariant(OCRepPayloadValueArray *arr,
        return g_variant_builder_end(&builder);
 }
 
+static GVariant* _icd_state_value_to_gvariant(OCRepPayload *state)
+{
+       GVariantBuilder *builder;
+       GVariant *var;
+
+       builder = _icd_state_value_to_gvariant_builder(state);
+       var = g_variant_builder_end(builder);
+
+       return var;
+}
 
-static GVariantBuilder* _icd_state_value_to_gvariant(OCRepPayload *repr)
+static GVariantBuilder* _icd_state_value_to_gvariant_builder(OCRepPayload *repr)
 {
        int total_len;
        GVariant *var = NULL;
@@ -229,7 +242,7 @@ static GVariantBuilder* _icd_state_value_to_gvariant(OCRepPayload *repr)
                        var = _icd_state_array_to_gvariant(&(val->arr), 0, total_len, 0);
                        break;
                case OCREP_PROP_OBJECT:
-                       var = _icd_payload_representation_to_gvariant(val->obj, TRUE);
+                       var = _icd_state_value_to_gvariant(val->obj);
                        break;
                default:
                        ERR("Invalid Type");
@@ -281,7 +294,7 @@ static GVariant* _icd_payload_representation_to_gvariant(OCRepPayload *repr,
        }
 
        /* Representation */
-       repr_gvar = _icd_state_value_to_gvariant(repr);
+       repr_gvar = _icd_state_value_to_gvariant_builder(repr);
 
        /* Children */
        g_variant_builder_init(&children, G_VARIANT_TYPE("av"));
@@ -441,15 +454,17 @@ static void _icd_state_list_from_gvariant(GVariant *var,
                        value_list->list = g_list_append(value_list->list, s);
        } else if (g_variant_type_equal(G_VARIANT_TYPE("av"), type)) {
                GVariant *value;
-
                if (g_variant_iter_loop(&iter, "v", &value)) {
-                       if (g_variant_is_of_type(value, G_VARIANT_TYPE("(siasa{sv}av)"))) {
-                               OCRepPayload *repr_value;
+                       if (g_variant_is_of_type(value, G_VARIANT_TYPE("a{sv}"))) {
+                               OCRepPayload *repr;
+                               GVariantIter state_iter;
                                value_list->type = OCREP_PROP_OBJECT;
                                do {
-                                       repr_value = icd_payload_representation_from_gvariant(value);
-                                       value_list->list = g_list_append(value_list->list, repr_value);
-
+                                       repr = OCRepPayloadCreate();
+                                       g_variant_iter_init(&state_iter, value);
+                                       _icd_state_value_from_gvariant(repr, &state_iter);
+                                       value_list->list = g_list_append(value_list->list, repr);
+                                       g_variant_iter_free(&state_iter);
                                } while (g_variant_iter_loop(&iter, "v", &value));
 
                        } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_ARRAY)) {
@@ -554,7 +569,6 @@ static void _icd_state_array_from_list(OCRepPayload *repr,
        }
 }
 
-
 static void _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *iter)
 {
        char *key;
@@ -595,7 +609,6 @@ static void _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *ite
        return;
 }
 
-
 OCRepPayload* icd_payload_representation_from_gvariant(GVariant *var)
 {
        GVariant *child;

diff --git a/lib/icl-payload.c b/lib/icl-payload.c
index 4e50ada..4ea51fb 100644 (file)
--- a/lib/icl-payload.c
+++ b/lib/icl-payload.c
@@ -232,7 +232,6 @@ void icl_state_from_gvariant(iotcon_state_h state, GVariantIter *iter)
        iotcon_state_h state_value = NULL;
 
        while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
-
                if (g_variant_is_of_type(var, G_VARIANT_TYPE_BOOLEAN)) {
                        value = icl_value_create_bool(g_variant_get_boolean(var));
 
@@ -248,17 +247,18 @@ void icl_state_from_gvariant(iotcon_state_h state, GVariantIter *iter)
                                value = icl_value_create_null();
                        else
                                value = icl_value_create_str(str_value);
-
+               } else if (g_variant_is_of_type(var, G_VARIANT_TYPE("a{sv}"))) {
+                       GVariantIter state_iter;
+                       iotcon_state_create(&state_value);
+                       g_variant_iter_init(&state_iter, var);
+                       icl_state_from_gvariant(state_value, &state_iter);
+                       value = icl_value_create_state(state_value);
                } else if (g_variant_is_of_type(var, G_VARIANT_TYPE_ARRAY)) {
                        list_value = _icl_state_list_from_gvariant(var);
                        value = icl_value_create_list(list_value);
-               } else if (g_variant_is_of_type(var, G_VARIANT_TYPE("a{sv}"))) {
-                       GVariantIter *state_iter;
-                       g_variant_get(var, "(&a{sv})", &state_iter);
-                       icl_state_from_gvariant(state_value, state_iter);
-                       value = icl_value_create_state(state_value);
+               } else {
+                       ERR("Invalid type(%s)", g_variant_get_type_string(var));
                }
-
                g_hash_table_replace(state->hash_table, ic_utils_strdup(key), value);
        }
 
@@ -317,22 +317,41 @@ static iotcon_list_h _icl_state_list_from_gvariant(GVariant *var)
 
                while (g_variant_iter_loop(&iter, "s", &s))
                        iotcon_list_add_str(list, s, -1);
-       } else if (g_variant_type_equal(G_VARIANT_TYPE("v"), type)) {
-               GVariant *value;
+       } else if (g_variant_type_equal(G_VARIANT_TYPE("av"), type)) {
+               GVariant *variant;
                iotcon_list_h list_value;
                iotcon_state_h state_value = NULL;
 
-               while (g_variant_iter_loop(&iter, "v", &value)) {
-                       if (g_variant_is_of_type(value, G_VARIANT_TYPE_ARRAY)) {
-                               list_value = _icl_state_list_from_gvariant(value);
-                               iotcon_list_add_list(list, list_value, -1);
-                       } else if (g_variant_is_of_type(value, G_VARIANT_TYPE("a{sv}"))) {
-                               GVariantIter *state_iter;
-                               g_variant_get(value, "(&a{sv})", &state_iter);
-                               icl_state_from_gvariant(state_value, state_iter);
+               while (g_variant_iter_loop(&iter, "v", &variant)) {
+                       if (g_variant_is_of_type(variant, G_VARIANT_TYPE("a{sv}"))) {
+                               GVariantIter state_iter;
+                               if (NULL == list) {
+                                       ret = iotcon_list_create(IOTCON_TYPE_STATE, &list);
+                                       if (IOTCON_ERROR_NONE != ret) {
+                                               ERR("iotcon_list_create() Fail(%d)", ret);
+                                               return NULL;
+                                       }
+                               }
+                               iotcon_state_create(&state_value);
+                               g_variant_iter_init(&state_iter, variant);
+                               icl_state_from_gvariant(state_value, &state_iter);
                                iotcon_list_add_state(list, state_value, -1);
+                       } else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_ARRAY)) {
+                               if (NULL == list) {
+                                       ret = iotcon_list_create(IOTCON_TYPE_LIST, &list);
+                                       if (IOTCON_ERROR_NONE != ret) {
+                                               ERR("iotcon_list_create() Fail(%d)", ret);
+                                               return NULL;
+                                       }
+                               }
+                               list_value = _icl_state_list_from_gvariant(variant);
+                               iotcon_list_add_list(list, list_value, -1);
+                       } else {
+                               ERR("Invalid type(%s)", g_variant_get_type_string(variant));
                        }
                }
+       } else {
+               ERR("Invalid type(%s)", g_variant_get_type_string(var));
        }
 
        return list;