From 454fe0cc1e6723208f9e92bf97486b488ab6c20f Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 17 Dec 2018 14:32:15 +0900 Subject: [PATCH 01/16] Update package version to 1.0.1 Change-Id: Ib45c228003d0e5bd0fdf1853ea981746d747c15c Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 9867d5b..cd82dbb 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From d4e5c02a6b9ed332944bf378eab4e8be3a1be9f5 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Fri, 21 Dec 2018 11:19:31 +0900 Subject: [PATCH 02/16] Fix crash temporarily Change-Id: I24b54f5d03f23f09e1260c687d0ef4312c86c89c Signed-off-by: Jihoon Kim --- src/autofill-daemon.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index 1ca0dd1..fbda668 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -350,8 +350,6 @@ static int __auth_info_request_cb(rpc_port_stub_AutofillAppPort_context_h contex free(view_id); } - rpc_port_autofill_svc_view_info_destroy(svi); - return 0; } -- 2.7.4 From 6a2d3dd80ce05b877618c424823a86759ba69025 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Fri, 21 Dec 2018 11:20:21 +0900 Subject: [PATCH 03/16] Update package version to 1.0.2 Change-Id: I9a61f611d95645b6f83d74059ea3362fef21047c Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index cd82dbb..82b91ce 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From 868d8409a0375647cac8e62a20355bff9e764a6c Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 09:57:18 +0900 Subject: [PATCH 04/16] Initialize variables before using Change-Id: I93334b2efbdaf81c470f84853b82a92f63711470 Signed-off-by: Jihoon Kim --- src/autofill-daemon.c | 84 +++++++++++++++++++++++++++++++-------------------- 1 file changed, 51 insertions(+), 33 deletions(-) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index fbda668..5967d6c 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -234,9 +234,12 @@ bool __view_info_item_cb(rpc_port_autofill_item_h items, void *user_data) rpc_port_autofill_svc_view_info_h svi = (rpc_port_autofill_svc_view_info_h)user_data; - rpc_port_autofill_svc_item_h svc_item; + rpc_port_autofill_svc_item_h svc_item = NULL; - rpc_port_autofill_svc_item_create(&svc_item); + if (rpc_port_autofill_svc_item_create(&svc_item) != 0) { + LOGW("Failed to create autofill item"); + return true; + } rpc_port_autofill_item_get_id(items, &id); rpc_port_autofill_svc_item_set_id(svc_item, id); @@ -262,7 +265,9 @@ bool __view_info_item_cb(rpc_port_autofill_item_h items, void *user_data) rpc_port_autofill_item_get_is_sensitive_data(items, &sensitive_data); rpc_port_autofill_svc_item_set_is_sensitive_data(svc_item, sensitive_data); - rpc_port_autofill_svc_view_info_add_items(svi, svc_item); + if (rpc_port_autofill_svc_view_info_add_items(svi, svc_item) != 0) { + LOGW("Failed to add item"); + } rpc_port_autofill_svc_item_destroy(svc_item); @@ -279,9 +284,10 @@ bool __save_item_cb(rpc_port_autofill_save_item_h items, void *user_data) rpc_port_autofill_svc_save_view_info_h svi = (rpc_port_autofill_svc_save_view_info_h)user_data; - rpc_port_autofill_svc_save_item_h svc_save_item; + rpc_port_autofill_svc_save_item_h svc_save_item = NULL; - rpc_port_autofill_svc_save_item_create(&svc_save_item); + if (rpc_port_autofill_svc_save_item_create(&svc_save_item) != 0) + return true; rpc_port_autofill_save_item_get_id(items, &id); rpc_port_autofill_svc_save_item_set_id(svc_save_item, id); @@ -317,7 +323,6 @@ bool __save_item_cb(rpc_port_autofill_save_item_h items, void *user_data) static int __auth_info_request_cb(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data) { char *sender = NULL; - autofill_client_s *sender_client; if (!svc_rpc_h) { LOGW("Not initialized"); @@ -330,11 +335,12 @@ static int __auth_info_request_cb(rpc_port_stub_AutofillAppPort_context_h contex rpc_port_autofill_view_info_get_view_id(vi, &view_id); LOGD("app id : %s, view id : %s", sender, view_id); - rpc_port_stub_AutofillAppPort_context_get_tag(context, (void *)&sender_client); - /* create view info */ - rpc_port_autofill_svc_view_info_h svi; - rpc_port_autofill_svc_view_info_create(&svi); + rpc_port_autofill_svc_view_info_h svi = NULL; + if (rpc_port_autofill_svc_view_info_create(&svi) != 0) { + goto end; + } + rpc_port_autofill_svc_view_info_set_app_id(svi, sender); rpc_port_autofill_svc_view_info_set_view_id(svi, view_id); @@ -342,6 +348,9 @@ static int __auth_info_request_cb(rpc_port_stub_AutofillAppPort_context_h contex rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(svc_rpc_h, context_id, svi); + rpc_port_autofill_svc_view_info_destroy(svi); + +end: if (sender) { free(sender); } @@ -368,8 +377,11 @@ static int __autofill_fill_request_cb(rpc_port_stub_AutofillAppPort_context_h co LOGD("app id : %s, view id : %s, context id : %d", sender, view_id, context_id); - rpc_port_autofill_svc_view_info_h svi; - rpc_port_autofill_svc_view_info_create(&svi); + rpc_port_autofill_svc_view_info_h svi = NULL; + if (rpc_port_autofill_svc_view_info_create(&svi) != 0) { + goto end; + } + rpc_port_autofill_svc_view_info_set_app_id(svi, sender); rpc_port_autofill_svc_view_info_set_view_id(svi, view_id); @@ -377,21 +389,22 @@ static int __autofill_fill_request_cb(rpc_port_stub_AutofillAppPort_context_h co rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(svc_rpc_h, context_id, svi); + rpc_port_autofill_svc_view_info_destroy(svi); + +end: if (sender) free(sender); if (view_id) free(view_id); - rpc_port_autofill_svc_view_info_destroy(svi); - return 0; } static int __commit_cb(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_save_view_info_h vi, void *user_data) { char *sender = NULL; - autofill_client_s *sender_client; + char *view_id = NULL; if (!svc_rpc_h) { LOGW("Not initialized"); @@ -404,17 +417,17 @@ static int __commit_cb(rpc_port_stub_AutofillAppPort_context_h context, int cont free(sender); } - char *view_id = NULL; + rpc_port_autofill_svc_save_view_info_h svi = NULL; + if (rpc_port_autofill_svc_save_view_info_create(&svi) != 0) { + return 0; + } + rpc_port_autofill_save_view_info_get_view_id(vi, &view_id); if (view_id) { LOGD("view id : %s", view_id); } - - rpc_port_autofill_svc_save_view_info_h svi; - rpc_port_autofill_svc_save_view_info_create(&svi); rpc_port_autofill_svc_save_view_info_set_view_id(svi, view_id); - rpc_port_stub_AutofillAppPort_context_get_tag(context, (void *)&sender_client); rpc_port_autofill_save_view_info_foreach_items(vi, __save_item_cb, svi); rpc_port_proxy_AutofillSvcPort_invoke_commit(svc_rpc_h, context_id, svi); @@ -435,9 +448,11 @@ bool fill_response_item_cb(rpc_port_autofill_svc_response_item_h response_items, char *presentation_text = NULL; char *value = NULL; - rpc_port_autofill_response_item_h res_item; + rpc_port_autofill_response_item_h res_item = NULL; - rpc_port_autofill_response_item_create(&res_item); + if (rpc_port_autofill_response_item_create(&res_item) != 0) { + return true; + } rpc_port_autofill_svc_response_item_get_id(response_items, &id); rpc_port_autofill_response_item_set_id(res_item, id); @@ -468,8 +483,9 @@ bool fill_response_group_cb(rpc_port_autofill_svc_response_group_h response_grou { rpc_port_autofill_fill_response_h fr_h = (rpc_port_autofill_fill_response_h)user_data; - rpc_port_autofill_response_group_h res_group; - rpc_port_autofill_response_group_create(&res_group); + rpc_port_autofill_response_group_h res_group = NULL; + if (rpc_port_autofill_response_group_create(&res_group) != 0) + return true; rpc_port_autofill_svc_response_group_foreach_response_items(response_groups, fill_response_item_cb, res_group); @@ -486,12 +502,14 @@ static void __fill_response_recv_cb(void *user_data, int context_id, rpc_port_au char *view_id = NULL; char *app_id = NULL; + /* create autofill response */ + rpc_port_autofill_fill_response_h fill_response_h = NULL; + if (rpc_port_autofill_fill_response_create(&fill_response_h) != 0) + return; + rpc_port_autofill_svc_fill_response_get_app_id(response_h, &app_id); rpc_port_autofill_svc_fill_response_get_view_id(response_h, &view_id); - /* create autofill response */ - rpc_port_autofill_fill_response_h fill_response_h; - rpc_port_autofill_fill_response_create(&fill_response_h); rpc_port_autofill_fill_response_set_view_id(fill_response_h, view_id); rpc_port_autofill_svc_fill_response_foreach_response_groups(response_h, fill_response_group_cb, fill_response_h); @@ -511,8 +529,8 @@ static void __fill_response_recv_cb(void *user_data, int context_id, rpc_port_au static void __auth_info_recv_cb(void *user_data, int context_id, rpc_port_autofill_svc_auth_info_h svc_auth_info_h) { - bool exist_autofill_data; - bool need_authentication; + bool exist_autofill_data = false; + bool need_authentication = false; char *service_name = NULL; char *service_logo_image_path = NULL; char *service_message = NULL; @@ -530,7 +548,7 @@ static void __auth_info_recv_cb(void *user_data, int context_id, rpc_port_autofi LOGD("app id : %s, service name : %s, message : %s, logo path : %s", app_id, service_name, service_message, service_logo_image_path); /* transfer auth info */ - rpc_port_autofill_auth_info_h auth_info_h; + rpc_port_autofill_auth_info_h auth_info_h = NULL; rpc_port_autofill_auth_info_create(&auth_info_h); rpc_port_autofill_auth_info_set_view_id(auth_info_h, view_id); rpc_port_autofill_auth_info_set_exist_autofill_data(auth_info_h, exist_autofill_data); @@ -617,7 +635,7 @@ static char * __manager_get_autofill_service_cb(rpc_port_stub_AutofillManagerPor return false; } - char *app_id; + char *app_id = NULL; autofill_config_get_autofill_service_app_id(&app_id); LOGD("app id : %s", app_id); @@ -667,7 +685,7 @@ static bool __manager_get_autofill_service_list_cb(rpc_port_stub_AutofillManager return false; } - rpc_port_list_string_h app_id_list_h; + rpc_port_list_string_h app_id_list_h = NULL; rpc_port_list_string_create(&app_id_list_h); ret = app_info_metadata_filter_foreach(handle, add_autofill_service_cb, app_id_list_h); @@ -685,7 +703,7 @@ static bool __manager_get_autofill_service_list_cb(rpc_port_stub_AutofillManager static int connect_service() { int ret; - size_t service_id_len; + size_t service_id_len = 0; rpc_port_proxy_AutofillSvcPort_callback_s rpc_callback = { .connected = __on_connected, -- 2.7.4 From 0da36fb70b86b354ae0110a932fbfff382968c40 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 10:04:19 +0900 Subject: [PATCH 05/16] Add debug message temporarily Change-Id: I36c63508b379d1ee172d0f1c03bc361ff4c13a4f Signed-off-by: Jihoon Kim --- src/autofill-daemon.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index 5967d6c..89e0095 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -241,20 +241,25 @@ bool __view_info_item_cb(rpc_port_autofill_item_h items, void *user_data) return true; } + LOGD("item : %p", svc_item); + rpc_port_autofill_item_get_id(items, &id); rpc_port_autofill_svc_item_set_id(svc_item, id); + LOGD("id : %s", id); if (id) { free(id); } rpc_port_autofill_item_get_label(items, &label); rpc_port_autofill_svc_item_set_label(svc_item, label); + LOGD("label : %s", label); if (label) { free(label); } rpc_port_autofill_item_get_value(items, &value); rpc_port_autofill_svc_item_set_value(svc_item, value); + LOGD("value : %s", value); if (value) { free(value); } -- 2.7.4 From da33fa6885639edbd78b76093b754af7f86771ec Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 11:01:16 +0900 Subject: [PATCH 06/16] Disable to use tidlc temporarily Change-Id: I2580241855a8b06b3cab4c94f186b5fb24c33d29 Signed-off-by: Jihoon Kim --- build_def.prop | 2 +- src/autofill_manager_stub.c | 681 +++++++ src/autofill_manager_stub.h | 70 + src/autofill_service_proxy.c | 4261 ++++++++++++++++++++++++++++++++++++++++++ src/autofill_service_proxy.h | 346 ++++ src/autofill_stub.c | 4148 ++++++++++++++++++++++++++++++++++++++++ src/autofill_stub.h | 327 ++++ 7 files changed, 9834 insertions(+), 1 deletion(-) create mode 100644 src/autofill_manager_stub.c create mode 100644 src/autofill_manager_stub.h create mode 100644 src/autofill_service_proxy.c create mode 100644 src/autofill_service_proxy.h create mode 100644 src/autofill_stub.c create mode 100644 src/autofill_stub.h diff --git a/build_def.prop b/build_def.prop index 520f46f..6bb5e2f 100644 --- a/build_def.prop +++ b/build_def.prop @@ -1,6 +1,6 @@ # Add pre/post build process PREBUILD_DESC = -PREBUILD_COMMAND = tidlc -s -l C -i tidl/autofill.tidl -o autofill_stub; mv autofill_stub.h ./src/; mv autofill_stub.c ./src/; tidlc -p -l C -i tidl/autofill_service.tidl -o autofill_service_proxy; mv autofill_service_proxy.h ./src/; mv autofill_service_proxy.c ./src/; tidlc -s -l C -i tidl/autofill_manager.tidl -o autofill_manager_stub; mv autofill_manager_stub.h ./src/; mv autofill_manager_stub.c ./src/; +PREBUILD_COMMAND = POSTBUILD_DESC = POSTBUILD_COMMAND = diff --git a/src/autofill_manager_stub.c b/src/autofill_manager_stub.c new file mode 100644 index 0000000..a662337 --- /dev/null +++ b/src/autofill_manager_stub.c @@ -0,0 +1,681 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "autofill_manager_stub.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "RPC_PORT_STUB" + +#ifdef _E +#undef _E +#endif + +#ifdef _W +#undef _W +#endif + +#ifdef _I +#undef _I +#endif + +#ifdef _D +#undef _D +#endif + +#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data); + +struct list_string_s { + rpc_port_parcelable_t parcelable; + GList *list_strings; +}; + +static void __list_string_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_string_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_strings)); + do { + GList *iter; + + iter = h->list_strings; + while (iter) { + char *value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write_string(parcel, value ? value : ""); + } + } while (0); +} + +static void __list_string_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_string_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + char *value = NULL; + + rpc_port_parcel_read_string(parcel, &value); + h->list_strings = g_list_append(h->list_strings, value); + } + } while (0); +} + +int rpc_port_list_string_create(rpc_port_list_string_h *h) +{ + struct list_string_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_string_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_string_to; + handle->parcelable.from = __list_string_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_string_destroy(rpc_port_list_string_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_strings; + while (iter) { + char *value = iter->data; + if (value) + free(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_strings); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_string_clone(rpc_port_list_string_h h, rpc_port_list_string_h *clone) +{ + rpc_port_list_string_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_string_create(&handle); + if (!handle) { + _E("Failed to create list_string handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_strings; + while (iter) { + char *new_value; + char *value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_string_destroy(handle); + return -1; + } + + new_value = strdup(value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_string_destroy(handle); + return -1; + } + + handle->list_strings = g_list_append(handle->list_strings, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_string_add_list_strings(rpc_port_list_string_h h, const char *list_strings) +{ + if (!h || !list_strings) { + _E("Invalid parameter"); + return -1; + } + + do { + char *value = NULL; + + value = strdup(list_strings); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_strings = g_list_append(h->list_strings, value); + } while (0); + + return 0; +} + +int rpc_port_list_string_foreach_list_strings(rpc_port_list_string_h h, + bool (*callback)(const char *list_strings, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_strings; + while (iter) { + char *value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_string_remove_list_strings(rpc_port_list_string_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_strings, nth); + if (iter == NULL) + return -1; + + char *value = iter->data; + h->list_strings = g_list_remove_link(h->list_strings, iter); + if (value) + free(value); + + g_list_free(iter); + + return 0; +} + +int rpc_port_list_string_get_list_strings_length(rpc_port_list_string_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_strings); + + return 0; +} + +enum AutofillManagerPort_method_e { + AutofillManagerPort_METHOD_Result, + AutofillManagerPort_METHOD_Callback, + AutofillManagerPort_METHOD_set_autofill_service, + AutofillManagerPort_METHOD_get_autofill_service, + AutofillManagerPort_METHOD_get_autofill_service_list, +}; + +static rpc_port_stub_h __AutofillManagerPort_stub; +static rpc_port_stub_AutofillManagerPort_callback_s __AutofillManagerPort_callback; +static void *__AutofillManagerPort_user_data; +static GList *__AutofillManagerPort_contexts; + +struct AutofillManagerPort_context_s { + char *sender; + char *instance; + rpc_port_h port; + void *tag; + rpc_port_stub_AutofillManagerPort_callback_s callback; + void *user_data; +}; + +static struct AutofillManagerPort_context_s *__create_AutofillManagerPort_context(const char *sender, const char *instance) +{ + struct AutofillManagerPort_context_s *handle; + + handle = calloc(1, sizeof(struct AutofillManagerPort_context_s)); + if (!handle) { + _E("Out of memory"); + return NULL; + } + + handle->sender = strdup(sender); + if (!handle->sender) { + _E("Out of memory"); + free(handle); + return NULL; + } + + handle->instance = strdup(instance); + if (!handle->instance) { + _E("Out of memory"); + free(handle->sender); + free(handle); + return NULL; + } + + handle->callback = __AutofillManagerPort_callback; + handle->user_data = __AutofillManagerPort_user_data; + + return handle; +} + +static void __destroy_AutofillManagerPort_context(gpointer data) +{ + struct AutofillManagerPort_context_s *handle = data; + + if (!handle) { + _E("Critical error!"); + return; + } + + free(handle->instance); + free(handle->sender); + free(handle); +} + +static struct AutofillManagerPort_context_s *__find_AutofillManagerPort_context(const char *instance) +{ + struct AutofillManagerPort_context_s *handle; + GList *iter; + + iter = __AutofillManagerPort_contexts; + while (iter) { + handle = (struct AutofillManagerPort_context_s *)iter->data; + if (!strcmp(handle->instance, instance)) + return handle; + iter = g_list_next(iter); + } + + return NULL; +} + +int rpc_port_stub_AutofillManagerPort_context_set_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void *tag) +{ + if (!ctx) { + _E("Invalid parameter"); + return -1; + } + + ctx->tag = tag; + + return 0; +} + +int rpc_port_stub_AutofillManagerPort_context_get_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void **tag) +{ + if (!ctx || !tag) { + _E("Invalid parameter"); + return -1; + } + + *tag = ctx->tag; + + return 0; +} + +int rpc_port_stub_AutofillManagerPort_context_get_sender(rpc_port_stub_AutofillManagerPort_context_h ctx, char **sender) +{ + if (!ctx || !sender) { + _E("Invalid parameter"); + return -1; + } + + *sender = strdup(ctx->sender); + if (*sender == NULL) { + _E("Out of memory"); + return -1; + } + + return 0; +} + +static int __AutofillManagerPort_method_set_autofill_service(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + char *app_id; + + rpc_port_parcel_read_string(parcel, &app_id); + + bool ret = context->callback.set_autofill_service(context, app_id, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); + rpc_port_parcel_write_bool(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + free(app_id); + return 0; +} + +static int __AutofillManagerPort_method_get_autofill_service(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + char *ret = context->callback.get_autofill_service(context, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); + rpc_port_parcel_write_string(result, ret ? ret : ""); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + free(ret); + return 0; +} + +static int __AutofillManagerPort_method_get_autofill_service_list(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + rpc_port_list_string_h service_info_list = NULL; + + bool ret = context->callback.get_autofill_service_list(context, &service_info_list, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); + rpc_port_parcel_write(result, &service_info_list->parcelable, service_info_list); + rpc_port_parcel_write_bool(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + rpc_port_list_string_destroy(service_info_list); + return 0; +} + +static stub_method __AutofillManagerPort_method_table[] = { + [AutofillManagerPort_METHOD_set_autofill_service] = __AutofillManagerPort_method_set_autofill_service, + [AutofillManagerPort_METHOD_get_autofill_service] = __AutofillManagerPort_method_get_autofill_service, + [AutofillManagerPort_METHOD_get_autofill_service_list] = __AutofillManagerPort_method_get_autofill_service_list, +}; + +static void __AutofillManagerPort_on_connected(const char *sender, const char *instance, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __create_AutofillManagerPort_context(sender, instance); + if (!context) + return; + + if (context->callback.create) + context->callback.create(context, context->user_data); + __AutofillManagerPort_contexts = g_list_append(__AutofillManagerPort_contexts, context); +} + +static void __AutofillManagerPort_on_disconnected(const char *sender, const char *instance, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __find_AutofillManagerPort_context(instance); + if (!context) + return; + + if (context->callback.terminate) + context->callback.terminate(context, context->user_data); + __AutofillManagerPort_contexts = g_list_remove(__AutofillManagerPort_contexts, context); + __destroy_AutofillManagerPort_context(context); +} + +static int __AutofillManagerPort_on_received(const char *sender, const char *instance, rpc_port_h port, void *data) +{ + rpc_port_stub_AutofillManagerPort_context_h context; + rpc_port_parcel_h parcel; + int cmd = -1; + int r; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __find_AutofillManagerPort_context(instance); + if (!context) { + _E("Failed to find AutofillManagerPort context(%s)", instance); + return -1; + } + + context->port = port; + r = rpc_port_parcel_create_from_port(&parcel, port); + if (r != 0) { + _E("Failed to create parcel from port"); + return r; + } + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd > 1 && cmd < (sizeof(__AutofillManagerPort_method_table) / sizeof(__AutofillManagerPort_method_table[0]))) { + if (__AutofillManagerPort_method_table[cmd]) + r = __AutofillManagerPort_method_table[cmd](port, parcel, context); + } else { + _E("Unknown Command(%d)", cmd); + r = -1; + } + + rpc_port_parcel_destroy(parcel); + + return r; +} + +static int __AutofillManagerPort_add_privileges(void) +{ + + return 0; +} + +int rpc_port_stub_AutofillManagerPort_register(rpc_port_stub_AutofillManagerPort_callback_s *callback, void *user_data) +{ + int r; + + if (__AutofillManagerPort_stub) { + _W("Already exists"); + return -1; + } + + if (!callback) { + _E("Invalid parameter"); + return -1; + } + + __AutofillManagerPort_callback = *callback; + __AutofillManagerPort_user_data = user_data; + r = rpc_port_stub_create(&__AutofillManagerPort_stub, "AutofillManagerPort"); + if (r != 0) { + _E("Failed to create stub handle"); + return r; + } + + r = rpc_port_stub_add_received_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_received, NULL); + if (r != 0) { + _E("Failed to add received event callback"); + rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + return r; + } + + r = rpc_port_stub_add_connected_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_connected, NULL); + if (r != 0) { + _E("Failed to add connected event callback"); + rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + return r; + } + + r = rpc_port_stub_add_disconnected_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_disconnected, NULL); + if (r != 0) { + _E("Failed to add disconnected event callback"); + rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + return r; + } + + r = __AutofillManagerPort_add_privileges(); + if (r != 0) { + _E("Failed to add privileges"); + rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + return r; + } + + r = rpc_port_stub_listen(__AutofillManagerPort_stub); + if (r != 0) { + _E("Failed to listen stub"); + rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + return r; + } + + return 0; +} + +int rpc_port_stub_AutofillManagerPort_unregister(void) +{ + int r; + + if (!__AutofillManagerPort_stub) + return -1; + + if (__AutofillManagerPort_contexts) { + g_list_free_full(__AutofillManagerPort_contexts, __destroy_AutofillManagerPort_context); + __AutofillManagerPort_contexts = NULL; + } + + r = rpc_port_stub_destroy(__AutofillManagerPort_stub); + __AutofillManagerPort_stub = NULL; + + return r; +} + +int rpc_port_stub_AutofillManagerPort_get_client_number(unsigned int *n) +{ + if (!n) { + _E("Invalid parameter"); + return -1; + } + + if (!__AutofillManagerPort_stub) { + _E("AutofillManagerPort Stub is not ready"); + return -1; + } + + *n = g_list_length(__AutofillManagerPort_contexts); + + return 0; +} diff --git a/src/autofill_manager_stub.h b/src/autofill_manager_stub.h new file mode 100644 index 0000000..458cb01 --- /dev/null +++ b/src/autofill_manager_stub.h @@ -0,0 +1,70 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct list_string_s *rpc_port_list_string_h; + +int rpc_port_list_string_create(rpc_port_list_string_h *h); + +int rpc_port_list_string_destroy(rpc_port_list_string_h h); + +int rpc_port_list_string_clone(rpc_port_list_string_h h, rpc_port_list_string_h *clone); + +int rpc_port_list_string_add_list_strings(rpc_port_list_string_h h, const char *list_strings); + +int rpc_port_list_string_foreach_list_strings(rpc_port_list_string_h h, + bool (*callback)(const char *list_strings, void *user_data), void *user_data); + +int rpc_port_list_string_remove_list_strings(rpc_port_list_string_h h, unsigned int nth); + +int rpc_port_list_string_get_list_strings_length(rpc_port_list_string_h h, unsigned int *length); + +typedef struct AutofillManagerPort_context_s* rpc_port_stub_AutofillManagerPort_context_h; + +int rpc_port_stub_AutofillManagerPort_context_set_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void *tag); + +int rpc_port_stub_AutofillManagerPort_context_get_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void **tag); + +int rpc_port_stub_AutofillManagerPort_context_get_sender(rpc_port_stub_AutofillManagerPort_context_h ctx, char **sender); + +typedef struct { + void (*create)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); + void (*terminate)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); + + bool (*set_autofill_service)(rpc_port_stub_AutofillManagerPort_context_h context, const char *app_id, void *user_data); + char *(*get_autofill_service)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); + bool (*get_autofill_service_list)(rpc_port_stub_AutofillManagerPort_context_h context, rpc_port_list_string_h *service_info_list, void *user_data); +} rpc_port_stub_AutofillManagerPort_callback_s; + +int rpc_port_stub_AutofillManagerPort_register(rpc_port_stub_AutofillManagerPort_callback_s *callback, void *user_data); + +int rpc_port_stub_AutofillManagerPort_unregister(void); + +int rpc_port_stub_AutofillManagerPort_get_client_number(unsigned int *n); + +#ifdef __cplusplus +} +#endif diff --git a/src/autofill_service_proxy.c b/src/autofill_service_proxy.c new file mode 100644 index 0000000..18e3bb5 --- /dev/null +++ b/src/autofill_service_proxy.c @@ -0,0 +1,4261 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "autofill_service_proxy.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "RPC_PORT_PROXY" + +#ifdef _E +#undef _E +#endif + +#ifdef _W +#undef _W +#endif + +#ifdef _I +#undef _I +#endif + +#ifdef _D +#undef _D +#endif + +#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +typedef void (*proxy_delegate)(GList **list, rpc_port_parcel_h parcel, int seq_id, int id); + +struct autofill_svc_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *label; + char *value; + int autofill_hint; + bool is_sensitive_data; +}; + +static void __autofill_svc_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); + rpc_port_parcel_write_int32(parcel, h->autofill_hint); + rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); +} + +static void __autofill_svc_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->label); + rpc_port_parcel_read_string(parcel, &h->value); + rpc_port_parcel_read_int32(parcel, &h->autofill_hint); + rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); +} + +int rpc_port_autofill_svc_item_create(rpc_port_autofill_svc_item_h *h) +{ + struct autofill_svc_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_item_to; + handle->parcelable.from = __autofill_svc_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_item_destroy(rpc_port_autofill_svc_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->label) + free(h->label); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_item_clone(rpc_port_autofill_svc_item_h h, rpc_port_autofill_svc_item_h *clone) +{ + rpc_port_autofill_svc_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_svc_item_destroy(handle); + return -1; + } + } + + if (h->label) { + handle->label = strdup(h->label); + if (!handle->label) { + _E("Failed to duplicate h->label"); + rpc_port_autofill_svc_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_svc_item_destroy(handle); + return -1; + } + } + + handle->autofill_hint = h->autofill_hint; + handle->is_sensitive_data = h->is_sensitive_data; + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_item_set_id(rpc_port_autofill_svc_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_set_label(rpc_port_autofill_svc_item_h h, const char *label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (h->label) { + free(h->label); + h->label = NULL; + } + + h->label = strdup(label); + if (!h->label) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_set_value(rpc_port_autofill_svc_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_set_autofill_hint(rpc_port_autofill_svc_item_h h, int autofill_hint) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->autofill_hint = autofill_hint; + return 0; +} + +int rpc_port_autofill_svc_item_set_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool is_sensitive_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->is_sensitive_data = is_sensitive_data; + return 0; +} + +int rpc_port_autofill_svc_item_get_id(rpc_port_autofill_svc_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_get_label(rpc_port_autofill_svc_item_h h, char **label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (!h->label) { + _E("Invalid parameter: h->label is NULL"); + return -1; + } + + *label = strdup(h->label); + if (*label == NULL) { + _E("Failed to duplicate label"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_get_value(rpc_port_autofill_svc_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_item_get_autofill_hint(rpc_port_autofill_svc_item_h h, int *autofill_hint) +{ + if (!h || !autofill_hint) { + _E("Invalid parameter"); + return -1; + } + + *autofill_hint = h->autofill_hint; + return 0; +} + +int rpc_port_autofill_svc_item_get_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool *is_sensitive_data) +{ + if (!h || !is_sensitive_data) { + _E("Invalid parameter"); + return -1; + } + + *is_sensitive_data = h->is_sensitive_data; + return 0; +} + +struct autofill_svc_view_info_s { + rpc_port_parcelable_t parcelable; + char *app_id; + char *view_id; + GList *items; +}; + +static void __autofill_svc_view_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_svc_view_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->app_id); + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_item_h value = NULL; + + rpc_port_autofill_svc_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->items = g_list_append(h->items, value); + } + } while (0); +} + +int rpc_port_autofill_svc_view_info_create(rpc_port_autofill_svc_view_info_h *h) +{ + struct autofill_svc_view_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_view_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_view_info_to; + handle->parcelable.from = __autofill_svc_view_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_view_info_destroy(rpc_port_autofill_svc_view_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) + free(h->app_id); + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_view_info_clone(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_view_info_h *clone) +{ + rpc_port_autofill_svc_view_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_view_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_view_info handle"); + return -1; + } + + if (h->app_id) { + handle->app_id = strdup(h->app_id); + if (!handle->app_id) { + _E("Failed to duplicate h->app_id"); + rpc_port_autofill_svc_view_info_destroy(handle); + return -1; + } + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_svc_view_info_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_item_h new_value; + rpc_port_autofill_svc_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_svc_view_info_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_svc_view_info_destroy(handle); + return -1; + } + + handle->items = g_list_append(handle->items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_view_info_set_app_id(rpc_port_autofill_svc_view_info_h h, const char *app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) { + free(h->app_id); + h->app_id = NULL; + } + + h->app_id = strdup(app_id); + if (!h->app_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_view_info_set_view_id(rpc_port_autofill_svc_view_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_view_info_add_items(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_item_h items) +{ + if (!h || !items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_item_h value = NULL; + + rpc_port_autofill_svc_item_clone(items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->items = g_list_append(h->items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_view_info_get_app_id(rpc_port_autofill_svc_view_info_h h, char **app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->app_id) { + _E("Invalid parameter: h->app_id is NULL"); + return -1; + } + + *app_id = strdup(h->app_id); + if (*app_id == NULL) { + _E("Failed to duplicate app_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_view_info_get_view_id(rpc_port_autofill_svc_view_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_view_info_foreach_items(rpc_port_autofill_svc_view_info_h h, + bool (*callback)(rpc_port_autofill_svc_item_h items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_view_info_remove_items(rpc_port_autofill_svc_view_info_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_item_h value = iter->data; + h->items = g_list_remove_link(h->items, iter); + rpc_port_autofill_svc_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_svc_view_info_get_items_length(rpc_port_autofill_svc_view_info_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->items); + + return 0; +} + +struct autofill_svc_save_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *label; + char *value; + int autofill_hint; + bool is_sensitive_data; +}; + +static void __autofill_svc_save_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); + rpc_port_parcel_write_int32(parcel, h->autofill_hint); + rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); +} + +static void __autofill_svc_save_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->label); + rpc_port_parcel_read_string(parcel, &h->value); + rpc_port_parcel_read_int32(parcel, &h->autofill_hint); + rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); +} + +int rpc_port_autofill_svc_save_item_create(rpc_port_autofill_svc_save_item_h *h) +{ + struct autofill_svc_save_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_save_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_save_item_to; + handle->parcelable.from = __autofill_svc_save_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_save_item_destroy(rpc_port_autofill_svc_save_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->label) + free(h->label); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_save_item_clone(rpc_port_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h *clone) +{ + rpc_port_autofill_svc_save_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_save_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_save_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_svc_save_item_destroy(handle); + return -1; + } + } + + if (h->label) { + handle->label = strdup(h->label); + if (!handle->label) { + _E("Failed to duplicate h->label"); + rpc_port_autofill_svc_save_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_svc_save_item_destroy(handle); + return -1; + } + } + + handle->autofill_hint = h->autofill_hint; + handle->is_sensitive_data = h->is_sensitive_data; + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_save_item_set_id(rpc_port_autofill_svc_save_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_set_label(rpc_port_autofill_svc_save_item_h h, const char *label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (h->label) { + free(h->label); + h->label = NULL; + } + + h->label = strdup(label); + if (!h->label) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_set_value(rpc_port_autofill_svc_save_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_set_autofill_hint(rpc_port_autofill_svc_save_item_h h, int autofill_hint) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->autofill_hint = autofill_hint; + return 0; +} + +int rpc_port_autofill_svc_save_item_set_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool is_sensitive_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->is_sensitive_data = is_sensitive_data; + return 0; +} + +int rpc_port_autofill_svc_save_item_get_id(rpc_port_autofill_svc_save_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_get_label(rpc_port_autofill_svc_save_item_h h, char **label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (!h->label) { + _E("Invalid parameter: h->label is NULL"); + return -1; + } + + *label = strdup(h->label); + if (*label == NULL) { + _E("Failed to duplicate label"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_get_value(rpc_port_autofill_svc_save_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_item_get_autofill_hint(rpc_port_autofill_svc_save_item_h h, int *autofill_hint) +{ + if (!h || !autofill_hint) { + _E("Invalid parameter"); + return -1; + } + + *autofill_hint = h->autofill_hint; + return 0; +} + +int rpc_port_autofill_svc_save_item_get_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool *is_sensitive_data) +{ + if (!h || !is_sensitive_data) { + _E("Invalid parameter"); + return -1; + } + + *is_sensitive_data = h->is_sensitive_data; + return 0; +} + +struct autofill_svc_save_view_info_s { + rpc_port_parcelable_t parcelable; + char *view_id; + GList *items; +}; + +static void __autofill_svc_save_view_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_save_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_svc_save_view_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_save_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_save_item_h value = NULL; + + rpc_port_autofill_svc_save_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->items = g_list_append(h->items, value); + } + } while (0); +} + +int rpc_port_autofill_svc_save_view_info_create(rpc_port_autofill_svc_save_view_info_h *h) +{ + struct autofill_svc_save_view_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_save_view_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_save_view_info_to; + handle->parcelable.from = __autofill_svc_save_view_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_destroy(rpc_port_autofill_svc_save_view_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_save_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_clone(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_view_info_h *clone) +{ + rpc_port_autofill_svc_save_view_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_save_view_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_save_view_info handle"); + return -1; + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_svc_save_view_info_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_save_item_h new_value; + rpc_port_autofill_svc_save_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_svc_save_view_info_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_save_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_svc_save_view_info_destroy(handle); + return -1; + } + + handle->items = g_list_append(handle->items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_set_view_id(rpc_port_autofill_svc_save_view_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_add_items(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_item_h items) +{ + if (!h || !items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_save_item_h value = NULL; + + rpc_port_autofill_svc_save_item_clone(items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->items = g_list_append(h->items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_get_view_id(rpc_port_autofill_svc_save_view_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_foreach_items(rpc_port_autofill_svc_save_view_info_h h, + bool (*callback)(rpc_port_autofill_svc_save_item_h items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_remove_items(rpc_port_autofill_svc_save_view_info_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_save_item_h value = iter->data; + h->items = g_list_remove_link(h->items, iter); + rpc_port_autofill_svc_save_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_svc_save_view_info_get_items_length(rpc_port_autofill_svc_save_view_info_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->items); + + return 0; +} + +struct autofill_svc_auth_info_s { + rpc_port_parcelable_t parcelable; + char *app_id; + char *view_id; + bool exist_autofill_data; + bool need_authentication; + char *service_name; + char *service_logo_image_path; + char *service_message; +}; + +static void __autofill_svc_auth_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_auth_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_bool(parcel, h->exist_autofill_data); + rpc_port_parcel_write_bool(parcel, h->need_authentication); + rpc_port_parcel_write_string(parcel, h->service_name ? h->service_name : ""); + rpc_port_parcel_write_string(parcel, h->service_logo_image_path ? h->service_logo_image_path : ""); + rpc_port_parcel_write_string(parcel, h->service_message ? h->service_message : ""); +} + +static void __autofill_svc_auth_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_auth_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->app_id); + rpc_port_parcel_read_string(parcel, &h->view_id); + rpc_port_parcel_read_bool(parcel, &h->exist_autofill_data); + rpc_port_parcel_read_bool(parcel, &h->need_authentication); + rpc_port_parcel_read_string(parcel, &h->service_name); + rpc_port_parcel_read_string(parcel, &h->service_logo_image_path); + rpc_port_parcel_read_string(parcel, &h->service_message); +} + +int rpc_port_autofill_svc_auth_info_create(rpc_port_autofill_svc_auth_info_h *h) +{ + struct autofill_svc_auth_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_auth_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_auth_info_to; + handle->parcelable.from = __autofill_svc_auth_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_auth_info_destroy(rpc_port_autofill_svc_auth_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) + free(h->app_id); + + if (h->view_id) + free(h->view_id); + + if (h->service_name) + free(h->service_name); + + if (h->service_logo_image_path) + free(h->service_logo_image_path); + + if (h->service_message) + free(h->service_message); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_auth_info_clone(rpc_port_autofill_svc_auth_info_h h, rpc_port_autofill_svc_auth_info_h *clone) +{ + rpc_port_autofill_svc_auth_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_auth_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_auth_info handle"); + return -1; + } + + if (h->app_id) { + handle->app_id = strdup(h->app_id); + if (!handle->app_id) { + _E("Failed to duplicate h->app_id"); + rpc_port_autofill_svc_auth_info_destroy(handle); + return -1; + } + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_svc_auth_info_destroy(handle); + return -1; + } + } + + handle->exist_autofill_data = h->exist_autofill_data; + handle->need_authentication = h->need_authentication; + if (h->service_name) { + handle->service_name = strdup(h->service_name); + if (!handle->service_name) { + _E("Failed to duplicate h->service_name"); + rpc_port_autofill_svc_auth_info_destroy(handle); + return -1; + } + } + + if (h->service_logo_image_path) { + handle->service_logo_image_path = strdup(h->service_logo_image_path); + if (!handle->service_logo_image_path) { + _E("Failed to duplicate h->service_logo_image_path"); + rpc_port_autofill_svc_auth_info_destroy(handle); + return -1; + } + } + + if (h->service_message) { + handle->service_message = strdup(h->service_message); + if (!handle->service_message) { + _E("Failed to duplicate h->service_message"); + rpc_port_autofill_svc_auth_info_destroy(handle); + return -1; + } + } + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_app_id(rpc_port_autofill_svc_auth_info_h h, const char *app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) { + free(h->app_id); + h->app_id = NULL; + } + + h->app_id = strdup(app_id); + if (!h->app_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_view_id(rpc_port_autofill_svc_auth_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool exist_autofill_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->exist_autofill_data = exist_autofill_data; + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool need_authentication) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->need_authentication = need_authentication; + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_service_name(rpc_port_autofill_svc_auth_info_h h, const char *service_name) +{ + if (!h || !service_name) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_name) { + free(h->service_name); + h->service_name = NULL; + } + + h->service_name = strdup(service_name); + if (!h->service_name) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, const char *service_logo_image_path) +{ + if (!h || !service_logo_image_path) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_logo_image_path) { + free(h->service_logo_image_path); + h->service_logo_image_path = NULL; + } + + h->service_logo_image_path = strdup(service_logo_image_path); + if (!h->service_logo_image_path) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_set_service_message(rpc_port_autofill_svc_auth_info_h h, const char *service_message) +{ + if (!h || !service_message) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_message) { + free(h->service_message); + h->service_message = NULL; + } + + h->service_message = strdup(service_message); + if (!h->service_message) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_app_id(rpc_port_autofill_svc_auth_info_h h, char **app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->app_id) { + _E("Invalid parameter: h->app_id is NULL"); + return -1; + } + + *app_id = strdup(h->app_id); + if (*app_id == NULL) { + _E("Failed to duplicate app_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_view_id(rpc_port_autofill_svc_auth_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool *exist_autofill_data) +{ + if (!h || !exist_autofill_data) { + _E("Invalid parameter"); + return -1; + } + + *exist_autofill_data = h->exist_autofill_data; + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool *need_authentication) +{ + if (!h || !need_authentication) { + _E("Invalid parameter"); + return -1; + } + + *need_authentication = h->need_authentication; + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_service_name(rpc_port_autofill_svc_auth_info_h h, char **service_name) +{ + if (!h || !service_name) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_name) { + _E("Invalid parameter: h->service_name is NULL"); + return -1; + } + + *service_name = strdup(h->service_name); + if (*service_name == NULL) { + _E("Failed to duplicate service_name"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, char **service_logo_image_path) +{ + if (!h || !service_logo_image_path) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_logo_image_path) { + _E("Invalid parameter: h->service_logo_image_path is NULL"); + return -1; + } + + *service_logo_image_path = strdup(h->service_logo_image_path); + if (*service_logo_image_path == NULL) { + _E("Failed to duplicate service_logo_image_path"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_auth_info_get_service_message(rpc_port_autofill_svc_auth_info_h h, char **service_message) +{ + if (!h || !service_message) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_message) { + _E("Invalid parameter: h->service_message is NULL"); + return -1; + } + + *service_message = strdup(h->service_message); + if (*service_message == NULL) { + _E("Failed to duplicate service_message"); + return -1; + } + + return 0; +} + +struct autofill_svc_response_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *presentation_text; + char *value; +}; + +static void __autofill_svc_response_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->presentation_text ? h->presentation_text : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); +} + +static void __autofill_svc_response_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->presentation_text); + rpc_port_parcel_read_string(parcel, &h->value); +} + +int rpc_port_autofill_svc_response_item_create(rpc_port_autofill_svc_response_item_h *h) +{ + struct autofill_svc_response_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_response_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_response_item_to; + handle->parcelable.from = __autofill_svc_response_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_response_item_destroy(rpc_port_autofill_svc_response_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->presentation_text) + free(h->presentation_text); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_response_item_clone(rpc_port_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h *clone) +{ + rpc_port_autofill_svc_response_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_response_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_response_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_svc_response_item_destroy(handle); + return -1; + } + } + + if (h->presentation_text) { + handle->presentation_text = strdup(h->presentation_text); + if (!handle->presentation_text) { + _E("Failed to duplicate h->presentation_text"); + rpc_port_autofill_svc_response_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_svc_response_item_destroy(handle); + return -1; + } + } + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_response_item_set_id(rpc_port_autofill_svc_response_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_response_item_set_presentation_text(rpc_port_autofill_svc_response_item_h h, const char *presentation_text) +{ + if (!h || !presentation_text) { + _E("Invalid parameter"); + return -1; + } + + if (h->presentation_text) { + free(h->presentation_text); + h->presentation_text = NULL; + } + + h->presentation_text = strdup(presentation_text); + if (!h->presentation_text) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_response_item_set_value(rpc_port_autofill_svc_response_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_response_item_get_id(rpc_port_autofill_svc_response_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_response_item_get_presentation_text(rpc_port_autofill_svc_response_item_h h, char **presentation_text) +{ + if (!h || !presentation_text) { + _E("Invalid parameter"); + return -1; + } + + if (!h->presentation_text) { + _E("Invalid parameter: h->presentation_text is NULL"); + return -1; + } + + *presentation_text = strdup(h->presentation_text); + if (*presentation_text == NULL) { + _E("Failed to duplicate presentation_text"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_response_item_get_value(rpc_port_autofill_svc_response_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +struct autofill_svc_response_group_s { + rpc_port_parcelable_t parcelable; + GList *response_items; +}; + +static void __autofill_svc_response_group_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_items)); + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_svc_response_group_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_response_item_h value = NULL; + + rpc_port_autofill_svc_response_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->response_items = g_list_append(h->response_items, value); + } + } while (0); +} + +int rpc_port_autofill_svc_response_group_create(rpc_port_autofill_svc_response_group_h *h) +{ + struct autofill_svc_response_group_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_response_group_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_response_group_to; + handle->parcelable.from = __autofill_svc_response_group_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_response_group_destroy(rpc_port_autofill_svc_response_group_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_response_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->response_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_response_group_clone(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h *clone) +{ + rpc_port_autofill_svc_response_group_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_response_group_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_response_group handle"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h new_value; + rpc_port_autofill_svc_response_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_svc_response_group_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_response_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_svc_response_group_destroy(handle); + return -1; + } + + handle->response_items = g_list_append(handle->response_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_response_group_add_response_items(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_item_h response_items) +{ + if (!h || !response_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_response_item_h value = NULL; + + rpc_port_autofill_svc_response_item_clone(response_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->response_items = g_list_append(h->response_items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_response_group_foreach_response_items(rpc_port_autofill_svc_response_group_h h, + bool (*callback)(rpc_port_autofill_svc_response_item_h response_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_response_group_remove_response_items(rpc_port_autofill_svc_response_group_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->response_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_response_item_h value = iter->data; + h->response_items = g_list_remove_link(h->response_items, iter); + rpc_port_autofill_svc_response_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_svc_response_group_get_response_items_length(rpc_port_autofill_svc_response_group_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->response_items); + + return 0; +} + +struct autofill_svc_fill_response_s { + rpc_port_parcelable_t parcelable; + char *app_id; + char *view_id; + GList *response_groups; +}; + +static void __autofill_svc_fill_response_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_fill_response_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_groups)); + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_svc_fill_response_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_svc_fill_response_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->app_id); + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_response_group_h value = NULL; + + rpc_port_autofill_svc_response_group_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->response_groups = g_list_append(h->response_groups, value); + } + } while (0); +} + +int rpc_port_autofill_svc_fill_response_create(rpc_port_autofill_svc_fill_response_h *h) +{ + struct autofill_svc_fill_response_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_svc_fill_response_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_svc_fill_response_to; + handle->parcelable.from = __autofill_svc_fill_response_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_svc_fill_response_destroy(rpc_port_autofill_svc_fill_response_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) + free(h->app_id); + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + if (value) + rpc_port_autofill_svc_response_group_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->response_groups); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_svc_fill_response_clone(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_fill_response_h *clone) +{ + rpc_port_autofill_svc_fill_response_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_svc_fill_response_create(&handle); + if (!handle) { + _E("Failed to create autofill_svc_fill_response handle"); + return -1; + } + + if (h->app_id) { + handle->app_id = strdup(h->app_id); + if (!handle->app_id) { + _E("Failed to duplicate h->app_id"); + rpc_port_autofill_svc_fill_response_destroy(handle); + return -1; + } + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_svc_fill_response_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h new_value; + rpc_port_autofill_svc_response_group_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_svc_fill_response_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_response_group_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_svc_fill_response_destroy(handle); + return -1; + } + + handle->response_groups = g_list_append(handle->response_groups, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_svc_fill_response_set_app_id(rpc_port_autofill_svc_fill_response_h h, const char *app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->app_id) { + free(h->app_id); + h->app_id = NULL; + } + + h->app_id = strdup(app_id); + if (!h->app_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_fill_response_set_view_id(rpc_port_autofill_svc_fill_response_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_fill_response_add_response_groups(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_response_group_h response_groups) +{ + if (!h || !response_groups) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_response_group_h value = NULL; + + rpc_port_autofill_svc_response_group_clone(response_groups, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->response_groups = g_list_append(h->response_groups, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_fill_response_get_app_id(rpc_port_autofill_svc_fill_response_h h, char **app_id) +{ + if (!h || !app_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->app_id) { + _E("Invalid parameter: h->app_id is NULL"); + return -1; + } + + *app_id = strdup(h->app_id); + if (*app_id == NULL) { + _E("Failed to duplicate app_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_fill_response_get_view_id(rpc_port_autofill_svc_fill_response_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_svc_fill_response_foreach_response_groups(rpc_port_autofill_svc_fill_response_h h, + bool (*callback)(rpc_port_autofill_svc_response_group_h response_groups, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_svc_fill_response_remove_response_groups(rpc_port_autofill_svc_fill_response_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->response_groups, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_response_group_h value = iter->data; + h->response_groups = g_list_remove_link(h->response_groups, iter); + rpc_port_autofill_svc_response_group_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_svc_fill_response_get_response_groups_length(rpc_port_autofill_svc_fill_response_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->response_groups); + + return 0; +} + +struct list_autofill_svc_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_svc_items; +}; + +static void __list_autofill_svc_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_items)); + do { + GList *iter; + + iter = h->list_autofill_svc_items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_svc_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_item_h value = NULL; + + rpc_port_autofill_svc_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_svc_items = g_list_append(h->list_autofill_svc_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_svc_item_create(rpc_port_list_autofill_svc_item_h *h) +{ + struct list_autofill_svc_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_svc_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_svc_item_to; + handle->parcelable.from = __list_autofill_svc_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_item_destroy(rpc_port_list_autofill_svc_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_svc_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_svc_item_clone(rpc_port_list_autofill_svc_item_h h, rpc_port_list_autofill_svc_item_h *clone) +{ + rpc_port_list_autofill_svc_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_svc_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_svc_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_items; + while (iter) { + rpc_port_autofill_svc_item_h new_value; + rpc_port_autofill_svc_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_svc_item_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_svc_item_destroy(handle); + return -1; + } + + handle->list_autofill_svc_items = g_list_append(handle->list_autofill_svc_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_item_add_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, rpc_port_autofill_svc_item_h list_autofill_svc_items) +{ + if (!h || !list_autofill_svc_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_item_h value = NULL; + + rpc_port_autofill_svc_item_clone(list_autofill_svc_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_svc_items = g_list_append(h->list_autofill_svc_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_item_foreach_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, + bool (*callback)(rpc_port_autofill_svc_item_h list_autofill_svc_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_items; + while (iter) { + rpc_port_autofill_svc_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_item_remove_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_svc_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_item_h value = iter->data; + h->list_autofill_svc_items = g_list_remove_link(h->list_autofill_svc_items, iter); + rpc_port_autofill_svc_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_svc_item_get_list_autofill_svc_items_length(rpc_port_list_autofill_svc_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_svc_items); + + return 0; +} + +struct list_autofill_svc_response_group_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_svc_response_groups; +}; + +static void __list_autofill_svc_response_group_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_response_groups)); + do { + GList *iter; + + iter = h->list_autofill_svc_response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_svc_response_group_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_response_group_h value = NULL; + + rpc_port_autofill_svc_response_group_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_svc_response_groups = g_list_append(h->list_autofill_svc_response_groups, value); + } + } while (0); +} + +int rpc_port_list_autofill_svc_response_group_create(rpc_port_list_autofill_svc_response_group_h *h) +{ + struct list_autofill_svc_response_group_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_svc_response_group_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_svc_response_group_to; + handle->parcelable.from = __list_autofill_svc_response_group_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_destroy(rpc_port_list_autofill_svc_response_group_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + if (value) + rpc_port_autofill_svc_response_group_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_svc_response_groups); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_clone(rpc_port_list_autofill_svc_response_group_h h, rpc_port_list_autofill_svc_response_group_h *clone) +{ + rpc_port_list_autofill_svc_response_group_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_svc_response_group_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_svc_response_group handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h new_value; + rpc_port_autofill_svc_response_group_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_svc_response_group_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_response_group_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_svc_response_group_destroy(handle); + return -1; + } + + handle->list_autofill_svc_response_groups = g_list_append(handle->list_autofill_svc_response_groups, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_add_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups) +{ + if (!h || !list_autofill_svc_response_groups) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_response_group_h value = NULL; + + rpc_port_autofill_svc_response_group_clone(list_autofill_svc_response_groups, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_svc_response_groups = g_list_append(h->list_autofill_svc_response_groups, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_foreach_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, + bool (*callback)(rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_groups; + while (iter) { + rpc_port_autofill_svc_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_remove_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_svc_response_groups, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_response_group_h value = iter->data; + h->list_autofill_svc_response_groups = g_list_remove_link(h->list_autofill_svc_response_groups, iter); + rpc_port_autofill_svc_response_group_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_svc_response_group_get_list_autofill_svc_response_groups_length(rpc_port_list_autofill_svc_response_group_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_svc_response_groups); + + return 0; +} + +struct list_autofill_svc_response_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_svc_response_items; +}; + +static void __list_autofill_svc_response_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_response_items)); + do { + GList *iter; + + iter = h->list_autofill_svc_response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_svc_response_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_response_item_h value = NULL; + + rpc_port_autofill_svc_response_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_svc_response_items = g_list_append(h->list_autofill_svc_response_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_svc_response_item_create(rpc_port_list_autofill_svc_response_item_h *h) +{ + struct list_autofill_svc_response_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_svc_response_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_svc_response_item_to; + handle->parcelable.from = __list_autofill_svc_response_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_destroy(rpc_port_list_autofill_svc_response_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_response_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_svc_response_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_clone(rpc_port_list_autofill_svc_response_item_h h, rpc_port_list_autofill_svc_response_item_h *clone) +{ + rpc_port_list_autofill_svc_response_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_svc_response_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_svc_response_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h new_value; + rpc_port_autofill_svc_response_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_svc_response_item_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_response_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_svc_response_item_destroy(handle); + return -1; + } + + handle->list_autofill_svc_response_items = g_list_append(handle->list_autofill_svc_response_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_add_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items) +{ + if (!h || !list_autofill_svc_response_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_response_item_h value = NULL; + + rpc_port_autofill_svc_response_item_clone(list_autofill_svc_response_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_svc_response_items = g_list_append(h->list_autofill_svc_response_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_foreach_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, + bool (*callback)(rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_response_items; + while (iter) { + rpc_port_autofill_svc_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_remove_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_svc_response_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_response_item_h value = iter->data; + h->list_autofill_svc_response_items = g_list_remove_link(h->list_autofill_svc_response_items, iter); + rpc_port_autofill_svc_response_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_svc_response_item_get_list_autofill_svc_response_items_length(rpc_port_list_autofill_svc_response_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_svc_response_items); + + return 0; +} + +struct list_autofill_svc_save_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_svc_save_items; +}; + +static void __list_autofill_svc_save_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_save_items)); + do { + GList *iter; + + iter = h->list_autofill_svc_save_items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_svc_save_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_svc_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_svc_save_item_h value = NULL; + + rpc_port_autofill_svc_save_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_svc_save_items = g_list_append(h->list_autofill_svc_save_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_svc_save_item_create(rpc_port_list_autofill_svc_save_item_h *h) +{ + struct list_autofill_svc_save_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_svc_save_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_svc_save_item_to; + handle->parcelable.from = __list_autofill_svc_save_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_destroy(rpc_port_list_autofill_svc_save_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_save_items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + if (value) + rpc_port_autofill_svc_save_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_svc_save_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_clone(rpc_port_list_autofill_svc_save_item_h h, rpc_port_list_autofill_svc_save_item_h *clone) +{ + rpc_port_list_autofill_svc_save_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_svc_save_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_svc_save_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_save_items; + while (iter) { + rpc_port_autofill_svc_save_item_h new_value; + rpc_port_autofill_svc_save_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_svc_save_item_destroy(handle); + return -1; + } + + rpc_port_autofill_svc_save_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_svc_save_item_destroy(handle); + return -1; + } + + handle->list_autofill_svc_save_items = g_list_append(handle->list_autofill_svc_save_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_add_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items) +{ + if (!h || !list_autofill_svc_save_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_svc_save_item_h value = NULL; + + rpc_port_autofill_svc_save_item_clone(list_autofill_svc_save_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_svc_save_items = g_list_append(h->list_autofill_svc_save_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_foreach_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, + bool (*callback)(rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_svc_save_items; + while (iter) { + rpc_port_autofill_svc_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_remove_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_svc_save_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_svc_save_item_h value = iter->data; + h->list_autofill_svc_save_items = g_list_remove_link(h->list_autofill_svc_save_items, iter); + rpc_port_autofill_svc_save_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_svc_save_item_get_list_autofill_svc_save_items_length(rpc_port_list_autofill_svc_save_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_svc_save_items); + + return 0; +} + +enum AutofillSvcPort_method_e { + AutofillSvcPort_METHOD_Result, + AutofillSvcPort_METHOD_Callback, + AutofillSvcPort_METHOD_Register, + AutofillSvcPort_METHOD_Unregister, + AutofillSvcPort_METHOD_request_auth_info, + AutofillSvcPort_METHOD_send_fill_request, + AutofillSvcPort_METHOD_commit, + AutofillSvcPort_METHOD_request_terminate, +}; + +enum AutofillSvcPort_delegate_e { + AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb = 1, + AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb = 2, +}; + +struct AutofillSvcPort_s { + char *stub_appid; + rpc_port_proxy_h proxy; + rpc_port_h port; + rpc_port_h callback_port; + rpc_port_proxy_AutofillSvcPort_callback_s callback; + void *user_data; + GList *delegates; + GRecMutex mutex; +}; + +struct AutofillSvcPort_autofill_svc_auth_info_cb_s { + rpc_port_parcelable_t parcelable; + int id; + int seq_id; + AutofillSvcPort_autofill_svc_auth_info_cb callback; + bool once; + void *user_data; +}; + +static void __AutofillSvcPort_autofill_svc_auth_info_cb_to(rpc_port_parcel_h parcel, void *data) +{ + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, handle->id); + rpc_port_parcel_write_int32(parcel, handle->seq_id); + rpc_port_parcel_write_bool(parcel, handle->once); +} + +static void __AutofillSvcPort_autofill_svc_auth_info_cb_from(rpc_port_parcel_h parcel, void *data) +{ + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_int32(parcel, &handle->id); + rpc_port_parcel_read_int32(parcel, &handle->seq_id); + rpc_port_parcel_read_bool(parcel, &handle->once); +} + +rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_create(AutofillSvcPort_autofill_svc_auth_info_cb callback, bool once, void *user_data) +{ + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; + static int seq_num; + + handle = calloc(1, sizeof(struct AutofillSvcPort_autofill_svc_auth_info_cb_s)); + if (!handle) { + _E("Out of memory"); + return NULL; + } + + handle->parcelable.to = __AutofillSvcPort_autofill_svc_auth_info_cb_to; + handle->parcelable.from= __AutofillSvcPort_autofill_svc_auth_info_cb_from; + handle->id = AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->callback = callback; + handle->once = once; + handle->user_data = user_data; + + return handle; +} + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate) +{ + if (!delegate) { + _E("Invalid parameter"); + return -1; + } + + free(delegate); + + return 0; +} + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate) +{ + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; + GList *iter; + + if (!proxy || !delegate) { + _E("Invalid handle %p %p", proxy, delegate); + return -1; + } + + iter = proxy->delegates; + while (iter) { + handle = (struct AutofillSvcPort_autofill_svc_auth_info_cb_s *)iter->data; + if (handle == delegate) { + proxy->delegates = g_list_remove_link(proxy->delegates, iter); + free(handle); + g_list_free(iter); + return 0; + } + iter = g_list_next(iter); + } + + return -1; +} + +static void __AutofillSvcPort_delegate_autofill_svc_auth_info_cb(GList **list, rpc_port_parcel_h parcel, int seq_id, int id) +{ + int context_id; + rpc_port_autofill_svc_auth_info_h auth_info; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_autofill_svc_auth_info_create(&auth_info); + rpc_port_parcel_read(parcel, &auth_info->parcelable, auth_info); + + do { + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; + GList *iter; + + iter = *list; + while (iter) { + handle = (struct AutofillSvcPort_autofill_svc_auth_info_cb_s *)iter->data; + if (handle->seq_id == seq_id && handle->id == id) { + handle->callback(handle->user_data, context_id, auth_info); + + if (handle->once) { + *list = g_list_remove_link(*list, iter); + free(handle); + g_list_free(iter); + } + break; + } + iter = g_list_next(iter); + } + } while (0); + + rpc_port_autofill_svc_auth_info_destroy(auth_info); +} + +struct AutofillSvcPort_autofill_svc_fill_response_cb_s { + rpc_port_parcelable_t parcelable; + int id; + int seq_id; + AutofillSvcPort_autofill_svc_fill_response_cb callback; + bool once; + void *user_data; +}; + +static void __AutofillSvcPort_autofill_svc_fill_response_cb_to(rpc_port_parcel_h parcel, void *data) +{ + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, handle->id); + rpc_port_parcel_write_int32(parcel, handle->seq_id); + rpc_port_parcel_write_bool(parcel, handle->once); +} + +static void __AutofillSvcPort_autofill_svc_fill_response_cb_from(rpc_port_parcel_h parcel, void *data) +{ + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_int32(parcel, &handle->id); + rpc_port_parcel_read_int32(parcel, &handle->seq_id); + rpc_port_parcel_read_bool(parcel, &handle->once); +} + +rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_create(AutofillSvcPort_autofill_svc_fill_response_cb callback, bool once, void *user_data) +{ + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; + static int seq_num; + + handle = calloc(1, sizeof(struct AutofillSvcPort_autofill_svc_fill_response_cb_s)); + if (!handle) { + _E("Out of memory"); + return NULL; + } + + handle->parcelable.to = __AutofillSvcPort_autofill_svc_fill_response_cb_to; + handle->parcelable.from= __AutofillSvcPort_autofill_svc_fill_response_cb_from; + handle->id = AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->callback = callback; + handle->once = once; + handle->user_data = user_data; + + return handle; +} + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate) +{ + if (!delegate) { + _E("Invalid parameter"); + return -1; + } + + free(delegate); + + return 0; +} + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate) +{ + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; + GList *iter; + + if (!proxy || !delegate) { + _E("Invalid handle %p %p", proxy, delegate); + return -1; + } + + iter = proxy->delegates; + while (iter) { + handle = (struct AutofillSvcPort_autofill_svc_fill_response_cb_s *)iter->data; + if (handle == delegate) { + proxy->delegates = g_list_remove_link(proxy->delegates, iter); + free(handle); + g_list_free(iter); + return 0; + } + iter = g_list_next(iter); + } + + return -1; +} + +static void __AutofillSvcPort_delegate_autofill_svc_fill_response_cb(GList **list, rpc_port_parcel_h parcel, int seq_id, int id) +{ + int context_id; + rpc_port_autofill_svc_fill_response_h response; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_autofill_svc_fill_response_create(&response); + rpc_port_parcel_read(parcel, &response->parcelable, response); + + do { + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; + GList *iter; + + iter = *list; + while (iter) { + handle = (struct AutofillSvcPort_autofill_svc_fill_response_cb_s *)iter->data; + if (handle->seq_id == seq_id && handle->id == id) { + handle->callback(handle->user_data, context_id, response); + + if (handle->once) { + *list = g_list_remove_link(*list, iter); + free(handle); + g_list_free(iter); + } + break; + } + iter = g_list_next(iter); + } + } while (0); + + rpc_port_autofill_svc_fill_response_destroy(response); +} + +static proxy_delegate __AutofillSvcPort_delegate_table[] = { + [AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb] = __AutofillSvcPort_delegate_autofill_svc_auth_info_cb, + [AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb] = __AutofillSvcPort_delegate_autofill_svc_fill_response_cb, +}; + +static void __AutofillSvcPort_process_received_event(GList **list, rpc_port_parcel_h parcel) +{ + int id; + int seq_id; + bool once; + + rpc_port_parcel_read_int32(parcel, &id); + rpc_port_parcel_read_int32(parcel, &seq_id); + rpc_port_parcel_read_bool(parcel, &once); + + if (id > 0 && id < (sizeof(__AutofillSvcPort_delegate_table) / sizeof(__AutofillSvcPort_delegate_table[0]))) { + if (__AutofillSvcPort_delegate_table[id]) + __AutofillSvcPort_delegate_table[id](list, parcel, seq_id, id); + } else { + _W("Unknown id(%d)", id); + } +} + +static rpc_port_parcel_h __AutofillSvcPort_consume_command(rpc_port_proxy_AutofillSvcPort_h h) +{ + rpc_port_parcel_h parcel = NULL; + int cmd = -1; + + do { + rpc_port_parcel_create_from_port(&parcel, h->port); + if (!parcel) + break; + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd == AutofillSvcPort_METHOD_Result) + return parcel; + + rpc_port_parcel_destroy(parcel); + parcel = NULL; + } while (true); + + return NULL; +} + +static void __AutofillSvcPort_on_connected(const char *endpoint, const char *port_name, rpc_port_h port, void *data) +{ + rpc_port_proxy_AutofillSvcPort_h handle = data; + + handle->port = port; + rpc_port_proxy_get_port(handle->proxy, RPC_PORT_PORT_CALLBACK, &handle->callback_port); + if (handle->callback.connected) + handle->callback.connected(handle, handle->user_data); + _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); +} + +static void __AutofillSvcPort_on_disconnected(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_AutofillSvcPort_h handle = data; + + handle->port = NULL; + if (handle->callback.disconnected) + handle->callback.disconnected(handle, handle->user_data); + _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); +} + +static void __AutofillSvcPort_on_rejected(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_AutofillSvcPort_h handle = data; + + handle->port = NULL; + if (handle->callback.rejected) + handle->callback.rejected(handle, handle->user_data); + _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); +} + +static void __AutofillSvcPort_on_received(const char *endpoint, const char *port_name, void *data) +{ + rpc_port_proxy_AutofillSvcPort_h handle = data; + rpc_port_parcel_h parcel_received = NULL; + int cmd = -1; + + rpc_port_parcel_create_from_port(&parcel_received, handle->callback_port); + if (!parcel_received) { + _E("Failed to create parcel from port(%s)", port_name); + return; + } + + rpc_port_parcel_read_int32(parcel_received, &cmd); + if (cmd != AutofillSvcPort_METHOD_Callback) { + _E("Invalid protocol"); + rpc_port_parcel_destroy(parcel_received); + return; + } + + __AutofillSvcPort_process_received_event(&handle->delegates, parcel_received); + rpc_port_parcel_destroy(parcel_received); + _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); +} + +int rpc_port_proxy_AutofillSvcPort_invoke_Register(rpc_port_proxy_AutofillSvcPort_h h, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h auth_info_cb, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h fill_response_cb) +{ + rpc_port_parcel_h parcel; + int r; + int ret = -1; + + if (!h || !auth_info_cb || !fill_response_cb) { + _E("Invalid parameter"); + return ret; + } + + if (!h->port) { + _E("Not connected"); + return ret; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_Register); + + do { + struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = auth_info_cb; + + rpc_port_parcel_write(parcel, &handle->parcelable, handle); + h->delegates = g_list_append(h->delegates, handle); + } while (0); + + do { + struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = fill_response_cb; + + rpc_port_parcel_write(parcel, &handle->parcelable, handle); + h->delegates = g_list_append(h->delegates, handle); + } while (0); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + + g_rec_mutex_lock(&h->mutex); + do { + rpc_port_parcel_h parcel_received; + + parcel_received = __AutofillSvcPort_consume_command(h); + if (!parcel_received) { + _E("Invalid protocol"); + break; + } + + rpc_port_parcel_read_int32(parcel_received, &ret); + + rpc_port_parcel_destroy(parcel_received); + } while (0); + g_rec_mutex_unlock(&h->mutex); + set_last_result(r); + + return ret; +} + +void rpc_port_proxy_AutofillSvcPort_invoke_Unregister(rpc_port_proxy_AutofillSvcPort_h h) +{ + rpc_port_parcel_h parcel; + int r; + + if (!h) { + _E("Invalid parameter"); + return; + } + + if (!h->port) { + _E("Not connected"); + return; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_Unregister); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + set_last_result(r); +} + +void rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi) +{ + rpc_port_parcel_h parcel; + int r; + + if (!h || !vi) { + _E("Invalid parameter"); + return; + } + + if (!h->port) { + _E("Not connected"); + return; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_request_auth_info); + rpc_port_parcel_write_int32(parcel, context_id); + rpc_port_parcel_write(parcel, &vi->parcelable, vi); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + set_last_result(r); +} + +void rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi) +{ + rpc_port_parcel_h parcel; + int r; + + if (!h || !vi) { + _E("Invalid parameter"); + return; + } + + if (!h->port) { + _E("Not connected"); + return; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_send_fill_request); + rpc_port_parcel_write_int32(parcel, context_id); + rpc_port_parcel_write(parcel, &vi->parcelable, vi); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + set_last_result(r); +} + +void rpc_port_proxy_AutofillSvcPort_invoke_commit(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_save_view_info_h si) +{ + rpc_port_parcel_h parcel; + int r; + + if (!h || !si) { + _E("Invalid parameter"); + return; + } + + if (!h->port) { + _E("Not connected"); + return; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_commit); + rpc_port_parcel_write_int32(parcel, context_id); + rpc_port_parcel_write(parcel, &si->parcelable, si); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + set_last_result(r); +} + +void rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(rpc_port_proxy_AutofillSvcPort_h h) +{ + rpc_port_parcel_h parcel; + int r; + + if (!h) { + _E("Invalid parameter"); + return; + } + + if (!h->port) { + _E("Not connected"); + return; + } + + rpc_port_parcel_create(&parcel); + rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_request_terminate); + + r = rpc_port_parcel_send(parcel, h->port); + if (r != RPC_PORT_ERROR_NONE) { + _E("Failed to send parcel. result(%d)", r); + r = RPC_PORT_ERROR_IO_ERROR; + } + + rpc_port_parcel_destroy(parcel); + set_last_result(r); +} + +static struct AutofillSvcPort_s *__create_AutofillSvcPort(const char *stub_appid, rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data) +{ + struct AutofillSvcPort_s *handle; + + handle = calloc(1, sizeof(struct AutofillSvcPort_s)); + if (!handle) { + _E("Out of memory"); + return NULL; + } + + handle->stub_appid = strdup(stub_appid); + if (!handle->stub_appid) { + _E("Out of memory"); + free(handle); + return NULL; + } + + rpc_port_proxy_create(&handle->proxy); + if (!handle->proxy) { + _E("Failed to create proxy"); + free(handle->stub_appid); + free(handle); + return NULL; + } + + g_rec_mutex_init(&handle->mutex); + + handle->callback = *callback; + handle->user_data = user_data; + + return handle; +} + +static void __destroy_AutofillSvcPort(struct AutofillSvcPort_s *h) +{ + if (!h) + return; + + g_rec_mutex_clear(&h->mutex); + + if (h->delegates) + g_list_free_full(h->delegates, free); + + if (h->proxy) + rpc_port_proxy_destroy(h->proxy); + + if (h->stub_appid) + free(h->stub_appid); + + free(h); +} + +int rpc_port_proxy_AutofillSvcPort_create(const char *stub_appid, rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data, rpc_port_proxy_AutofillSvcPort_h *h) +{ + struct AutofillSvcPort_s *handle; + int r; + + if (!stub_appid || !callback || !h) { + _E("Invalid parameter"); + return -1; + } + + handle = __create_AutofillSvcPort(stub_appid, callback, user_data); + if (!handle) + return -1; + + r = rpc_port_proxy_add_connected_event_cb(handle->proxy, __AutofillSvcPort_on_connected, handle); + if (r != 0) { + _E("Failed to add connected event cb. err = %d", r); + __destroy_AutofillSvcPort(handle); + return r; + } + + r = rpc_port_proxy_add_disconnected_event_cb(handle->proxy, __AutofillSvcPort_on_disconnected, handle); + if (r != 0) { + _E("Failed to add disconnected event cb. err = %d", r); + __destroy_AutofillSvcPort(handle); + return r; + } + + r = rpc_port_proxy_add_rejected_event_cb(handle->proxy, __AutofillSvcPort_on_rejected, handle); + if (r != 0) { + _E("Failed to add rejected event cb. err = %d", r); + __destroy_AutofillSvcPort(handle); + return r; + } + + r = rpc_port_proxy_add_received_event_cb(handle->proxy, __AutofillSvcPort_on_received, handle); + if (r != 0) { + _E("Failed to add received event cb. err = %d", r); + __destroy_AutofillSvcPort(handle); + return r; + } + + *h = handle; + + return 0; +} + +int rpc_port_proxy_AutofillSvcPort_connect(rpc_port_proxy_AutofillSvcPort_h h) +{ + int r; + + if (!h || !h->proxy) { + _E("Invalid parameter"); + return -1; + } + + r = rpc_port_proxy_connect(h->proxy, h->stub_appid, "AutofillSvcPort"); + if (r != 0) { + _E("Failed to connect AutofillSvcPort(%s)", h->stub_appid); + return r; + } + + return 0; +} + +int rpc_port_proxy_AutofillSvcPort_destroy(rpc_port_proxy_AutofillSvcPort_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + __destroy_AutofillSvcPort(h); + return 0; +} diff --git a/src/autofill_service_proxy.h b/src/autofill_service_proxy.h new file mode 100644 index 0000000..8a0700b --- /dev/null +++ b/src/autofill_service_proxy.h @@ -0,0 +1,346 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct autofill_svc_item_s *rpc_port_autofill_svc_item_h; + +int rpc_port_autofill_svc_item_create(rpc_port_autofill_svc_item_h *h); + +int rpc_port_autofill_svc_item_destroy(rpc_port_autofill_svc_item_h h); + +int rpc_port_autofill_svc_item_clone(rpc_port_autofill_svc_item_h h, rpc_port_autofill_svc_item_h *clone); + +int rpc_port_autofill_svc_item_set_id(rpc_port_autofill_svc_item_h h, const char *id); + +int rpc_port_autofill_svc_item_set_label(rpc_port_autofill_svc_item_h h, const char *label); + +int rpc_port_autofill_svc_item_set_value(rpc_port_autofill_svc_item_h h, const char *value); + +int rpc_port_autofill_svc_item_set_autofill_hint(rpc_port_autofill_svc_item_h h, int autofill_hint); + +int rpc_port_autofill_svc_item_set_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool is_sensitive_data); + +int rpc_port_autofill_svc_item_get_id(rpc_port_autofill_svc_item_h h, char **id); + +int rpc_port_autofill_svc_item_get_label(rpc_port_autofill_svc_item_h h, char **label); + +int rpc_port_autofill_svc_item_get_value(rpc_port_autofill_svc_item_h h, char **value); + +int rpc_port_autofill_svc_item_get_autofill_hint(rpc_port_autofill_svc_item_h h, int *autofill_hint); + +int rpc_port_autofill_svc_item_get_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool *is_sensitive_data); + +typedef struct autofill_svc_view_info_s *rpc_port_autofill_svc_view_info_h; + +int rpc_port_autofill_svc_view_info_create(rpc_port_autofill_svc_view_info_h *h); + +int rpc_port_autofill_svc_view_info_destroy(rpc_port_autofill_svc_view_info_h h); + +int rpc_port_autofill_svc_view_info_clone(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_view_info_h *clone); + +int rpc_port_autofill_svc_view_info_set_app_id(rpc_port_autofill_svc_view_info_h h, const char *app_id); + +int rpc_port_autofill_svc_view_info_set_view_id(rpc_port_autofill_svc_view_info_h h, const char *view_id); + +int rpc_port_autofill_svc_view_info_add_items(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_item_h items); + +int rpc_port_autofill_svc_view_info_get_app_id(rpc_port_autofill_svc_view_info_h h, char **app_id); + +int rpc_port_autofill_svc_view_info_get_view_id(rpc_port_autofill_svc_view_info_h h, char **view_id); + +int rpc_port_autofill_svc_view_info_foreach_items(rpc_port_autofill_svc_view_info_h h, + bool (*callback)(rpc_port_autofill_svc_item_h items, void *user_data), void *user_data); + +int rpc_port_autofill_svc_view_info_remove_items(rpc_port_autofill_svc_view_info_h h, unsigned int nth); + +int rpc_port_autofill_svc_view_info_get_items_length(rpc_port_autofill_svc_view_info_h h, unsigned int *length); + +typedef struct autofill_svc_save_item_s *rpc_port_autofill_svc_save_item_h; + +int rpc_port_autofill_svc_save_item_create(rpc_port_autofill_svc_save_item_h *h); + +int rpc_port_autofill_svc_save_item_destroy(rpc_port_autofill_svc_save_item_h h); + +int rpc_port_autofill_svc_save_item_clone(rpc_port_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h *clone); + +int rpc_port_autofill_svc_save_item_set_id(rpc_port_autofill_svc_save_item_h h, const char *id); + +int rpc_port_autofill_svc_save_item_set_label(rpc_port_autofill_svc_save_item_h h, const char *label); + +int rpc_port_autofill_svc_save_item_set_value(rpc_port_autofill_svc_save_item_h h, const char *value); + +int rpc_port_autofill_svc_save_item_set_autofill_hint(rpc_port_autofill_svc_save_item_h h, int autofill_hint); + +int rpc_port_autofill_svc_save_item_set_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool is_sensitive_data); + +int rpc_port_autofill_svc_save_item_get_id(rpc_port_autofill_svc_save_item_h h, char **id); + +int rpc_port_autofill_svc_save_item_get_label(rpc_port_autofill_svc_save_item_h h, char **label); + +int rpc_port_autofill_svc_save_item_get_value(rpc_port_autofill_svc_save_item_h h, char **value); + +int rpc_port_autofill_svc_save_item_get_autofill_hint(rpc_port_autofill_svc_save_item_h h, int *autofill_hint); + +int rpc_port_autofill_svc_save_item_get_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool *is_sensitive_data); + +typedef struct autofill_svc_save_view_info_s *rpc_port_autofill_svc_save_view_info_h; + +int rpc_port_autofill_svc_save_view_info_create(rpc_port_autofill_svc_save_view_info_h *h); + +int rpc_port_autofill_svc_save_view_info_destroy(rpc_port_autofill_svc_save_view_info_h h); + +int rpc_port_autofill_svc_save_view_info_clone(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_view_info_h *clone); + +int rpc_port_autofill_svc_save_view_info_set_view_id(rpc_port_autofill_svc_save_view_info_h h, const char *view_id); + +int rpc_port_autofill_svc_save_view_info_add_items(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_item_h items); + +int rpc_port_autofill_svc_save_view_info_get_view_id(rpc_port_autofill_svc_save_view_info_h h, char **view_id); + +int rpc_port_autofill_svc_save_view_info_foreach_items(rpc_port_autofill_svc_save_view_info_h h, + bool (*callback)(rpc_port_autofill_svc_save_item_h items, void *user_data), void *user_data); + +int rpc_port_autofill_svc_save_view_info_remove_items(rpc_port_autofill_svc_save_view_info_h h, unsigned int nth); + +int rpc_port_autofill_svc_save_view_info_get_items_length(rpc_port_autofill_svc_save_view_info_h h, unsigned int *length); + +typedef struct autofill_svc_auth_info_s *rpc_port_autofill_svc_auth_info_h; + +int rpc_port_autofill_svc_auth_info_create(rpc_port_autofill_svc_auth_info_h *h); + +int rpc_port_autofill_svc_auth_info_destroy(rpc_port_autofill_svc_auth_info_h h); + +int rpc_port_autofill_svc_auth_info_clone(rpc_port_autofill_svc_auth_info_h h, rpc_port_autofill_svc_auth_info_h *clone); + +int rpc_port_autofill_svc_auth_info_set_app_id(rpc_port_autofill_svc_auth_info_h h, const char *app_id); + +int rpc_port_autofill_svc_auth_info_set_view_id(rpc_port_autofill_svc_auth_info_h h, const char *view_id); + +int rpc_port_autofill_svc_auth_info_set_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool exist_autofill_data); + +int rpc_port_autofill_svc_auth_info_set_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool need_authentication); + +int rpc_port_autofill_svc_auth_info_set_service_name(rpc_port_autofill_svc_auth_info_h h, const char *service_name); + +int rpc_port_autofill_svc_auth_info_set_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, const char *service_logo_image_path); + +int rpc_port_autofill_svc_auth_info_set_service_message(rpc_port_autofill_svc_auth_info_h h, const char *service_message); + +int rpc_port_autofill_svc_auth_info_get_app_id(rpc_port_autofill_svc_auth_info_h h, char **app_id); + +int rpc_port_autofill_svc_auth_info_get_view_id(rpc_port_autofill_svc_auth_info_h h, char **view_id); + +int rpc_port_autofill_svc_auth_info_get_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool *exist_autofill_data); + +int rpc_port_autofill_svc_auth_info_get_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool *need_authentication); + +int rpc_port_autofill_svc_auth_info_get_service_name(rpc_port_autofill_svc_auth_info_h h, char **service_name); + +int rpc_port_autofill_svc_auth_info_get_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, char **service_logo_image_path); + +int rpc_port_autofill_svc_auth_info_get_service_message(rpc_port_autofill_svc_auth_info_h h, char **service_message); + +typedef struct autofill_svc_response_item_s *rpc_port_autofill_svc_response_item_h; + +int rpc_port_autofill_svc_response_item_create(rpc_port_autofill_svc_response_item_h *h); + +int rpc_port_autofill_svc_response_item_destroy(rpc_port_autofill_svc_response_item_h h); + +int rpc_port_autofill_svc_response_item_clone(rpc_port_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h *clone); + +int rpc_port_autofill_svc_response_item_set_id(rpc_port_autofill_svc_response_item_h h, const char *id); + +int rpc_port_autofill_svc_response_item_set_presentation_text(rpc_port_autofill_svc_response_item_h h, const char *presentation_text); + +int rpc_port_autofill_svc_response_item_set_value(rpc_port_autofill_svc_response_item_h h, const char *value); + +int rpc_port_autofill_svc_response_item_get_id(rpc_port_autofill_svc_response_item_h h, char **id); + +int rpc_port_autofill_svc_response_item_get_presentation_text(rpc_port_autofill_svc_response_item_h h, char **presentation_text); + +int rpc_port_autofill_svc_response_item_get_value(rpc_port_autofill_svc_response_item_h h, char **value); + +typedef struct autofill_svc_response_group_s *rpc_port_autofill_svc_response_group_h; + +int rpc_port_autofill_svc_response_group_create(rpc_port_autofill_svc_response_group_h *h); + +int rpc_port_autofill_svc_response_group_destroy(rpc_port_autofill_svc_response_group_h h); + +int rpc_port_autofill_svc_response_group_clone(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h *clone); + +int rpc_port_autofill_svc_response_group_add_response_items(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_item_h response_items); + +int rpc_port_autofill_svc_response_group_foreach_response_items(rpc_port_autofill_svc_response_group_h h, + bool (*callback)(rpc_port_autofill_svc_response_item_h response_items, void *user_data), void *user_data); + +int rpc_port_autofill_svc_response_group_remove_response_items(rpc_port_autofill_svc_response_group_h h, unsigned int nth); + +int rpc_port_autofill_svc_response_group_get_response_items_length(rpc_port_autofill_svc_response_group_h h, unsigned int *length); + +typedef struct autofill_svc_fill_response_s *rpc_port_autofill_svc_fill_response_h; + +int rpc_port_autofill_svc_fill_response_create(rpc_port_autofill_svc_fill_response_h *h); + +int rpc_port_autofill_svc_fill_response_destroy(rpc_port_autofill_svc_fill_response_h h); + +int rpc_port_autofill_svc_fill_response_clone(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_fill_response_h *clone); + +int rpc_port_autofill_svc_fill_response_set_app_id(rpc_port_autofill_svc_fill_response_h h, const char *app_id); + +int rpc_port_autofill_svc_fill_response_set_view_id(rpc_port_autofill_svc_fill_response_h h, const char *view_id); + +int rpc_port_autofill_svc_fill_response_add_response_groups(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_response_group_h response_groups); + +int rpc_port_autofill_svc_fill_response_get_app_id(rpc_port_autofill_svc_fill_response_h h, char **app_id); + +int rpc_port_autofill_svc_fill_response_get_view_id(rpc_port_autofill_svc_fill_response_h h, char **view_id); + +int rpc_port_autofill_svc_fill_response_foreach_response_groups(rpc_port_autofill_svc_fill_response_h h, + bool (*callback)(rpc_port_autofill_svc_response_group_h response_groups, void *user_data), void *user_data); + +int rpc_port_autofill_svc_fill_response_remove_response_groups(rpc_port_autofill_svc_fill_response_h h, unsigned int nth); + +int rpc_port_autofill_svc_fill_response_get_response_groups_length(rpc_port_autofill_svc_fill_response_h h, unsigned int *length); + +typedef struct list_autofill_svc_item_s *rpc_port_list_autofill_svc_item_h; + +int rpc_port_list_autofill_svc_item_create(rpc_port_list_autofill_svc_item_h *h); + +int rpc_port_list_autofill_svc_item_destroy(rpc_port_list_autofill_svc_item_h h); + +int rpc_port_list_autofill_svc_item_clone(rpc_port_list_autofill_svc_item_h h, rpc_port_list_autofill_svc_item_h *clone); + +int rpc_port_list_autofill_svc_item_add_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, rpc_port_autofill_svc_item_h list_autofill_svc_items); + +int rpc_port_list_autofill_svc_item_foreach_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, + bool (*callback)(rpc_port_autofill_svc_item_h list_autofill_svc_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_svc_item_remove_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, unsigned int nth); + +int rpc_port_list_autofill_svc_item_get_list_autofill_svc_items_length(rpc_port_list_autofill_svc_item_h h, unsigned int *length); + +typedef struct list_autofill_svc_response_group_s *rpc_port_list_autofill_svc_response_group_h; + +int rpc_port_list_autofill_svc_response_group_create(rpc_port_list_autofill_svc_response_group_h *h); + +int rpc_port_list_autofill_svc_response_group_destroy(rpc_port_list_autofill_svc_response_group_h h); + +int rpc_port_list_autofill_svc_response_group_clone(rpc_port_list_autofill_svc_response_group_h h, rpc_port_list_autofill_svc_response_group_h *clone); + +int rpc_port_list_autofill_svc_response_group_add_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups); + +int rpc_port_list_autofill_svc_response_group_foreach_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, + bool (*callback)(rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups, void *user_data), void *user_data); + +int rpc_port_list_autofill_svc_response_group_remove_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, unsigned int nth); + +int rpc_port_list_autofill_svc_response_group_get_list_autofill_svc_response_groups_length(rpc_port_list_autofill_svc_response_group_h h, unsigned int *length); + +typedef struct list_autofill_svc_response_item_s *rpc_port_list_autofill_svc_response_item_h; + +int rpc_port_list_autofill_svc_response_item_create(rpc_port_list_autofill_svc_response_item_h *h); + +int rpc_port_list_autofill_svc_response_item_destroy(rpc_port_list_autofill_svc_response_item_h h); + +int rpc_port_list_autofill_svc_response_item_clone(rpc_port_list_autofill_svc_response_item_h h, rpc_port_list_autofill_svc_response_item_h *clone); + +int rpc_port_list_autofill_svc_response_item_add_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items); + +int rpc_port_list_autofill_svc_response_item_foreach_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, + bool (*callback)(rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_svc_response_item_remove_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, unsigned int nth); + +int rpc_port_list_autofill_svc_response_item_get_list_autofill_svc_response_items_length(rpc_port_list_autofill_svc_response_item_h h, unsigned int *length); + +typedef struct list_autofill_svc_save_item_s *rpc_port_list_autofill_svc_save_item_h; + +int rpc_port_list_autofill_svc_save_item_create(rpc_port_list_autofill_svc_save_item_h *h); + +int rpc_port_list_autofill_svc_save_item_destroy(rpc_port_list_autofill_svc_save_item_h h); + +int rpc_port_list_autofill_svc_save_item_clone(rpc_port_list_autofill_svc_save_item_h h, rpc_port_list_autofill_svc_save_item_h *clone); + +int rpc_port_list_autofill_svc_save_item_add_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items); + +int rpc_port_list_autofill_svc_save_item_foreach_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, + bool (*callback)(rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_svc_save_item_remove_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, unsigned int nth); + +int rpc_port_list_autofill_svc_save_item_get_list_autofill_svc_save_items_length(rpc_port_list_autofill_svc_save_item_h h, unsigned int *length); + +typedef struct AutofillSvcPort_s *rpc_port_proxy_AutofillSvcPort_h; + +typedef struct { + void (*connected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); + void (*disconnected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); + void (*rejected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); +} rpc_port_proxy_AutofillSvcPort_callback_s; + +typedef struct AutofillSvcPort_autofill_svc_auth_info_cb_s *rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h; + +typedef void (*AutofillSvcPort_autofill_svc_auth_info_cb)(void *user_data, int context_id, rpc_port_autofill_svc_auth_info_h auth_info); + +rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_create(AutofillSvcPort_autofill_svc_auth_info_cb callback, bool once, void *user_data); + +int rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate); + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate); + +typedef struct AutofillSvcPort_autofill_svc_fill_response_cb_s *rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h; + +typedef void (*AutofillSvcPort_autofill_svc_fill_response_cb)(void *user_data, int context_id, rpc_port_autofill_svc_fill_response_h response); + +rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_create(AutofillSvcPort_autofill_svc_fill_response_cb callback, bool once, void *user_data); + +int rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate); + +int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate); + +int rpc_port_proxy_AutofillSvcPort_create(const char *stub_appid, + rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data, + rpc_port_proxy_AutofillSvcPort_h *h); + +int rpc_port_proxy_AutofillSvcPort_connect(rpc_port_proxy_AutofillSvcPort_h h); + +int rpc_port_proxy_AutofillSvcPort_destroy(rpc_port_proxy_AutofillSvcPort_h h); + +int rpc_port_proxy_AutofillSvcPort_invoke_Register(rpc_port_proxy_AutofillSvcPort_h h, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h auth_info_cb, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h fill_response_cb); + +void rpc_port_proxy_AutofillSvcPort_invoke_Unregister(rpc_port_proxy_AutofillSvcPort_h h); + +void rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi); + +void rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi); + +void rpc_port_proxy_AutofillSvcPort_invoke_commit(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_save_view_info_h si); + +void rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(rpc_port_proxy_AutofillSvcPort_h h); + +#ifdef __cplusplus +} +#endif diff --git a/src/autofill_stub.c b/src/autofill_stub.c new file mode 100644 index 0000000..086ada2 --- /dev/null +++ b/src/autofill_stub.c @@ -0,0 +1,4148 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "autofill_stub.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "RPC_PORT_STUB" + +#ifdef _E +#undef _E +#endif + +#ifdef _W +#undef _W +#endif + +#ifdef _I +#undef _I +#endif + +#ifdef _D +#undef _D +#endif + +#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data); + +struct autofill_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *label; + char *value; + int autofill_hint; + bool is_sensitive_data; +}; + +static void __autofill_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); + rpc_port_parcel_write_int32(parcel, h->autofill_hint); + rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); +} + +static void __autofill_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->label); + rpc_port_parcel_read_string(parcel, &h->value); + rpc_port_parcel_read_int32(parcel, &h->autofill_hint); + rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); +} + +int rpc_port_autofill_item_create(rpc_port_autofill_item_h *h) +{ + struct autofill_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_item_to; + handle->parcelable.from = __autofill_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_item_destroy(rpc_port_autofill_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->label) + free(h->label); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_item_clone(rpc_port_autofill_item_h h, rpc_port_autofill_item_h *clone) +{ + rpc_port_autofill_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_item_destroy(handle); + return -1; + } + } + + if (h->label) { + handle->label = strdup(h->label); + if (!handle->label) { + _E("Failed to duplicate h->label"); + rpc_port_autofill_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_item_destroy(handle); + return -1; + } + } + + handle->autofill_hint = h->autofill_hint; + handle->is_sensitive_data = h->is_sensitive_data; + *clone = handle; + + return 0; +} + +int rpc_port_autofill_item_set_id(rpc_port_autofill_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_set_label(rpc_port_autofill_item_h h, const char *label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (h->label) { + free(h->label); + h->label = NULL; + } + + h->label = strdup(label); + if (!h->label) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_set_value(rpc_port_autofill_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_set_autofill_hint(rpc_port_autofill_item_h h, int autofill_hint) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->autofill_hint = autofill_hint; + return 0; +} + +int rpc_port_autofill_item_set_is_sensitive_data(rpc_port_autofill_item_h h, bool is_sensitive_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->is_sensitive_data = is_sensitive_data; + return 0; +} + +int rpc_port_autofill_item_get_id(rpc_port_autofill_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_get_label(rpc_port_autofill_item_h h, char **label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (!h->label) { + _E("Invalid parameter: h->label is NULL"); + return -1; + } + + *label = strdup(h->label); + if (*label == NULL) { + _E("Failed to duplicate label"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_get_value(rpc_port_autofill_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_item_get_autofill_hint(rpc_port_autofill_item_h h, int *autofill_hint) +{ + if (!h || !autofill_hint) { + _E("Invalid parameter"); + return -1; + } + + *autofill_hint = h->autofill_hint; + return 0; +} + +int rpc_port_autofill_item_get_is_sensitive_data(rpc_port_autofill_item_h h, bool *is_sensitive_data) +{ + if (!h || !is_sensitive_data) { + _E("Invalid parameter"); + return -1; + } + + *is_sensitive_data = h->is_sensitive_data; + return 0; +} + +struct autofill_view_info_s { + rpc_port_parcelable_t parcelable; + char *view_id; + GList *items; +}; + +static void __autofill_view_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_view_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_item_h value = NULL; + + rpc_port_autofill_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->items = g_list_append(h->items, value); + } + } while (0); +} + +int rpc_port_autofill_view_info_create(rpc_port_autofill_view_info_h *h) +{ + struct autofill_view_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_view_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_view_info_to; + handle->parcelable.from = __autofill_view_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_view_info_destroy(rpc_port_autofill_view_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + if (value) + rpc_port_autofill_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_view_info_clone(rpc_port_autofill_view_info_h h, rpc_port_autofill_view_info_h *clone) +{ + rpc_port_autofill_view_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_view_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_view_info handle"); + return -1; + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_view_info_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_item_h new_value; + rpc_port_autofill_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_view_info_destroy(handle); + return -1; + } + + rpc_port_autofill_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_view_info_destroy(handle); + return -1; + } + + handle->items = g_list_append(handle->items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_view_info_set_view_id(rpc_port_autofill_view_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_view_info_add_items(rpc_port_autofill_view_info_h h, rpc_port_autofill_item_h items) +{ + if (!h || !items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_item_h value = NULL; + + rpc_port_autofill_item_clone(items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->items = g_list_append(h->items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_view_info_get_view_id(rpc_port_autofill_view_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_view_info_foreach_items(rpc_port_autofill_view_info_h h, + bool (*callback)(rpc_port_autofill_item_h items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_view_info_remove_items(rpc_port_autofill_view_info_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_item_h value = iter->data; + h->items = g_list_remove_link(h->items, iter); + rpc_port_autofill_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_view_info_get_items_length(rpc_port_autofill_view_info_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->items); + + return 0; +} + +struct autofill_save_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *label; + char *value; + int autofill_hint; + bool is_sensitive_data; +}; + +static void __autofill_save_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); + rpc_port_parcel_write_int32(parcel, h->autofill_hint); + rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); +} + +static void __autofill_save_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->label); + rpc_port_parcel_read_string(parcel, &h->value); + rpc_port_parcel_read_int32(parcel, &h->autofill_hint); + rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); +} + +int rpc_port_autofill_save_item_create(rpc_port_autofill_save_item_h *h) +{ + struct autofill_save_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_save_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_save_item_to; + handle->parcelable.from = __autofill_save_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_save_item_destroy(rpc_port_autofill_save_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->label) + free(h->label); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_save_item_clone(rpc_port_autofill_save_item_h h, rpc_port_autofill_save_item_h *clone) +{ + rpc_port_autofill_save_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_save_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_save_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_save_item_destroy(handle); + return -1; + } + } + + if (h->label) { + handle->label = strdup(h->label); + if (!handle->label) { + _E("Failed to duplicate h->label"); + rpc_port_autofill_save_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_save_item_destroy(handle); + return -1; + } + } + + handle->autofill_hint = h->autofill_hint; + handle->is_sensitive_data = h->is_sensitive_data; + *clone = handle; + + return 0; +} + +int rpc_port_autofill_save_item_set_id(rpc_port_autofill_save_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_set_label(rpc_port_autofill_save_item_h h, const char *label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (h->label) { + free(h->label); + h->label = NULL; + } + + h->label = strdup(label); + if (!h->label) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_set_value(rpc_port_autofill_save_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_set_autofill_hint(rpc_port_autofill_save_item_h h, int autofill_hint) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->autofill_hint = autofill_hint; + return 0; +} + +int rpc_port_autofill_save_item_set_is_sensitive_data(rpc_port_autofill_save_item_h h, bool is_sensitive_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->is_sensitive_data = is_sensitive_data; + return 0; +} + +int rpc_port_autofill_save_item_get_id(rpc_port_autofill_save_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_get_label(rpc_port_autofill_save_item_h h, char **label) +{ + if (!h || !label) { + _E("Invalid parameter"); + return -1; + } + + if (!h->label) { + _E("Invalid parameter: h->label is NULL"); + return -1; + } + + *label = strdup(h->label); + if (*label == NULL) { + _E("Failed to duplicate label"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_get_value(rpc_port_autofill_save_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_item_get_autofill_hint(rpc_port_autofill_save_item_h h, int *autofill_hint) +{ + if (!h || !autofill_hint) { + _E("Invalid parameter"); + return -1; + } + + *autofill_hint = h->autofill_hint; + return 0; +} + +int rpc_port_autofill_save_item_get_is_sensitive_data(rpc_port_autofill_save_item_h h, bool *is_sensitive_data) +{ + if (!h || !is_sensitive_data) { + _E("Invalid parameter"); + return -1; + } + + *is_sensitive_data = h->is_sensitive_data; + return 0; +} + +struct autofill_save_view_info_s { + rpc_port_parcelable_t parcelable; + char *view_id; + GList *items; +}; + +static void __autofill_save_view_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_save_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_save_view_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_save_view_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_save_item_h value = NULL; + + rpc_port_autofill_save_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->items = g_list_append(h->items, value); + } + } while (0); +} + +int rpc_port_autofill_save_view_info_create(rpc_port_autofill_save_view_info_h *h) +{ + struct autofill_save_view_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_save_view_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_save_view_info_to; + handle->parcelable.from = __autofill_save_view_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_save_view_info_destroy(rpc_port_autofill_save_view_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + if (value) + rpc_port_autofill_save_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_save_view_info_clone(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_view_info_h *clone) +{ + rpc_port_autofill_save_view_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_save_view_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_save_view_info handle"); + return -1; + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_save_view_info_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_save_item_h new_value; + rpc_port_autofill_save_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_save_view_info_destroy(handle); + return -1; + } + + rpc_port_autofill_save_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_save_view_info_destroy(handle); + return -1; + } + + handle->items = g_list_append(handle->items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_save_view_info_set_view_id(rpc_port_autofill_save_view_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_view_info_add_items(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_item_h items) +{ + if (!h || !items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_save_item_h value = NULL; + + rpc_port_autofill_save_item_clone(items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->items = g_list_append(h->items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_save_view_info_get_view_id(rpc_port_autofill_save_view_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_save_view_info_foreach_items(rpc_port_autofill_save_view_info_h h, + bool (*callback)(rpc_port_autofill_save_item_h items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_save_view_info_remove_items(rpc_port_autofill_save_view_info_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_save_item_h value = iter->data; + h->items = g_list_remove_link(h->items, iter); + rpc_port_autofill_save_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_save_view_info_get_items_length(rpc_port_autofill_save_view_info_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->items); + + return 0; +} + +struct autofill_auth_info_s { + rpc_port_parcelable_t parcelable; + char *view_id; + bool exist_autofill_data; + bool need_authentication; + char *service_name; + char *service_logo_image_path; + char *service_message; +}; + +static void __autofill_auth_info_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_auth_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_bool(parcel, h->exist_autofill_data); + rpc_port_parcel_write_bool(parcel, h->need_authentication); + rpc_port_parcel_write_string(parcel, h->service_name ? h->service_name : ""); + rpc_port_parcel_write_string(parcel, h->service_logo_image_path ? h->service_logo_image_path : ""); + rpc_port_parcel_write_string(parcel, h->service_message ? h->service_message : ""); +} + +static void __autofill_auth_info_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_auth_info_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->view_id); + rpc_port_parcel_read_bool(parcel, &h->exist_autofill_data); + rpc_port_parcel_read_bool(parcel, &h->need_authentication); + rpc_port_parcel_read_string(parcel, &h->service_name); + rpc_port_parcel_read_string(parcel, &h->service_logo_image_path); + rpc_port_parcel_read_string(parcel, &h->service_message); +} + +int rpc_port_autofill_auth_info_create(rpc_port_autofill_auth_info_h *h) +{ + struct autofill_auth_info_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_auth_info_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_auth_info_to; + handle->parcelable.from = __autofill_auth_info_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_auth_info_destroy(rpc_port_autofill_auth_info_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) + free(h->view_id); + + if (h->service_name) + free(h->service_name); + + if (h->service_logo_image_path) + free(h->service_logo_image_path); + + if (h->service_message) + free(h->service_message); + + free(h); + + return 0; +} + +int rpc_port_autofill_auth_info_clone(rpc_port_autofill_auth_info_h h, rpc_port_autofill_auth_info_h *clone) +{ + rpc_port_autofill_auth_info_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_auth_info_create(&handle); + if (!handle) { + _E("Failed to create autofill_auth_info handle"); + return -1; + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_auth_info_destroy(handle); + return -1; + } + } + + handle->exist_autofill_data = h->exist_autofill_data; + handle->need_authentication = h->need_authentication; + if (h->service_name) { + handle->service_name = strdup(h->service_name); + if (!handle->service_name) { + _E("Failed to duplicate h->service_name"); + rpc_port_autofill_auth_info_destroy(handle); + return -1; + } + } + + if (h->service_logo_image_path) { + handle->service_logo_image_path = strdup(h->service_logo_image_path); + if (!handle->service_logo_image_path) { + _E("Failed to duplicate h->service_logo_image_path"); + rpc_port_autofill_auth_info_destroy(handle); + return -1; + } + } + + if (h->service_message) { + handle->service_message = strdup(h->service_message); + if (!handle->service_message) { + _E("Failed to duplicate h->service_message"); + rpc_port_autofill_auth_info_destroy(handle); + return -1; + } + } + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_auth_info_set_view_id(rpc_port_autofill_auth_info_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_set_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool exist_autofill_data) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->exist_autofill_data = exist_autofill_data; + return 0; +} + +int rpc_port_autofill_auth_info_set_need_authentication(rpc_port_autofill_auth_info_h h, bool need_authentication) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + h->need_authentication = need_authentication; + return 0; +} + +int rpc_port_autofill_auth_info_set_service_name(rpc_port_autofill_auth_info_h h, const char *service_name) +{ + if (!h || !service_name) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_name) { + free(h->service_name); + h->service_name = NULL; + } + + h->service_name = strdup(service_name); + if (!h->service_name) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_set_service_logo_image_path(rpc_port_autofill_auth_info_h h, const char *service_logo_image_path) +{ + if (!h || !service_logo_image_path) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_logo_image_path) { + free(h->service_logo_image_path); + h->service_logo_image_path = NULL; + } + + h->service_logo_image_path = strdup(service_logo_image_path); + if (!h->service_logo_image_path) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_set_service_message(rpc_port_autofill_auth_info_h h, const char *service_message) +{ + if (!h || !service_message) { + _E("Invalid parameter"); + return -1; + } + + if (h->service_message) { + free(h->service_message); + h->service_message = NULL; + } + + h->service_message = strdup(service_message); + if (!h->service_message) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_get_view_id(rpc_port_autofill_auth_info_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_get_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool *exist_autofill_data) +{ + if (!h || !exist_autofill_data) { + _E("Invalid parameter"); + return -1; + } + + *exist_autofill_data = h->exist_autofill_data; + return 0; +} + +int rpc_port_autofill_auth_info_get_need_authentication(rpc_port_autofill_auth_info_h h, bool *need_authentication) +{ + if (!h || !need_authentication) { + _E("Invalid parameter"); + return -1; + } + + *need_authentication = h->need_authentication; + return 0; +} + +int rpc_port_autofill_auth_info_get_service_name(rpc_port_autofill_auth_info_h h, char **service_name) +{ + if (!h || !service_name) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_name) { + _E("Invalid parameter: h->service_name is NULL"); + return -1; + } + + *service_name = strdup(h->service_name); + if (*service_name == NULL) { + _E("Failed to duplicate service_name"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_get_service_logo_image_path(rpc_port_autofill_auth_info_h h, char **service_logo_image_path) +{ + if (!h || !service_logo_image_path) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_logo_image_path) { + _E("Invalid parameter: h->service_logo_image_path is NULL"); + return -1; + } + + *service_logo_image_path = strdup(h->service_logo_image_path); + if (*service_logo_image_path == NULL) { + _E("Failed to duplicate service_logo_image_path"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_auth_info_get_service_message(rpc_port_autofill_auth_info_h h, char **service_message) +{ + if (!h || !service_message) { + _E("Invalid parameter"); + return -1; + } + + if (!h->service_message) { + _E("Invalid parameter: h->service_message is NULL"); + return -1; + } + + *service_message = strdup(h->service_message); + if (*service_message == NULL) { + _E("Failed to duplicate service_message"); + return -1; + } + + return 0; +} + +struct autofill_response_item_s { + rpc_port_parcelable_t parcelable; + char *id; + char *presentation_text; + char *value; +}; + +static void __autofill_response_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); + rpc_port_parcel_write_string(parcel, h->presentation_text ? h->presentation_text : ""); + rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); +} + +static void __autofill_response_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->id); + rpc_port_parcel_read_string(parcel, &h->presentation_text); + rpc_port_parcel_read_string(parcel, &h->value); +} + +int rpc_port_autofill_response_item_create(rpc_port_autofill_response_item_h *h) +{ + struct autofill_response_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_response_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_response_item_to; + handle->parcelable.from = __autofill_response_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_response_item_destroy(rpc_port_autofill_response_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) + free(h->id); + + if (h->presentation_text) + free(h->presentation_text); + + if (h->value) + free(h->value); + + free(h); + + return 0; +} + +int rpc_port_autofill_response_item_clone(rpc_port_autofill_response_item_h h, rpc_port_autofill_response_item_h *clone) +{ + rpc_port_autofill_response_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_response_item_create(&handle); + if (!handle) { + _E("Failed to create autofill_response_item handle"); + return -1; + } + + if (h->id) { + handle->id = strdup(h->id); + if (!handle->id) { + _E("Failed to duplicate h->id"); + rpc_port_autofill_response_item_destroy(handle); + return -1; + } + } + + if (h->presentation_text) { + handle->presentation_text = strdup(h->presentation_text); + if (!handle->presentation_text) { + _E("Failed to duplicate h->presentation_text"); + rpc_port_autofill_response_item_destroy(handle); + return -1; + } + } + + if (h->value) { + handle->value = strdup(h->value); + if (!handle->value) { + _E("Failed to duplicate h->value"); + rpc_port_autofill_response_item_destroy(handle); + return -1; + } + } + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_response_item_set_id(rpc_port_autofill_response_item_h h, const char *id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (h->id) { + free(h->id); + h->id = NULL; + } + + h->id = strdup(id); + if (!h->id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_response_item_set_presentation_text(rpc_port_autofill_response_item_h h, const char *presentation_text) +{ + if (!h || !presentation_text) { + _E("Invalid parameter"); + return -1; + } + + if (h->presentation_text) { + free(h->presentation_text); + h->presentation_text = NULL; + } + + h->presentation_text = strdup(presentation_text); + if (!h->presentation_text) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_response_item_set_value(rpc_port_autofill_response_item_h h, const char *value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (h->value) { + free(h->value); + h->value = NULL; + } + + h->value = strdup(value); + if (!h->value) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_response_item_get_id(rpc_port_autofill_response_item_h h, char **id) +{ + if (!h || !id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->id) { + _E("Invalid parameter: h->id is NULL"); + return -1; + } + + *id = strdup(h->id); + if (*id == NULL) { + _E("Failed to duplicate id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_response_item_get_presentation_text(rpc_port_autofill_response_item_h h, char **presentation_text) +{ + if (!h || !presentation_text) { + _E("Invalid parameter"); + return -1; + } + + if (!h->presentation_text) { + _E("Invalid parameter: h->presentation_text is NULL"); + return -1; + } + + *presentation_text = strdup(h->presentation_text); + if (*presentation_text == NULL) { + _E("Failed to duplicate presentation_text"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_response_item_get_value(rpc_port_autofill_response_item_h h, char **value) +{ + if (!h || !value) { + _E("Invalid parameter"); + return -1; + } + + if (!h->value) { + _E("Invalid parameter: h->value is NULL"); + return -1; + } + + *value = strdup(h->value); + if (*value == NULL) { + _E("Failed to duplicate value"); + return -1; + } + + return 0; +} + +struct autofill_response_group_s { + rpc_port_parcelable_t parcelable; + GList *response_items; +}; + +static void __autofill_response_group_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_items)); + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_response_group_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_response_item_h value = NULL; + + rpc_port_autofill_response_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->response_items = g_list_append(h->response_items, value); + } + } while (0); +} + +int rpc_port_autofill_response_group_create(rpc_port_autofill_response_group_h *h) +{ + struct autofill_response_group_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_response_group_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_response_group_to; + handle->parcelable.from = __autofill_response_group_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_response_group_destroy(rpc_port_autofill_response_group_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + if (value) + rpc_port_autofill_response_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->response_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_response_group_clone(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_group_h *clone) +{ + rpc_port_autofill_response_group_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_response_group_create(&handle); + if (!handle) { + _E("Failed to create autofill_response_group handle"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_response_item_h new_value; + rpc_port_autofill_response_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_response_group_destroy(handle); + return -1; + } + + rpc_port_autofill_response_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_response_group_destroy(handle); + return -1; + } + + handle->response_items = g_list_append(handle->response_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_response_group_add_response_items(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_item_h response_items) +{ + if (!h || !response_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_response_item_h value = NULL; + + rpc_port_autofill_response_item_clone(response_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->response_items = g_list_append(h->response_items, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_response_group_foreach_response_items(rpc_port_autofill_response_group_h h, + bool (*callback)(rpc_port_autofill_response_item_h response_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_response_group_remove_response_items(rpc_port_autofill_response_group_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->response_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_response_item_h value = iter->data; + h->response_items = g_list_remove_link(h->response_items, iter); + rpc_port_autofill_response_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_response_group_get_response_items_length(rpc_port_autofill_response_group_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->response_items); + + return 0; +} + +struct autofill_fill_response_s { + rpc_port_parcelable_t parcelable; + char *view_id; + GList *response_groups; +}; + +static void __autofill_fill_response_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_fill_response_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); + rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_groups)); + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __autofill_fill_response_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_autofill_fill_response_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_string(parcel, &h->view_id); + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_response_group_h value = NULL; + + rpc_port_autofill_response_group_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->response_groups = g_list_append(h->response_groups, value); + } + } while (0); +} + +int rpc_port_autofill_fill_response_create(rpc_port_autofill_fill_response_h *h) +{ + struct autofill_fill_response_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct autofill_fill_response_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __autofill_fill_response_to; + handle->parcelable.from = __autofill_fill_response_from; + + *h = handle; + + return 0; +} + +int rpc_port_autofill_fill_response_destroy(rpc_port_autofill_fill_response_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) + free(h->view_id); + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + if (value) + rpc_port_autofill_response_group_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->response_groups); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_autofill_fill_response_clone(rpc_port_autofill_fill_response_h h, rpc_port_autofill_fill_response_h *clone) +{ + rpc_port_autofill_fill_response_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_autofill_fill_response_create(&handle); + if (!handle) { + _E("Failed to create autofill_fill_response handle"); + return -1; + } + + if (h->view_id) { + handle->view_id = strdup(h->view_id); + if (!handle->view_id) { + _E("Failed to duplicate h->view_id"); + rpc_port_autofill_fill_response_destroy(handle); + return -1; + } + } + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_response_group_h new_value; + rpc_port_autofill_response_group_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_autofill_fill_response_destroy(handle); + return -1; + } + + rpc_port_autofill_response_group_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_autofill_fill_response_destroy(handle); + return -1; + } + + handle->response_groups = g_list_append(handle->response_groups, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_autofill_fill_response_set_view_id(rpc_port_autofill_fill_response_h h, const char *view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (h->view_id) { + free(h->view_id); + h->view_id = NULL; + } + + h->view_id = strdup(view_id); + if (!h->view_id) { + _E("Failed to duplicate data"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_fill_response_add_response_groups(rpc_port_autofill_fill_response_h h, rpc_port_autofill_response_group_h response_groups) +{ + if (!h || !response_groups) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_response_group_h value = NULL; + + rpc_port_autofill_response_group_clone(response_groups, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->response_groups = g_list_append(h->response_groups, value); + } while (0); + + return 0; +} + +int rpc_port_autofill_fill_response_get_view_id(rpc_port_autofill_fill_response_h h, char **view_id) +{ + if (!h || !view_id) { + _E("Invalid parameter"); + return -1; + } + + if (!h->view_id) { + _E("Invalid parameter: h->view_id is NULL"); + return -1; + } + + *view_id = strdup(h->view_id); + if (*view_id == NULL) { + _E("Failed to duplicate view_id"); + return -1; + } + + return 0; +} + +int rpc_port_autofill_fill_response_foreach_response_groups(rpc_port_autofill_fill_response_h h, + bool (*callback)(rpc_port_autofill_response_group_h response_groups, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_autofill_fill_response_remove_response_groups(rpc_port_autofill_fill_response_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->response_groups, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_response_group_h value = iter->data; + h->response_groups = g_list_remove_link(h->response_groups, iter); + rpc_port_autofill_response_group_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_autofill_fill_response_get_response_groups_length(rpc_port_autofill_fill_response_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->response_groups); + + return 0; +} + +struct list_autofill_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_items; +}; + +static void __list_autofill_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_items)); + do { + GList *iter; + + iter = h->list_autofill_items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_item_h value = NULL; + + rpc_port_autofill_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_items = g_list_append(h->list_autofill_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_item_create(rpc_port_list_autofill_item_h *h) +{ + struct list_autofill_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_item_to; + handle->parcelable.from = __list_autofill_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_item_destroy(rpc_port_list_autofill_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + if (value) + rpc_port_autofill_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_item_clone(rpc_port_list_autofill_item_h h, rpc_port_list_autofill_item_h *clone) +{ + rpc_port_list_autofill_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_items; + while (iter) { + rpc_port_autofill_item_h new_value; + rpc_port_autofill_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_item_destroy(handle); + return -1; + } + + rpc_port_autofill_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_item_destroy(handle); + return -1; + } + + handle->list_autofill_items = g_list_append(handle->list_autofill_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_item_add_list_autofill_items(rpc_port_list_autofill_item_h h, rpc_port_autofill_item_h list_autofill_items) +{ + if (!h || !list_autofill_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_item_h value = NULL; + + rpc_port_autofill_item_clone(list_autofill_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_items = g_list_append(h->list_autofill_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_item_foreach_list_autofill_items(rpc_port_list_autofill_item_h h, + bool (*callback)(rpc_port_autofill_item_h list_autofill_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_items; + while (iter) { + rpc_port_autofill_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_item_remove_list_autofill_items(rpc_port_list_autofill_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_item_h value = iter->data; + h->list_autofill_items = g_list_remove_link(h->list_autofill_items, iter); + rpc_port_autofill_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_item_get_list_autofill_items_length(rpc_port_list_autofill_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_items); + + return 0; +} + +struct list_autofill_response_group_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_response_groups; +}; + +static void __list_autofill_response_group_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_response_groups)); + do { + GList *iter; + + iter = h->list_autofill_response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_response_group_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_response_group_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_response_group_h value = NULL; + + rpc_port_autofill_response_group_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_response_groups = g_list_append(h->list_autofill_response_groups, value); + } + } while (0); +} + +int rpc_port_list_autofill_response_group_create(rpc_port_list_autofill_response_group_h *h) +{ + struct list_autofill_response_group_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_response_group_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_response_group_to; + handle->parcelable.from = __list_autofill_response_group_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_response_group_destroy(rpc_port_list_autofill_response_group_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + if (value) + rpc_port_autofill_response_group_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_response_groups); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_response_group_clone(rpc_port_list_autofill_response_group_h h, rpc_port_list_autofill_response_group_h *clone) +{ + rpc_port_list_autofill_response_group_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_response_group_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_response_group handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_groups; + while (iter) { + rpc_port_autofill_response_group_h new_value; + rpc_port_autofill_response_group_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_response_group_destroy(handle); + return -1; + } + + rpc_port_autofill_response_group_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_response_group_destroy(handle); + return -1; + } + + handle->list_autofill_response_groups = g_list_append(handle->list_autofill_response_groups, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_response_group_add_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, rpc_port_autofill_response_group_h list_autofill_response_groups) +{ + if (!h || !list_autofill_response_groups) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_response_group_h value = NULL; + + rpc_port_autofill_response_group_clone(list_autofill_response_groups, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_response_groups = g_list_append(h->list_autofill_response_groups, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_response_group_foreach_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, + bool (*callback)(rpc_port_autofill_response_group_h list_autofill_response_groups, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_groups; + while (iter) { + rpc_port_autofill_response_group_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_response_group_remove_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_response_groups, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_response_group_h value = iter->data; + h->list_autofill_response_groups = g_list_remove_link(h->list_autofill_response_groups, iter); + rpc_port_autofill_response_group_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_response_group_get_list_autofill_response_groups_length(rpc_port_list_autofill_response_group_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_response_groups); + + return 0; +} + +struct list_autofill_response_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_response_items; +}; + +static void __list_autofill_response_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_response_items)); + do { + GList *iter; + + iter = h->list_autofill_response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_response_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_response_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_response_item_h value = NULL; + + rpc_port_autofill_response_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_response_items = g_list_append(h->list_autofill_response_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_response_item_create(rpc_port_list_autofill_response_item_h *h) +{ + struct list_autofill_response_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_response_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_response_item_to; + handle->parcelable.from = __list_autofill_response_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_response_item_destroy(rpc_port_list_autofill_response_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + if (value) + rpc_port_autofill_response_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_response_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_response_item_clone(rpc_port_list_autofill_response_item_h h, rpc_port_list_autofill_response_item_h *clone) +{ + rpc_port_list_autofill_response_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_response_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_response_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_items; + while (iter) { + rpc_port_autofill_response_item_h new_value; + rpc_port_autofill_response_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_response_item_destroy(handle); + return -1; + } + + rpc_port_autofill_response_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_response_item_destroy(handle); + return -1; + } + + handle->list_autofill_response_items = g_list_append(handle->list_autofill_response_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_response_item_add_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, rpc_port_autofill_response_item_h list_autofill_response_items) +{ + if (!h || !list_autofill_response_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_response_item_h value = NULL; + + rpc_port_autofill_response_item_clone(list_autofill_response_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_response_items = g_list_append(h->list_autofill_response_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_response_item_foreach_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, + bool (*callback)(rpc_port_autofill_response_item_h list_autofill_response_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_response_items; + while (iter) { + rpc_port_autofill_response_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_response_item_remove_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_response_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_response_item_h value = iter->data; + h->list_autofill_response_items = g_list_remove_link(h->list_autofill_response_items, iter); + rpc_port_autofill_response_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_response_item_get_list_autofill_response_items_length(rpc_port_list_autofill_response_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_response_items); + + return 0; +} + +struct list_autofill_save_item_s { + rpc_port_parcelable_t parcelable; + GList *list_autofill_save_items; +}; + +static void __list_autofill_save_item_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_save_items)); + do { + GList *iter; + + iter = h->list_autofill_save_items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + rpc_port_parcel_write(parcel, &value->parcelable, value); + } + } while (0); +} + +static void __list_autofill_save_item_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_list_autofill_save_item_h h = data; + + if (!parcel || !h) { + _E("Invalid parameter"); + return; + } + + do { + int len = 0; + + rpc_port_parcel_read_array_count(parcel, &len); + for (int i = 0; i < len; i++) { + rpc_port_autofill_save_item_h value = NULL; + + rpc_port_autofill_save_item_create(&value); + if (!value) { + _E("Failed to create handle"); + return; + } + + rpc_port_parcel_read(parcel, &value->parcelable, value); + h->list_autofill_save_items = g_list_append(h->list_autofill_save_items, value); + } + } while (0); +} + +int rpc_port_list_autofill_save_item_create(rpc_port_list_autofill_save_item_h *h) +{ + struct list_autofill_save_item_s *handle; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct list_autofill_save_item_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __list_autofill_save_item_to; + handle->parcelable.from = __list_autofill_save_item_from; + + *h = handle; + + return 0; +} + +int rpc_port_list_autofill_save_item_destroy(rpc_port_list_autofill_save_item_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_save_items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + if (value) + rpc_port_autofill_save_item_destroy(value); + + iter = g_list_next(iter); + } + g_list_free(h->list_autofill_save_items); + } while (0); + + free(h); + + return 0; +} + +int rpc_port_list_autofill_save_item_clone(rpc_port_list_autofill_save_item_h h, rpc_port_list_autofill_save_item_h *clone) +{ + rpc_port_list_autofill_save_item_h handle = NULL; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + rpc_port_list_autofill_save_item_create(&handle); + if (!handle) { + _E("Failed to create list_autofill_save_item handle"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_save_items; + while (iter) { + rpc_port_autofill_save_item_h new_value; + rpc_port_autofill_save_item_h value = iter->data; + + if (!value) { + _E("Error: value is NULL"); + rpc_port_list_autofill_save_item_destroy(handle); + return -1; + } + + rpc_port_autofill_save_item_clone(value, &new_value); + if (!new_value) { + _E("Failed to duplicate value"); + rpc_port_list_autofill_save_item_destroy(handle); + return -1; + } + + handle->list_autofill_save_items = g_list_append(handle->list_autofill_save_items, new_value); + iter = g_list_next(iter); + } + } while (0); + + *clone = handle; + + return 0; +} + +int rpc_port_list_autofill_save_item_add_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, rpc_port_autofill_save_item_h list_autofill_save_items) +{ + if (!h || !list_autofill_save_items) { + _E("Invalid parameter"); + return -1; + } + + do { + rpc_port_autofill_save_item_h value = NULL; + + rpc_port_autofill_save_item_clone(list_autofill_save_items, &value); + if (!value) { + _E("Out of memory"); + return -1; + } + + h->list_autofill_save_items = g_list_append(h->list_autofill_save_items, value); + } while (0); + + return 0; +} + +int rpc_port_list_autofill_save_item_foreach_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, + bool (*callback)(rpc_port_autofill_save_item_h list_autofill_save_items, void *user_data), void *user_data) +{ + if (!h || !callback) { + _E("Invalid parameter"); + return -1; + } + + do { + GList *iter; + + iter = h->list_autofill_save_items; + while (iter) { + rpc_port_autofill_save_item_h value = iter->data; + + iter = g_list_next(iter); + if (!value) { + _W("Warning: value is NULL"); + continue; + } + + bool ret = callback(value, user_data); + if (!ret) + break; + } + } while (0); + + return 0; +} + +int rpc_port_list_autofill_save_item_remove_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, unsigned int nth) +{ + GList *iter; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + iter = g_list_nth(h->list_autofill_save_items, nth); + if (iter == NULL) + return -1; + + rpc_port_autofill_save_item_h value = iter->data; + h->list_autofill_save_items = g_list_remove_link(h->list_autofill_save_items, iter); + rpc_port_autofill_save_item_destroy(value); + g_list_free(iter); + + return 0; +} + +int rpc_port_list_autofill_save_item_get_list_autofill_save_items_length(rpc_port_list_autofill_save_item_h h, unsigned int *length) +{ + if (!h || !length) { + _E("Invalid parameter"); + return -1; + } + + *length = g_list_length(h->list_autofill_save_items); + + return 0; +} + +enum AutofillAppPort_method_e { + AutofillAppPort_METHOD_Result, + AutofillAppPort_METHOD_Callback, + AutofillAppPort_METHOD_Register, + AutofillAppPort_METHOD_Unregister, + AutofillAppPort_METHOD_request_auth_info, + AutofillAppPort_METHOD_send_fill_request, + AutofillAppPort_METHOD_commit, +}; + +enum AutofillAppPort_delegate_e { + AutofillAppPort_DELEGATE_autofill_auth_info_received_cb = 1, + AutofillAppPort_DELEGATE_autofill_fill_response_received_cb = 2, +}; + +static rpc_port_stub_h __AutofillAppPort_stub; +static rpc_port_stub_AutofillAppPort_callback_s __AutofillAppPort_callback; +static void *__AutofillAppPort_user_data; +static GList *__AutofillAppPort_contexts; + +struct AutofillAppPort_context_s { + char *sender; + char *instance; + rpc_port_h port; + void *tag; + rpc_port_stub_AutofillAppPort_callback_s callback; + void *user_data; +}; + +static struct AutofillAppPort_context_s *__create_AutofillAppPort_context(const char *sender, const char *instance) +{ + struct AutofillAppPort_context_s *handle; + + handle = calloc(1, sizeof(struct AutofillAppPort_context_s)); + if (!handle) { + _E("Out of memory"); + return NULL; + } + + handle->sender = strdup(sender); + if (!handle->sender) { + _E("Out of memory"); + free(handle); + return NULL; + } + + handle->instance = strdup(instance); + if (!handle->instance) { + _E("Out of memory"); + free(handle->sender); + free(handle); + return NULL; + } + + handle->callback = __AutofillAppPort_callback; + handle->user_data = __AutofillAppPort_user_data; + + return handle; +} + +static void __destroy_AutofillAppPort_context(gpointer data) +{ + struct AutofillAppPort_context_s *handle = data; + + if (!handle) { + _E("Critical error!"); + return; + } + + free(handle->instance); + free(handle->sender); + free(handle); +} + +static struct AutofillAppPort_context_s *__find_AutofillAppPort_context(const char *instance) +{ + struct AutofillAppPort_context_s *handle; + GList *iter; + + iter = __AutofillAppPort_contexts; + while (iter) { + handle = (struct AutofillAppPort_context_s *)iter->data; + if (!strcmp(handle->instance, instance)) + return handle; + iter = g_list_next(iter); + } + + return NULL; +} + +int rpc_port_stub_AutofillAppPort_context_set_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void *tag) +{ + if (!ctx) { + _E("Invalid parameter"); + return -1; + } + + ctx->tag = tag; + + return 0; +} + +int rpc_port_stub_AutofillAppPort_context_get_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void **tag) +{ + if (!ctx || !tag) { + _E("Invalid parameter"); + return -1; + } + + *tag = ctx->tag; + + return 0; +} + +int rpc_port_stub_AutofillAppPort_context_get_sender(rpc_port_stub_AutofillAppPort_context_h ctx, char **sender) +{ + if (!ctx || !sender) { + _E("Invalid parameter"); + return -1; + } + + *sender = strdup(ctx->sender); + if (*sender == NULL) { + _E("Out of memory"); + return -1; + } + + return 0; +} + +struct AutofillAppPort_autofill_auth_info_received_cb_s { + rpc_port_parcelable_t parcelable; + rpc_port_h port; + int id; + int seq_id; + bool once; + bool valid; +}; + +static void __AutofillAppPort_autofill_auth_info_received_cb_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, handle->id); + rpc_port_parcel_write_int32(parcel, handle->seq_id); + rpc_port_parcel_write_bool(parcel, handle->once); +} + +static void __AutofillAppPort_autofill_auth_info_received_cb_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_int32(parcel, &handle->id); + rpc_port_parcel_read_int32(parcel, &handle->seq_id); + rpc_port_parcel_read_bool(parcel, &handle->once); +} + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_create(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *h) +{ + struct AutofillAppPort_autofill_auth_info_received_cb_s *handle; + static int seq_num; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct AutofillAppPort_autofill_auth_info_received_cb_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __AutofillAppPort_autofill_auth_info_received_cb_to; + handle->parcelable.from = __AutofillAppPort_autofill_auth_info_received_cb_from; + handle->id = AutofillAppPort_DELEGATE_autofill_auth_info_received_cb; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->once = false; + handle->valid = true; + + *h = handle; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + free(h); + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_clone(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *clone) +{ + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct AutofillAppPort_autofill_auth_info_received_cb_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable = h->parcelable; + handle->port = h->port; + handle->id = h->id; + handle->seq_id = h->seq_id; + handle->once = h->once; + handle->valid = h->valid; + + *clone = handle; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_autofill_auth_info_h auth_info) +{ + rpc_port_parcel_h parcel = NULL; + + if (!h || !h->port) { + _E("Invalid parameter"); + return -1; + } + + if (h->once && !h->valid) { + _E("Invalid callback"); + return -1; + } + + rpc_port_parcel_create(&parcel); + if (!parcel) { + _E("Failed to create parcel"); + return -1; + } + + rpc_port_parcel_write_int32(parcel, AutofillAppPort_METHOD_Callback); + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_write(parcel, &auth_info->parcelable, auth_info); + + rpc_port_parcel_send(parcel, h->port); + rpc_port_parcel_destroy(parcel); + h->valid = false; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_set_port(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_h port) +{ + if (!h || !port) { + _E("Invalid parameter"); + return -1; + } + + h->port = port; + + return 0; +} + +struct AutofillAppPort_autofill_fill_response_received_cb_s { + rpc_port_parcelable_t parcelable; + rpc_port_h port; + int id; + int seq_id; + bool once; + bool valid; +}; + +static void __AutofillAppPort_autofill_fill_response_received_cb_to(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_write_int32(parcel, handle->id); + rpc_port_parcel_write_int32(parcel, handle->seq_id); + rpc_port_parcel_write_bool(parcel, handle->once); +} + +static void __AutofillAppPort_autofill_fill_response_received_cb_from(rpc_port_parcel_h parcel, void *data) +{ + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle = data; + + if (!handle) { + _E("Invalid parameter"); + return; + } + + rpc_port_parcel_read_int32(parcel, &handle->id); + rpc_port_parcel_read_int32(parcel, &handle->seq_id); + rpc_port_parcel_read_bool(parcel, &handle->once); +} + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_create(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *h) +{ + struct AutofillAppPort_autofill_fill_response_received_cb_s *handle; + static int seq_num; + + if (!h) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct AutofillAppPort_autofill_fill_response_received_cb_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable.to = __AutofillAppPort_autofill_fill_response_received_cb_to; + handle->parcelable.from = __AutofillAppPort_autofill_fill_response_received_cb_from; + handle->id = AutofillAppPort_DELEGATE_autofill_fill_response_received_cb; + handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; + handle->once = false; + handle->valid = true; + + *h = handle; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h) +{ + if (!h) { + _E("Invalid parameter"); + return -1; + } + + free(h); + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_clone(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *clone) +{ + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle; + + if (!h || !clone) { + _E("Invalid parameter"); + return -1; + } + + handle = calloc(1, sizeof(struct AutofillAppPort_autofill_fill_response_received_cb_s)); + if (!handle) { + _E("Out of memory"); + return -1; + } + + handle->parcelable = h->parcelable; + handle->port = h->port; + handle->id = h->id; + handle->seq_id = h->seq_id; + handle->once = h->once; + handle->valid = h->valid; + + *clone = handle; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_autofill_fill_response_h response) +{ + rpc_port_parcel_h parcel = NULL; + + if (!h || !h->port) { + _E("Invalid parameter"); + return -1; + } + + if (h->once && !h->valid) { + _E("Invalid callback"); + return -1; + } + + rpc_port_parcel_create(&parcel); + if (!parcel) { + _E("Failed to create parcel"); + return -1; + } + + rpc_port_parcel_write_int32(parcel, AutofillAppPort_METHOD_Callback); + rpc_port_parcel_write(parcel, &h->parcelable, h); + rpc_port_parcel_write(parcel, &response->parcelable, response); + + rpc_port_parcel_send(parcel, h->port); + rpc_port_parcel_destroy(parcel); + h->valid = false; + + return 0; +} + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_set_port(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_h port) +{ + if (!h || !port) { + _E("Invalid parameter"); + return -1; + } + + h->port = port; + + return 0; +} + +static int __AutofillAppPort_method_Register(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + int context_id; + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb = NULL; + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_cb = NULL; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_create(&auth_info_cb); + + if (!auth_info_cb) { + _E("Failed to create handle"); + return -1; + } + + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_set_port(auth_info_cb, callback_port); + rpc_port_parcel_read(parcel, &auth_info_cb->parcelable, auth_info_cb); + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_create(&fill_response_cb); + + if (!fill_response_cb) { + _E("Failed to create handle"); + return -1; + } + + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_set_port(fill_response_cb, callback_port); + rpc_port_parcel_read(parcel, &fill_response_cb->parcelable, fill_response_cb); + + int ret = context->callback.Register(context, context_id, auth_info_cb, fill_response_cb, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); + rpc_port_parcel_write_int32(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(auth_info_cb); + rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(fill_response_cb); + return 0; +} + +static int __AutofillAppPort_method_Unregister(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + int context_id; + + rpc_port_parcel_read_int32(parcel, &context_id); + + context->callback.Unregister(context, context_id, context->user_data); + + return 0; +} + +static int __AutofillAppPort_method_request_auth_info(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + int context_id; + rpc_port_autofill_view_info_h vi = NULL; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_autofill_view_info_create(&vi); + rpc_port_parcel_read(parcel, &vi->parcelable, vi); + + int ret = context->callback.request_auth_info(context, context_id, vi, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); + rpc_port_parcel_write_int32(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + rpc_port_autofill_view_info_destroy(vi); + return 0; +} + +static int __AutofillAppPort_method_send_fill_request(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + int context_id; + rpc_port_autofill_view_info_h vi = NULL; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_autofill_view_info_create(&vi); + rpc_port_parcel_read(parcel, &vi->parcelable, vi); + + int ret = context->callback.send_fill_request(context, context_id, vi, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); + rpc_port_parcel_write_int32(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + rpc_port_autofill_view_info_destroy(vi); + return 0; +} + +static int __AutofillAppPort_method_commit(rpc_port_h port, rpc_port_parcel_h parcel, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context = data; + rpc_port_h callback_port; + int r; + + r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); + if (r != 0) { + _E("Failed to get callback port"); + return -1; + } + + int context_id; + rpc_port_autofill_save_view_info_h vi = NULL; + + rpc_port_parcel_read_int32(parcel, &context_id); + rpc_port_autofill_save_view_info_create(&vi); + rpc_port_parcel_read(parcel, &vi->parcelable, vi); + + int ret = context->callback.commit(context, context_id, vi, context->user_data); + do { + rpc_port_parcel_h result; + + rpc_port_parcel_create(&result); + rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); + rpc_port_parcel_write_int32(result, ret); + rpc_port_parcel_send(result, port); + rpc_port_parcel_destroy(result); + } while (0); + + rpc_port_autofill_save_view_info_destroy(vi); + return 0; +} + +static stub_method __AutofillAppPort_method_table[] = { + [AutofillAppPort_METHOD_Register] = __AutofillAppPort_method_Register, + [AutofillAppPort_METHOD_Unregister] = __AutofillAppPort_method_Unregister, + [AutofillAppPort_METHOD_request_auth_info] = __AutofillAppPort_method_request_auth_info, + [AutofillAppPort_METHOD_send_fill_request] = __AutofillAppPort_method_send_fill_request, + [AutofillAppPort_METHOD_commit] = __AutofillAppPort_method_commit, +}; + +static void __AutofillAppPort_on_connected(const char *sender, const char *instance, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __create_AutofillAppPort_context(sender, instance); + if (!context) + return; + + if (context->callback.create) + context->callback.create(context, context->user_data); + __AutofillAppPort_contexts = g_list_append(__AutofillAppPort_contexts, context); +} + +static void __AutofillAppPort_on_disconnected(const char *sender, const char *instance, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __find_AutofillAppPort_context(instance); + if (!context) + return; + + if (context->callback.terminate) + context->callback.terminate(context, context->user_data); + __AutofillAppPort_contexts = g_list_remove(__AutofillAppPort_contexts, context); + __destroy_AutofillAppPort_context(context); +} + +static int __AutofillAppPort_on_received(const char *sender, const char *instance, rpc_port_h port, void *data) +{ + rpc_port_stub_AutofillAppPort_context_h context; + rpc_port_parcel_h parcel; + int cmd = -1; + int r; + + _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); + context = __find_AutofillAppPort_context(instance); + if (!context) { + _E("Failed to find AutofillAppPort context(%s)", instance); + return -1; + } + + context->port = port; + r = rpc_port_parcel_create_from_port(&parcel, port); + if (r != 0) { + _E("Failed to create parcel from port"); + return r; + } + + rpc_port_parcel_read_int32(parcel, &cmd); + if (cmd > 1 && cmd < (sizeof(__AutofillAppPort_method_table) / sizeof(__AutofillAppPort_method_table[0]))) { + if (__AutofillAppPort_method_table[cmd]) + r = __AutofillAppPort_method_table[cmd](port, parcel, context); + } else { + _E("Unknown Command(%d)", cmd); + r = -1; + } + + rpc_port_parcel_destroy(parcel); + + return r; +} + +static int __AutofillAppPort_add_privileges(void) +{ + + return 0; +} + +int rpc_port_stub_AutofillAppPort_register(rpc_port_stub_AutofillAppPort_callback_s *callback, void *user_data) +{ + int r; + + if (__AutofillAppPort_stub) { + _W("Already exists"); + return -1; + } + + if (!callback) { + _E("Invalid parameter"); + return -1; + } + + __AutofillAppPort_callback = *callback; + __AutofillAppPort_user_data = user_data; + r = rpc_port_stub_create(&__AutofillAppPort_stub, "AutofillAppPort"); + if (r != 0) { + _E("Failed to create stub handle"); + return r; + } + + r = rpc_port_stub_add_received_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_received, NULL); + if (r != 0) { + _E("Failed to add received event callback"); + rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + return r; + } + + r = rpc_port_stub_add_connected_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_connected, NULL); + if (r != 0) { + _E("Failed to add connected event callback"); + rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + return r; + } + + r = rpc_port_stub_add_disconnected_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_disconnected, NULL); + if (r != 0) { + _E("Failed to add disconnected event callback"); + rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + return r; + } + + r = __AutofillAppPort_add_privileges(); + if (r != 0) { + _E("Failed to add privileges"); + rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + return r; + } + + r = rpc_port_stub_listen(__AutofillAppPort_stub); + if (r != 0) { + _E("Failed to listen stub"); + rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + return r; + } + + return 0; +} + +int rpc_port_stub_AutofillAppPort_unregister(void) +{ + int r; + + if (!__AutofillAppPort_stub) + return -1; + + if (__AutofillAppPort_contexts) { + g_list_free_full(__AutofillAppPort_contexts, __destroy_AutofillAppPort_context); + __AutofillAppPort_contexts = NULL; + } + + r = rpc_port_stub_destroy(__AutofillAppPort_stub); + __AutofillAppPort_stub = NULL; + + return r; +} + +int rpc_port_stub_AutofillAppPort_get_client_number(unsigned int *n) +{ + if (!n) { + _E("Invalid parameter"); + return -1; + } + + if (!__AutofillAppPort_stub) { + _E("AutofillAppPort Stub is not ready"); + return -1; + } + + *n = g_list_length(__AutofillAppPort_contexts); + + return 0; +} diff --git a/src/autofill_stub.h b/src/autofill_stub.h new file mode 100644 index 0000000..9a3682c --- /dev/null +++ b/src/autofill_stub.h @@ -0,0 +1,327 @@ +/* + * Generated by tidlc 1.3.2. + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct autofill_item_s *rpc_port_autofill_item_h; + +int rpc_port_autofill_item_create(rpc_port_autofill_item_h *h); + +int rpc_port_autofill_item_destroy(rpc_port_autofill_item_h h); + +int rpc_port_autofill_item_clone(rpc_port_autofill_item_h h, rpc_port_autofill_item_h *clone); + +int rpc_port_autofill_item_set_id(rpc_port_autofill_item_h h, const char *id); + +int rpc_port_autofill_item_set_label(rpc_port_autofill_item_h h, const char *label); + +int rpc_port_autofill_item_set_value(rpc_port_autofill_item_h h, const char *value); + +int rpc_port_autofill_item_set_autofill_hint(rpc_port_autofill_item_h h, int autofill_hint); + +int rpc_port_autofill_item_set_is_sensitive_data(rpc_port_autofill_item_h h, bool is_sensitive_data); + +int rpc_port_autofill_item_get_id(rpc_port_autofill_item_h h, char **id); + +int rpc_port_autofill_item_get_label(rpc_port_autofill_item_h h, char **label); + +int rpc_port_autofill_item_get_value(rpc_port_autofill_item_h h, char **value); + +int rpc_port_autofill_item_get_autofill_hint(rpc_port_autofill_item_h h, int *autofill_hint); + +int rpc_port_autofill_item_get_is_sensitive_data(rpc_port_autofill_item_h h, bool *is_sensitive_data); + +typedef struct autofill_view_info_s *rpc_port_autofill_view_info_h; + +int rpc_port_autofill_view_info_create(rpc_port_autofill_view_info_h *h); + +int rpc_port_autofill_view_info_destroy(rpc_port_autofill_view_info_h h); + +int rpc_port_autofill_view_info_clone(rpc_port_autofill_view_info_h h, rpc_port_autofill_view_info_h *clone); + +int rpc_port_autofill_view_info_set_view_id(rpc_port_autofill_view_info_h h, const char *view_id); + +int rpc_port_autofill_view_info_add_items(rpc_port_autofill_view_info_h h, rpc_port_autofill_item_h items); + +int rpc_port_autofill_view_info_get_view_id(rpc_port_autofill_view_info_h h, char **view_id); + +int rpc_port_autofill_view_info_foreach_items(rpc_port_autofill_view_info_h h, + bool (*callback)(rpc_port_autofill_item_h items, void *user_data), void *user_data); + +int rpc_port_autofill_view_info_remove_items(rpc_port_autofill_view_info_h h, unsigned int nth); + +int rpc_port_autofill_view_info_get_items_length(rpc_port_autofill_view_info_h h, unsigned int *length); + +typedef struct autofill_save_item_s *rpc_port_autofill_save_item_h; + +int rpc_port_autofill_save_item_create(rpc_port_autofill_save_item_h *h); + +int rpc_port_autofill_save_item_destroy(rpc_port_autofill_save_item_h h); + +int rpc_port_autofill_save_item_clone(rpc_port_autofill_save_item_h h, rpc_port_autofill_save_item_h *clone); + +int rpc_port_autofill_save_item_set_id(rpc_port_autofill_save_item_h h, const char *id); + +int rpc_port_autofill_save_item_set_label(rpc_port_autofill_save_item_h h, const char *label); + +int rpc_port_autofill_save_item_set_value(rpc_port_autofill_save_item_h h, const char *value); + +int rpc_port_autofill_save_item_set_autofill_hint(rpc_port_autofill_save_item_h h, int autofill_hint); + +int rpc_port_autofill_save_item_set_is_sensitive_data(rpc_port_autofill_save_item_h h, bool is_sensitive_data); + +int rpc_port_autofill_save_item_get_id(rpc_port_autofill_save_item_h h, char **id); + +int rpc_port_autofill_save_item_get_label(rpc_port_autofill_save_item_h h, char **label); + +int rpc_port_autofill_save_item_get_value(rpc_port_autofill_save_item_h h, char **value); + +int rpc_port_autofill_save_item_get_autofill_hint(rpc_port_autofill_save_item_h h, int *autofill_hint); + +int rpc_port_autofill_save_item_get_is_sensitive_data(rpc_port_autofill_save_item_h h, bool *is_sensitive_data); + +typedef struct autofill_save_view_info_s *rpc_port_autofill_save_view_info_h; + +int rpc_port_autofill_save_view_info_create(rpc_port_autofill_save_view_info_h *h); + +int rpc_port_autofill_save_view_info_destroy(rpc_port_autofill_save_view_info_h h); + +int rpc_port_autofill_save_view_info_clone(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_view_info_h *clone); + +int rpc_port_autofill_save_view_info_set_view_id(rpc_port_autofill_save_view_info_h h, const char *view_id); + +int rpc_port_autofill_save_view_info_add_items(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_item_h items); + +int rpc_port_autofill_save_view_info_get_view_id(rpc_port_autofill_save_view_info_h h, char **view_id); + +int rpc_port_autofill_save_view_info_foreach_items(rpc_port_autofill_save_view_info_h h, + bool (*callback)(rpc_port_autofill_save_item_h items, void *user_data), void *user_data); + +int rpc_port_autofill_save_view_info_remove_items(rpc_port_autofill_save_view_info_h h, unsigned int nth); + +int rpc_port_autofill_save_view_info_get_items_length(rpc_port_autofill_save_view_info_h h, unsigned int *length); + +typedef struct autofill_auth_info_s *rpc_port_autofill_auth_info_h; + +int rpc_port_autofill_auth_info_create(rpc_port_autofill_auth_info_h *h); + +int rpc_port_autofill_auth_info_destroy(rpc_port_autofill_auth_info_h h); + +int rpc_port_autofill_auth_info_clone(rpc_port_autofill_auth_info_h h, rpc_port_autofill_auth_info_h *clone); + +int rpc_port_autofill_auth_info_set_view_id(rpc_port_autofill_auth_info_h h, const char *view_id); + +int rpc_port_autofill_auth_info_set_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool exist_autofill_data); + +int rpc_port_autofill_auth_info_set_need_authentication(rpc_port_autofill_auth_info_h h, bool need_authentication); + +int rpc_port_autofill_auth_info_set_service_name(rpc_port_autofill_auth_info_h h, const char *service_name); + +int rpc_port_autofill_auth_info_set_service_logo_image_path(rpc_port_autofill_auth_info_h h, const char *service_logo_image_path); + +int rpc_port_autofill_auth_info_set_service_message(rpc_port_autofill_auth_info_h h, const char *service_message); + +int rpc_port_autofill_auth_info_get_view_id(rpc_port_autofill_auth_info_h h, char **view_id); + +int rpc_port_autofill_auth_info_get_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool *exist_autofill_data); + +int rpc_port_autofill_auth_info_get_need_authentication(rpc_port_autofill_auth_info_h h, bool *need_authentication); + +int rpc_port_autofill_auth_info_get_service_name(rpc_port_autofill_auth_info_h h, char **service_name); + +int rpc_port_autofill_auth_info_get_service_logo_image_path(rpc_port_autofill_auth_info_h h, char **service_logo_image_path); + +int rpc_port_autofill_auth_info_get_service_message(rpc_port_autofill_auth_info_h h, char **service_message); + +typedef struct autofill_response_item_s *rpc_port_autofill_response_item_h; + +int rpc_port_autofill_response_item_create(rpc_port_autofill_response_item_h *h); + +int rpc_port_autofill_response_item_destroy(rpc_port_autofill_response_item_h h); + +int rpc_port_autofill_response_item_clone(rpc_port_autofill_response_item_h h, rpc_port_autofill_response_item_h *clone); + +int rpc_port_autofill_response_item_set_id(rpc_port_autofill_response_item_h h, const char *id); + +int rpc_port_autofill_response_item_set_presentation_text(rpc_port_autofill_response_item_h h, const char *presentation_text); + +int rpc_port_autofill_response_item_set_value(rpc_port_autofill_response_item_h h, const char *value); + +int rpc_port_autofill_response_item_get_id(rpc_port_autofill_response_item_h h, char **id); + +int rpc_port_autofill_response_item_get_presentation_text(rpc_port_autofill_response_item_h h, char **presentation_text); + +int rpc_port_autofill_response_item_get_value(rpc_port_autofill_response_item_h h, char **value); + +typedef struct autofill_response_group_s *rpc_port_autofill_response_group_h; + +int rpc_port_autofill_response_group_create(rpc_port_autofill_response_group_h *h); + +int rpc_port_autofill_response_group_destroy(rpc_port_autofill_response_group_h h); + +int rpc_port_autofill_response_group_clone(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_group_h *clone); + +int rpc_port_autofill_response_group_add_response_items(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_item_h response_items); + +int rpc_port_autofill_response_group_foreach_response_items(rpc_port_autofill_response_group_h h, + bool (*callback)(rpc_port_autofill_response_item_h response_items, void *user_data), void *user_data); + +int rpc_port_autofill_response_group_remove_response_items(rpc_port_autofill_response_group_h h, unsigned int nth); + +int rpc_port_autofill_response_group_get_response_items_length(rpc_port_autofill_response_group_h h, unsigned int *length); + +typedef struct autofill_fill_response_s *rpc_port_autofill_fill_response_h; + +int rpc_port_autofill_fill_response_create(rpc_port_autofill_fill_response_h *h); + +int rpc_port_autofill_fill_response_destroy(rpc_port_autofill_fill_response_h h); + +int rpc_port_autofill_fill_response_clone(rpc_port_autofill_fill_response_h h, rpc_port_autofill_fill_response_h *clone); + +int rpc_port_autofill_fill_response_set_view_id(rpc_port_autofill_fill_response_h h, const char *view_id); + +int rpc_port_autofill_fill_response_add_response_groups(rpc_port_autofill_fill_response_h h, rpc_port_autofill_response_group_h response_groups); + +int rpc_port_autofill_fill_response_get_view_id(rpc_port_autofill_fill_response_h h, char **view_id); + +int rpc_port_autofill_fill_response_foreach_response_groups(rpc_port_autofill_fill_response_h h, + bool (*callback)(rpc_port_autofill_response_group_h response_groups, void *user_data), void *user_data); + +int rpc_port_autofill_fill_response_remove_response_groups(rpc_port_autofill_fill_response_h h, unsigned int nth); + +int rpc_port_autofill_fill_response_get_response_groups_length(rpc_port_autofill_fill_response_h h, unsigned int *length); + +typedef struct list_autofill_item_s *rpc_port_list_autofill_item_h; + +int rpc_port_list_autofill_item_create(rpc_port_list_autofill_item_h *h); + +int rpc_port_list_autofill_item_destroy(rpc_port_list_autofill_item_h h); + +int rpc_port_list_autofill_item_clone(rpc_port_list_autofill_item_h h, rpc_port_list_autofill_item_h *clone); + +int rpc_port_list_autofill_item_add_list_autofill_items(rpc_port_list_autofill_item_h h, rpc_port_autofill_item_h list_autofill_items); + +int rpc_port_list_autofill_item_foreach_list_autofill_items(rpc_port_list_autofill_item_h h, + bool (*callback)(rpc_port_autofill_item_h list_autofill_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_item_remove_list_autofill_items(rpc_port_list_autofill_item_h h, unsigned int nth); + +int rpc_port_list_autofill_item_get_list_autofill_items_length(rpc_port_list_autofill_item_h h, unsigned int *length); + +typedef struct list_autofill_response_group_s *rpc_port_list_autofill_response_group_h; + +int rpc_port_list_autofill_response_group_create(rpc_port_list_autofill_response_group_h *h); + +int rpc_port_list_autofill_response_group_destroy(rpc_port_list_autofill_response_group_h h); + +int rpc_port_list_autofill_response_group_clone(rpc_port_list_autofill_response_group_h h, rpc_port_list_autofill_response_group_h *clone); + +int rpc_port_list_autofill_response_group_add_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, rpc_port_autofill_response_group_h list_autofill_response_groups); + +int rpc_port_list_autofill_response_group_foreach_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, + bool (*callback)(rpc_port_autofill_response_group_h list_autofill_response_groups, void *user_data), void *user_data); + +int rpc_port_list_autofill_response_group_remove_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, unsigned int nth); + +int rpc_port_list_autofill_response_group_get_list_autofill_response_groups_length(rpc_port_list_autofill_response_group_h h, unsigned int *length); + +typedef struct list_autofill_response_item_s *rpc_port_list_autofill_response_item_h; + +int rpc_port_list_autofill_response_item_create(rpc_port_list_autofill_response_item_h *h); + +int rpc_port_list_autofill_response_item_destroy(rpc_port_list_autofill_response_item_h h); + +int rpc_port_list_autofill_response_item_clone(rpc_port_list_autofill_response_item_h h, rpc_port_list_autofill_response_item_h *clone); + +int rpc_port_list_autofill_response_item_add_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, rpc_port_autofill_response_item_h list_autofill_response_items); + +int rpc_port_list_autofill_response_item_foreach_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, + bool (*callback)(rpc_port_autofill_response_item_h list_autofill_response_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_response_item_remove_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, unsigned int nth); + +int rpc_port_list_autofill_response_item_get_list_autofill_response_items_length(rpc_port_list_autofill_response_item_h h, unsigned int *length); + +typedef struct list_autofill_save_item_s *rpc_port_list_autofill_save_item_h; + +int rpc_port_list_autofill_save_item_create(rpc_port_list_autofill_save_item_h *h); + +int rpc_port_list_autofill_save_item_destroy(rpc_port_list_autofill_save_item_h h); + +int rpc_port_list_autofill_save_item_clone(rpc_port_list_autofill_save_item_h h, rpc_port_list_autofill_save_item_h *clone); + +int rpc_port_list_autofill_save_item_add_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, rpc_port_autofill_save_item_h list_autofill_save_items); + +int rpc_port_list_autofill_save_item_foreach_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, + bool (*callback)(rpc_port_autofill_save_item_h list_autofill_save_items, void *user_data), void *user_data); + +int rpc_port_list_autofill_save_item_remove_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, unsigned int nth); + +int rpc_port_list_autofill_save_item_get_list_autofill_save_items_length(rpc_port_list_autofill_save_item_h h, unsigned int *length); + +typedef struct AutofillAppPort_context_s* rpc_port_stub_AutofillAppPort_context_h; + +int rpc_port_stub_AutofillAppPort_context_set_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void *tag); + +int rpc_port_stub_AutofillAppPort_context_get_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void **tag); + +int rpc_port_stub_AutofillAppPort_context_get_sender(rpc_port_stub_AutofillAppPort_context_h ctx, char **sender); + +typedef struct AutofillAppPort_autofill_auth_info_received_cb_s *rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h; + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h); + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_clone(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *clone); + +int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_autofill_auth_info_h auth_info); + +typedef struct AutofillAppPort_autofill_fill_response_received_cb_s *rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h; + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h); + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_clone(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *clone); + +int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_autofill_fill_response_h response); + +typedef struct { + void (*create)(rpc_port_stub_AutofillAppPort_context_h context, void *user_data); + void (*terminate)(rpc_port_stub_AutofillAppPort_context_h context, void *user_data); + + int (*Register)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_cb, void *user_data); + void (*Unregister)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, void *user_data); + int (*request_auth_info)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data); + int (*send_fill_request)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data); + int (*commit)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_save_view_info_h vi, void *user_data); +} rpc_port_stub_AutofillAppPort_callback_s; + +int rpc_port_stub_AutofillAppPort_register(rpc_port_stub_AutofillAppPort_callback_s *callback, void *user_data); + +int rpc_port_stub_AutofillAppPort_unregister(void); + +int rpc_port_stub_AutofillAppPort_get_client_number(unsigned int *n); + +#ifdef __cplusplus +} +#endif -- 2.7.4 From 61e2335c69fe5a3852699a68a26a7f4d470ddc29 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 11:23:01 +0900 Subject: [PATCH 07/16] Revert "Add debug message temporarily" This reverts commit 0da36fb70b86b354ae0110a932fbfff382968c40. Change-Id: I6045cc705ede626fb1e53d6fd9c1f9cff905b062 --- src/autofill-daemon.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index 89e0095..5967d6c 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -241,25 +241,20 @@ bool __view_info_item_cb(rpc_port_autofill_item_h items, void *user_data) return true; } - LOGD("item : %p", svc_item); - rpc_port_autofill_item_get_id(items, &id); rpc_port_autofill_svc_item_set_id(svc_item, id); - LOGD("id : %s", id); if (id) { free(id); } rpc_port_autofill_item_get_label(items, &label); rpc_port_autofill_svc_item_set_label(svc_item, label); - LOGD("label : %s", label); if (label) { free(label); } rpc_port_autofill_item_get_value(items, &value); rpc_port_autofill_svc_item_set_value(svc_item, value); - LOGD("value : %s", value); if (value) { free(value); } -- 2.7.4 From 7d920bfda2a5f9574968ad5c25d828da4f481cd5 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 11:23:43 +0900 Subject: [PATCH 08/16] Update package version to 1.0.3 Change-Id: I25617c84d062e0fd92bb94d4f1d9173be982c4e7 Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 82b91ce..63eb4cc 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From 8a092d7864db36696133543121d11fa7af2218f7 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 17:07:59 +0900 Subject: [PATCH 09/16] Revert "Disable to use tidlc temporarily" This reverts commit da33fa6885639edbd78b76093b754af7f86771ec. Change-Id: I6e745b5f426f044224bba88a23cec7df088cab51 --- build_def.prop | 2 +- src/autofill_manager_stub.c | 681 ------- src/autofill_manager_stub.h | 70 - src/autofill_service_proxy.c | 4261 ------------------------------------------ src/autofill_service_proxy.h | 346 ---- src/autofill_stub.c | 4148 ---------------------------------------- src/autofill_stub.h | 327 ---- 7 files changed, 1 insertion(+), 9834 deletions(-) delete mode 100644 src/autofill_manager_stub.c delete mode 100644 src/autofill_manager_stub.h delete mode 100644 src/autofill_service_proxy.c delete mode 100644 src/autofill_service_proxy.h delete mode 100644 src/autofill_stub.c delete mode 100644 src/autofill_stub.h diff --git a/build_def.prop b/build_def.prop index 6bb5e2f..520f46f 100644 --- a/build_def.prop +++ b/build_def.prop @@ -1,6 +1,6 @@ # Add pre/post build process PREBUILD_DESC = -PREBUILD_COMMAND = +PREBUILD_COMMAND = tidlc -s -l C -i tidl/autofill.tidl -o autofill_stub; mv autofill_stub.h ./src/; mv autofill_stub.c ./src/; tidlc -p -l C -i tidl/autofill_service.tidl -o autofill_service_proxy; mv autofill_service_proxy.h ./src/; mv autofill_service_proxy.c ./src/; tidlc -s -l C -i tidl/autofill_manager.tidl -o autofill_manager_stub; mv autofill_manager_stub.h ./src/; mv autofill_manager_stub.c ./src/; POSTBUILD_DESC = POSTBUILD_COMMAND = diff --git a/src/autofill_manager_stub.c b/src/autofill_manager_stub.c deleted file mode 100644 index a662337..0000000 --- a/src/autofill_manager_stub.c +++ /dev/null @@ -1,681 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "autofill_manager_stub.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "RPC_PORT_STUB" - -#ifdef _E -#undef _E -#endif - -#ifdef _W -#undef _W -#endif - -#ifdef _I -#undef _I -#endif - -#ifdef _D -#undef _D -#endif - -#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) - -typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data); - -struct list_string_s { - rpc_port_parcelable_t parcelable; - GList *list_strings; -}; - -static void __list_string_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_string_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_strings)); - do { - GList *iter; - - iter = h->list_strings; - while (iter) { - char *value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write_string(parcel, value ? value : ""); - } - } while (0); -} - -static void __list_string_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_string_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - char *value = NULL; - - rpc_port_parcel_read_string(parcel, &value); - h->list_strings = g_list_append(h->list_strings, value); - } - } while (0); -} - -int rpc_port_list_string_create(rpc_port_list_string_h *h) -{ - struct list_string_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_string_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_string_to; - handle->parcelable.from = __list_string_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_string_destroy(rpc_port_list_string_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_strings; - while (iter) { - char *value = iter->data; - if (value) - free(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_strings); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_string_clone(rpc_port_list_string_h h, rpc_port_list_string_h *clone) -{ - rpc_port_list_string_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_string_create(&handle); - if (!handle) { - _E("Failed to create list_string handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_strings; - while (iter) { - char *new_value; - char *value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_string_destroy(handle); - return -1; - } - - new_value = strdup(value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_string_destroy(handle); - return -1; - } - - handle->list_strings = g_list_append(handle->list_strings, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_string_add_list_strings(rpc_port_list_string_h h, const char *list_strings) -{ - if (!h || !list_strings) { - _E("Invalid parameter"); - return -1; - } - - do { - char *value = NULL; - - value = strdup(list_strings); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_strings = g_list_append(h->list_strings, value); - } while (0); - - return 0; -} - -int rpc_port_list_string_foreach_list_strings(rpc_port_list_string_h h, - bool (*callback)(const char *list_strings, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_strings; - while (iter) { - char *value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_string_remove_list_strings(rpc_port_list_string_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_strings, nth); - if (iter == NULL) - return -1; - - char *value = iter->data; - h->list_strings = g_list_remove_link(h->list_strings, iter); - if (value) - free(value); - - g_list_free(iter); - - return 0; -} - -int rpc_port_list_string_get_list_strings_length(rpc_port_list_string_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_strings); - - return 0; -} - -enum AutofillManagerPort_method_e { - AutofillManagerPort_METHOD_Result, - AutofillManagerPort_METHOD_Callback, - AutofillManagerPort_METHOD_set_autofill_service, - AutofillManagerPort_METHOD_get_autofill_service, - AutofillManagerPort_METHOD_get_autofill_service_list, -}; - -static rpc_port_stub_h __AutofillManagerPort_stub; -static rpc_port_stub_AutofillManagerPort_callback_s __AutofillManagerPort_callback; -static void *__AutofillManagerPort_user_data; -static GList *__AutofillManagerPort_contexts; - -struct AutofillManagerPort_context_s { - char *sender; - char *instance; - rpc_port_h port; - void *tag; - rpc_port_stub_AutofillManagerPort_callback_s callback; - void *user_data; -}; - -static struct AutofillManagerPort_context_s *__create_AutofillManagerPort_context(const char *sender, const char *instance) -{ - struct AutofillManagerPort_context_s *handle; - - handle = calloc(1, sizeof(struct AutofillManagerPort_context_s)); - if (!handle) { - _E("Out of memory"); - return NULL; - } - - handle->sender = strdup(sender); - if (!handle->sender) { - _E("Out of memory"); - free(handle); - return NULL; - } - - handle->instance = strdup(instance); - if (!handle->instance) { - _E("Out of memory"); - free(handle->sender); - free(handle); - return NULL; - } - - handle->callback = __AutofillManagerPort_callback; - handle->user_data = __AutofillManagerPort_user_data; - - return handle; -} - -static void __destroy_AutofillManagerPort_context(gpointer data) -{ - struct AutofillManagerPort_context_s *handle = data; - - if (!handle) { - _E("Critical error!"); - return; - } - - free(handle->instance); - free(handle->sender); - free(handle); -} - -static struct AutofillManagerPort_context_s *__find_AutofillManagerPort_context(const char *instance) -{ - struct AutofillManagerPort_context_s *handle; - GList *iter; - - iter = __AutofillManagerPort_contexts; - while (iter) { - handle = (struct AutofillManagerPort_context_s *)iter->data; - if (!strcmp(handle->instance, instance)) - return handle; - iter = g_list_next(iter); - } - - return NULL; -} - -int rpc_port_stub_AutofillManagerPort_context_set_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void *tag) -{ - if (!ctx) { - _E("Invalid parameter"); - return -1; - } - - ctx->tag = tag; - - return 0; -} - -int rpc_port_stub_AutofillManagerPort_context_get_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void **tag) -{ - if (!ctx || !tag) { - _E("Invalid parameter"); - return -1; - } - - *tag = ctx->tag; - - return 0; -} - -int rpc_port_stub_AutofillManagerPort_context_get_sender(rpc_port_stub_AutofillManagerPort_context_h ctx, char **sender) -{ - if (!ctx || !sender) { - _E("Invalid parameter"); - return -1; - } - - *sender = strdup(ctx->sender); - if (*sender == NULL) { - _E("Out of memory"); - return -1; - } - - return 0; -} - -static int __AutofillManagerPort_method_set_autofill_service(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - char *app_id; - - rpc_port_parcel_read_string(parcel, &app_id); - - bool ret = context->callback.set_autofill_service(context, app_id, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); - rpc_port_parcel_write_bool(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - free(app_id); - return 0; -} - -static int __AutofillManagerPort_method_get_autofill_service(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - char *ret = context->callback.get_autofill_service(context, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); - rpc_port_parcel_write_string(result, ret ? ret : ""); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - free(ret); - return 0; -} - -static int __AutofillManagerPort_method_get_autofill_service_list(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillManagerPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - rpc_port_list_string_h service_info_list = NULL; - - bool ret = context->callback.get_autofill_service_list(context, &service_info_list, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillManagerPort_METHOD_Result); - rpc_port_parcel_write(result, &service_info_list->parcelable, service_info_list); - rpc_port_parcel_write_bool(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - rpc_port_list_string_destroy(service_info_list); - return 0; -} - -static stub_method __AutofillManagerPort_method_table[] = { - [AutofillManagerPort_METHOD_set_autofill_service] = __AutofillManagerPort_method_set_autofill_service, - [AutofillManagerPort_METHOD_get_autofill_service] = __AutofillManagerPort_method_get_autofill_service, - [AutofillManagerPort_METHOD_get_autofill_service_list] = __AutofillManagerPort_method_get_autofill_service_list, -}; - -static void __AutofillManagerPort_on_connected(const char *sender, const char *instance, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __create_AutofillManagerPort_context(sender, instance); - if (!context) - return; - - if (context->callback.create) - context->callback.create(context, context->user_data); - __AutofillManagerPort_contexts = g_list_append(__AutofillManagerPort_contexts, context); -} - -static void __AutofillManagerPort_on_disconnected(const char *sender, const char *instance, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __find_AutofillManagerPort_context(instance); - if (!context) - return; - - if (context->callback.terminate) - context->callback.terminate(context, context->user_data); - __AutofillManagerPort_contexts = g_list_remove(__AutofillManagerPort_contexts, context); - __destroy_AutofillManagerPort_context(context); -} - -static int __AutofillManagerPort_on_received(const char *sender, const char *instance, rpc_port_h port, void *data) -{ - rpc_port_stub_AutofillManagerPort_context_h context; - rpc_port_parcel_h parcel; - int cmd = -1; - int r; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __find_AutofillManagerPort_context(instance); - if (!context) { - _E("Failed to find AutofillManagerPort context(%s)", instance); - return -1; - } - - context->port = port; - r = rpc_port_parcel_create_from_port(&parcel, port); - if (r != 0) { - _E("Failed to create parcel from port"); - return r; - } - - rpc_port_parcel_read_int32(parcel, &cmd); - if (cmd > 1 && cmd < (sizeof(__AutofillManagerPort_method_table) / sizeof(__AutofillManagerPort_method_table[0]))) { - if (__AutofillManagerPort_method_table[cmd]) - r = __AutofillManagerPort_method_table[cmd](port, parcel, context); - } else { - _E("Unknown Command(%d)", cmd); - r = -1; - } - - rpc_port_parcel_destroy(parcel); - - return r; -} - -static int __AutofillManagerPort_add_privileges(void) -{ - - return 0; -} - -int rpc_port_stub_AutofillManagerPort_register(rpc_port_stub_AutofillManagerPort_callback_s *callback, void *user_data) -{ - int r; - - if (__AutofillManagerPort_stub) { - _W("Already exists"); - return -1; - } - - if (!callback) { - _E("Invalid parameter"); - return -1; - } - - __AutofillManagerPort_callback = *callback; - __AutofillManagerPort_user_data = user_data; - r = rpc_port_stub_create(&__AutofillManagerPort_stub, "AutofillManagerPort"); - if (r != 0) { - _E("Failed to create stub handle"); - return r; - } - - r = rpc_port_stub_add_received_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_received, NULL); - if (r != 0) { - _E("Failed to add received event callback"); - rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - return r; - } - - r = rpc_port_stub_add_connected_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_connected, NULL); - if (r != 0) { - _E("Failed to add connected event callback"); - rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - return r; - } - - r = rpc_port_stub_add_disconnected_event_cb(__AutofillManagerPort_stub, __AutofillManagerPort_on_disconnected, NULL); - if (r != 0) { - _E("Failed to add disconnected event callback"); - rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - return r; - } - - r = __AutofillManagerPort_add_privileges(); - if (r != 0) { - _E("Failed to add privileges"); - rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - return r; - } - - r = rpc_port_stub_listen(__AutofillManagerPort_stub); - if (r != 0) { - _E("Failed to listen stub"); - rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - return r; - } - - return 0; -} - -int rpc_port_stub_AutofillManagerPort_unregister(void) -{ - int r; - - if (!__AutofillManagerPort_stub) - return -1; - - if (__AutofillManagerPort_contexts) { - g_list_free_full(__AutofillManagerPort_contexts, __destroy_AutofillManagerPort_context); - __AutofillManagerPort_contexts = NULL; - } - - r = rpc_port_stub_destroy(__AutofillManagerPort_stub); - __AutofillManagerPort_stub = NULL; - - return r; -} - -int rpc_port_stub_AutofillManagerPort_get_client_number(unsigned int *n) -{ - if (!n) { - _E("Invalid parameter"); - return -1; - } - - if (!__AutofillManagerPort_stub) { - _E("AutofillManagerPort Stub is not ready"); - return -1; - } - - *n = g_list_length(__AutofillManagerPort_contexts); - - return 0; -} diff --git a/src/autofill_manager_stub.h b/src/autofill_manager_stub.h deleted file mode 100644 index 458cb01..0000000 --- a/src/autofill_manager_stub.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct list_string_s *rpc_port_list_string_h; - -int rpc_port_list_string_create(rpc_port_list_string_h *h); - -int rpc_port_list_string_destroy(rpc_port_list_string_h h); - -int rpc_port_list_string_clone(rpc_port_list_string_h h, rpc_port_list_string_h *clone); - -int rpc_port_list_string_add_list_strings(rpc_port_list_string_h h, const char *list_strings); - -int rpc_port_list_string_foreach_list_strings(rpc_port_list_string_h h, - bool (*callback)(const char *list_strings, void *user_data), void *user_data); - -int rpc_port_list_string_remove_list_strings(rpc_port_list_string_h h, unsigned int nth); - -int rpc_port_list_string_get_list_strings_length(rpc_port_list_string_h h, unsigned int *length); - -typedef struct AutofillManagerPort_context_s* rpc_port_stub_AutofillManagerPort_context_h; - -int rpc_port_stub_AutofillManagerPort_context_set_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void *tag); - -int rpc_port_stub_AutofillManagerPort_context_get_tag(rpc_port_stub_AutofillManagerPort_context_h ctx, void **tag); - -int rpc_port_stub_AutofillManagerPort_context_get_sender(rpc_port_stub_AutofillManagerPort_context_h ctx, char **sender); - -typedef struct { - void (*create)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); - void (*terminate)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); - - bool (*set_autofill_service)(rpc_port_stub_AutofillManagerPort_context_h context, const char *app_id, void *user_data); - char *(*get_autofill_service)(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data); - bool (*get_autofill_service_list)(rpc_port_stub_AutofillManagerPort_context_h context, rpc_port_list_string_h *service_info_list, void *user_data); -} rpc_port_stub_AutofillManagerPort_callback_s; - -int rpc_port_stub_AutofillManagerPort_register(rpc_port_stub_AutofillManagerPort_callback_s *callback, void *user_data); - -int rpc_port_stub_AutofillManagerPort_unregister(void); - -int rpc_port_stub_AutofillManagerPort_get_client_number(unsigned int *n); - -#ifdef __cplusplus -} -#endif diff --git a/src/autofill_service_proxy.c b/src/autofill_service_proxy.c deleted file mode 100644 index 18e3bb5..0000000 --- a/src/autofill_service_proxy.c +++ /dev/null @@ -1,4261 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "autofill_service_proxy.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "RPC_PORT_PROXY" - -#ifdef _E -#undef _E -#endif - -#ifdef _W -#undef _W -#endif - -#ifdef _I -#undef _I -#endif - -#ifdef _D -#undef _D -#endif - -#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) - -typedef void (*proxy_delegate)(GList **list, rpc_port_parcel_h parcel, int seq_id, int id); - -struct autofill_svc_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *label; - char *value; - int autofill_hint; - bool is_sensitive_data; -}; - -static void __autofill_svc_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); - rpc_port_parcel_write_int32(parcel, h->autofill_hint); - rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); -} - -static void __autofill_svc_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->label); - rpc_port_parcel_read_string(parcel, &h->value); - rpc_port_parcel_read_int32(parcel, &h->autofill_hint); - rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); -} - -int rpc_port_autofill_svc_item_create(rpc_port_autofill_svc_item_h *h) -{ - struct autofill_svc_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_item_to; - handle->parcelable.from = __autofill_svc_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_item_destroy(rpc_port_autofill_svc_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->label) - free(h->label); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_item_clone(rpc_port_autofill_svc_item_h h, rpc_port_autofill_svc_item_h *clone) -{ - rpc_port_autofill_svc_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_svc_item_destroy(handle); - return -1; - } - } - - if (h->label) { - handle->label = strdup(h->label); - if (!handle->label) { - _E("Failed to duplicate h->label"); - rpc_port_autofill_svc_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_svc_item_destroy(handle); - return -1; - } - } - - handle->autofill_hint = h->autofill_hint; - handle->is_sensitive_data = h->is_sensitive_data; - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_item_set_id(rpc_port_autofill_svc_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_set_label(rpc_port_autofill_svc_item_h h, const char *label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (h->label) { - free(h->label); - h->label = NULL; - } - - h->label = strdup(label); - if (!h->label) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_set_value(rpc_port_autofill_svc_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_set_autofill_hint(rpc_port_autofill_svc_item_h h, int autofill_hint) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->autofill_hint = autofill_hint; - return 0; -} - -int rpc_port_autofill_svc_item_set_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool is_sensitive_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->is_sensitive_data = is_sensitive_data; - return 0; -} - -int rpc_port_autofill_svc_item_get_id(rpc_port_autofill_svc_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_get_label(rpc_port_autofill_svc_item_h h, char **label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (!h->label) { - _E("Invalid parameter: h->label is NULL"); - return -1; - } - - *label = strdup(h->label); - if (*label == NULL) { - _E("Failed to duplicate label"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_get_value(rpc_port_autofill_svc_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_item_get_autofill_hint(rpc_port_autofill_svc_item_h h, int *autofill_hint) -{ - if (!h || !autofill_hint) { - _E("Invalid parameter"); - return -1; - } - - *autofill_hint = h->autofill_hint; - return 0; -} - -int rpc_port_autofill_svc_item_get_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool *is_sensitive_data) -{ - if (!h || !is_sensitive_data) { - _E("Invalid parameter"); - return -1; - } - - *is_sensitive_data = h->is_sensitive_data; - return 0; -} - -struct autofill_svc_view_info_s { - rpc_port_parcelable_t parcelable; - char *app_id; - char *view_id; - GList *items; -}; - -static void __autofill_svc_view_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_svc_view_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->app_id); - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_item_h value = NULL; - - rpc_port_autofill_svc_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->items = g_list_append(h->items, value); - } - } while (0); -} - -int rpc_port_autofill_svc_view_info_create(rpc_port_autofill_svc_view_info_h *h) -{ - struct autofill_svc_view_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_view_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_view_info_to; - handle->parcelable.from = __autofill_svc_view_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_view_info_destroy(rpc_port_autofill_svc_view_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) - free(h->app_id); - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_view_info_clone(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_view_info_h *clone) -{ - rpc_port_autofill_svc_view_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_view_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_view_info handle"); - return -1; - } - - if (h->app_id) { - handle->app_id = strdup(h->app_id); - if (!handle->app_id) { - _E("Failed to duplicate h->app_id"); - rpc_port_autofill_svc_view_info_destroy(handle); - return -1; - } - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_svc_view_info_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_item_h new_value; - rpc_port_autofill_svc_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_svc_view_info_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_svc_view_info_destroy(handle); - return -1; - } - - handle->items = g_list_append(handle->items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_view_info_set_app_id(rpc_port_autofill_svc_view_info_h h, const char *app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) { - free(h->app_id); - h->app_id = NULL; - } - - h->app_id = strdup(app_id); - if (!h->app_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_view_info_set_view_id(rpc_port_autofill_svc_view_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_view_info_add_items(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_item_h items) -{ - if (!h || !items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_item_h value = NULL; - - rpc_port_autofill_svc_item_clone(items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->items = g_list_append(h->items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_view_info_get_app_id(rpc_port_autofill_svc_view_info_h h, char **app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->app_id) { - _E("Invalid parameter: h->app_id is NULL"); - return -1; - } - - *app_id = strdup(h->app_id); - if (*app_id == NULL) { - _E("Failed to duplicate app_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_view_info_get_view_id(rpc_port_autofill_svc_view_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_view_info_foreach_items(rpc_port_autofill_svc_view_info_h h, - bool (*callback)(rpc_port_autofill_svc_item_h items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_view_info_remove_items(rpc_port_autofill_svc_view_info_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_item_h value = iter->data; - h->items = g_list_remove_link(h->items, iter); - rpc_port_autofill_svc_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_svc_view_info_get_items_length(rpc_port_autofill_svc_view_info_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->items); - - return 0; -} - -struct autofill_svc_save_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *label; - char *value; - int autofill_hint; - bool is_sensitive_data; -}; - -static void __autofill_svc_save_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); - rpc_port_parcel_write_int32(parcel, h->autofill_hint); - rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); -} - -static void __autofill_svc_save_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->label); - rpc_port_parcel_read_string(parcel, &h->value); - rpc_port_parcel_read_int32(parcel, &h->autofill_hint); - rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); -} - -int rpc_port_autofill_svc_save_item_create(rpc_port_autofill_svc_save_item_h *h) -{ - struct autofill_svc_save_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_save_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_save_item_to; - handle->parcelable.from = __autofill_svc_save_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_save_item_destroy(rpc_port_autofill_svc_save_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->label) - free(h->label); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_save_item_clone(rpc_port_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h *clone) -{ - rpc_port_autofill_svc_save_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_save_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_save_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_svc_save_item_destroy(handle); - return -1; - } - } - - if (h->label) { - handle->label = strdup(h->label); - if (!handle->label) { - _E("Failed to duplicate h->label"); - rpc_port_autofill_svc_save_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_svc_save_item_destroy(handle); - return -1; - } - } - - handle->autofill_hint = h->autofill_hint; - handle->is_sensitive_data = h->is_sensitive_data; - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_save_item_set_id(rpc_port_autofill_svc_save_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_set_label(rpc_port_autofill_svc_save_item_h h, const char *label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (h->label) { - free(h->label); - h->label = NULL; - } - - h->label = strdup(label); - if (!h->label) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_set_value(rpc_port_autofill_svc_save_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_set_autofill_hint(rpc_port_autofill_svc_save_item_h h, int autofill_hint) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->autofill_hint = autofill_hint; - return 0; -} - -int rpc_port_autofill_svc_save_item_set_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool is_sensitive_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->is_sensitive_data = is_sensitive_data; - return 0; -} - -int rpc_port_autofill_svc_save_item_get_id(rpc_port_autofill_svc_save_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_get_label(rpc_port_autofill_svc_save_item_h h, char **label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (!h->label) { - _E("Invalid parameter: h->label is NULL"); - return -1; - } - - *label = strdup(h->label); - if (*label == NULL) { - _E("Failed to duplicate label"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_get_value(rpc_port_autofill_svc_save_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_item_get_autofill_hint(rpc_port_autofill_svc_save_item_h h, int *autofill_hint) -{ - if (!h || !autofill_hint) { - _E("Invalid parameter"); - return -1; - } - - *autofill_hint = h->autofill_hint; - return 0; -} - -int rpc_port_autofill_svc_save_item_get_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool *is_sensitive_data) -{ - if (!h || !is_sensitive_data) { - _E("Invalid parameter"); - return -1; - } - - *is_sensitive_data = h->is_sensitive_data; - return 0; -} - -struct autofill_svc_save_view_info_s { - rpc_port_parcelable_t parcelable; - char *view_id; - GList *items; -}; - -static void __autofill_svc_save_view_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_save_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_svc_save_view_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_save_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_save_item_h value = NULL; - - rpc_port_autofill_svc_save_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->items = g_list_append(h->items, value); - } - } while (0); -} - -int rpc_port_autofill_svc_save_view_info_create(rpc_port_autofill_svc_save_view_info_h *h) -{ - struct autofill_svc_save_view_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_save_view_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_save_view_info_to; - handle->parcelable.from = __autofill_svc_save_view_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_destroy(rpc_port_autofill_svc_save_view_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_save_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_clone(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_view_info_h *clone) -{ - rpc_port_autofill_svc_save_view_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_save_view_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_save_view_info handle"); - return -1; - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_svc_save_view_info_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_save_item_h new_value; - rpc_port_autofill_svc_save_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_svc_save_view_info_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_save_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_svc_save_view_info_destroy(handle); - return -1; - } - - handle->items = g_list_append(handle->items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_set_view_id(rpc_port_autofill_svc_save_view_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_add_items(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_item_h items) -{ - if (!h || !items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_save_item_h value = NULL; - - rpc_port_autofill_svc_save_item_clone(items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->items = g_list_append(h->items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_get_view_id(rpc_port_autofill_svc_save_view_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_foreach_items(rpc_port_autofill_svc_save_view_info_h h, - bool (*callback)(rpc_port_autofill_svc_save_item_h items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_remove_items(rpc_port_autofill_svc_save_view_info_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_save_item_h value = iter->data; - h->items = g_list_remove_link(h->items, iter); - rpc_port_autofill_svc_save_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_svc_save_view_info_get_items_length(rpc_port_autofill_svc_save_view_info_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->items); - - return 0; -} - -struct autofill_svc_auth_info_s { - rpc_port_parcelable_t parcelable; - char *app_id; - char *view_id; - bool exist_autofill_data; - bool need_authentication; - char *service_name; - char *service_logo_image_path; - char *service_message; -}; - -static void __autofill_svc_auth_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_auth_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_bool(parcel, h->exist_autofill_data); - rpc_port_parcel_write_bool(parcel, h->need_authentication); - rpc_port_parcel_write_string(parcel, h->service_name ? h->service_name : ""); - rpc_port_parcel_write_string(parcel, h->service_logo_image_path ? h->service_logo_image_path : ""); - rpc_port_parcel_write_string(parcel, h->service_message ? h->service_message : ""); -} - -static void __autofill_svc_auth_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_auth_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->app_id); - rpc_port_parcel_read_string(parcel, &h->view_id); - rpc_port_parcel_read_bool(parcel, &h->exist_autofill_data); - rpc_port_parcel_read_bool(parcel, &h->need_authentication); - rpc_port_parcel_read_string(parcel, &h->service_name); - rpc_port_parcel_read_string(parcel, &h->service_logo_image_path); - rpc_port_parcel_read_string(parcel, &h->service_message); -} - -int rpc_port_autofill_svc_auth_info_create(rpc_port_autofill_svc_auth_info_h *h) -{ - struct autofill_svc_auth_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_auth_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_auth_info_to; - handle->parcelable.from = __autofill_svc_auth_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_auth_info_destroy(rpc_port_autofill_svc_auth_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) - free(h->app_id); - - if (h->view_id) - free(h->view_id); - - if (h->service_name) - free(h->service_name); - - if (h->service_logo_image_path) - free(h->service_logo_image_path); - - if (h->service_message) - free(h->service_message); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_auth_info_clone(rpc_port_autofill_svc_auth_info_h h, rpc_port_autofill_svc_auth_info_h *clone) -{ - rpc_port_autofill_svc_auth_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_auth_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_auth_info handle"); - return -1; - } - - if (h->app_id) { - handle->app_id = strdup(h->app_id); - if (!handle->app_id) { - _E("Failed to duplicate h->app_id"); - rpc_port_autofill_svc_auth_info_destroy(handle); - return -1; - } - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_svc_auth_info_destroy(handle); - return -1; - } - } - - handle->exist_autofill_data = h->exist_autofill_data; - handle->need_authentication = h->need_authentication; - if (h->service_name) { - handle->service_name = strdup(h->service_name); - if (!handle->service_name) { - _E("Failed to duplicate h->service_name"); - rpc_port_autofill_svc_auth_info_destroy(handle); - return -1; - } - } - - if (h->service_logo_image_path) { - handle->service_logo_image_path = strdup(h->service_logo_image_path); - if (!handle->service_logo_image_path) { - _E("Failed to duplicate h->service_logo_image_path"); - rpc_port_autofill_svc_auth_info_destroy(handle); - return -1; - } - } - - if (h->service_message) { - handle->service_message = strdup(h->service_message); - if (!handle->service_message) { - _E("Failed to duplicate h->service_message"); - rpc_port_autofill_svc_auth_info_destroy(handle); - return -1; - } - } - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_app_id(rpc_port_autofill_svc_auth_info_h h, const char *app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) { - free(h->app_id); - h->app_id = NULL; - } - - h->app_id = strdup(app_id); - if (!h->app_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_view_id(rpc_port_autofill_svc_auth_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool exist_autofill_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->exist_autofill_data = exist_autofill_data; - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool need_authentication) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->need_authentication = need_authentication; - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_service_name(rpc_port_autofill_svc_auth_info_h h, const char *service_name) -{ - if (!h || !service_name) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_name) { - free(h->service_name); - h->service_name = NULL; - } - - h->service_name = strdup(service_name); - if (!h->service_name) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, const char *service_logo_image_path) -{ - if (!h || !service_logo_image_path) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_logo_image_path) { - free(h->service_logo_image_path); - h->service_logo_image_path = NULL; - } - - h->service_logo_image_path = strdup(service_logo_image_path); - if (!h->service_logo_image_path) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_set_service_message(rpc_port_autofill_svc_auth_info_h h, const char *service_message) -{ - if (!h || !service_message) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_message) { - free(h->service_message); - h->service_message = NULL; - } - - h->service_message = strdup(service_message); - if (!h->service_message) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_app_id(rpc_port_autofill_svc_auth_info_h h, char **app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->app_id) { - _E("Invalid parameter: h->app_id is NULL"); - return -1; - } - - *app_id = strdup(h->app_id); - if (*app_id == NULL) { - _E("Failed to duplicate app_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_view_id(rpc_port_autofill_svc_auth_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool *exist_autofill_data) -{ - if (!h || !exist_autofill_data) { - _E("Invalid parameter"); - return -1; - } - - *exist_autofill_data = h->exist_autofill_data; - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool *need_authentication) -{ - if (!h || !need_authentication) { - _E("Invalid parameter"); - return -1; - } - - *need_authentication = h->need_authentication; - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_service_name(rpc_port_autofill_svc_auth_info_h h, char **service_name) -{ - if (!h || !service_name) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_name) { - _E("Invalid parameter: h->service_name is NULL"); - return -1; - } - - *service_name = strdup(h->service_name); - if (*service_name == NULL) { - _E("Failed to duplicate service_name"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, char **service_logo_image_path) -{ - if (!h || !service_logo_image_path) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_logo_image_path) { - _E("Invalid parameter: h->service_logo_image_path is NULL"); - return -1; - } - - *service_logo_image_path = strdup(h->service_logo_image_path); - if (*service_logo_image_path == NULL) { - _E("Failed to duplicate service_logo_image_path"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_auth_info_get_service_message(rpc_port_autofill_svc_auth_info_h h, char **service_message) -{ - if (!h || !service_message) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_message) { - _E("Invalid parameter: h->service_message is NULL"); - return -1; - } - - *service_message = strdup(h->service_message); - if (*service_message == NULL) { - _E("Failed to duplicate service_message"); - return -1; - } - - return 0; -} - -struct autofill_svc_response_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *presentation_text; - char *value; -}; - -static void __autofill_svc_response_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->presentation_text ? h->presentation_text : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); -} - -static void __autofill_svc_response_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->presentation_text); - rpc_port_parcel_read_string(parcel, &h->value); -} - -int rpc_port_autofill_svc_response_item_create(rpc_port_autofill_svc_response_item_h *h) -{ - struct autofill_svc_response_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_response_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_response_item_to; - handle->parcelable.from = __autofill_svc_response_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_response_item_destroy(rpc_port_autofill_svc_response_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->presentation_text) - free(h->presentation_text); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_response_item_clone(rpc_port_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h *clone) -{ - rpc_port_autofill_svc_response_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_response_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_response_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_svc_response_item_destroy(handle); - return -1; - } - } - - if (h->presentation_text) { - handle->presentation_text = strdup(h->presentation_text); - if (!handle->presentation_text) { - _E("Failed to duplicate h->presentation_text"); - rpc_port_autofill_svc_response_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_svc_response_item_destroy(handle); - return -1; - } - } - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_response_item_set_id(rpc_port_autofill_svc_response_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_response_item_set_presentation_text(rpc_port_autofill_svc_response_item_h h, const char *presentation_text) -{ - if (!h || !presentation_text) { - _E("Invalid parameter"); - return -1; - } - - if (h->presentation_text) { - free(h->presentation_text); - h->presentation_text = NULL; - } - - h->presentation_text = strdup(presentation_text); - if (!h->presentation_text) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_response_item_set_value(rpc_port_autofill_svc_response_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_response_item_get_id(rpc_port_autofill_svc_response_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_response_item_get_presentation_text(rpc_port_autofill_svc_response_item_h h, char **presentation_text) -{ - if (!h || !presentation_text) { - _E("Invalid parameter"); - return -1; - } - - if (!h->presentation_text) { - _E("Invalid parameter: h->presentation_text is NULL"); - return -1; - } - - *presentation_text = strdup(h->presentation_text); - if (*presentation_text == NULL) { - _E("Failed to duplicate presentation_text"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_response_item_get_value(rpc_port_autofill_svc_response_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -struct autofill_svc_response_group_s { - rpc_port_parcelable_t parcelable; - GList *response_items; -}; - -static void __autofill_svc_response_group_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_items)); - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_svc_response_group_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_response_item_h value = NULL; - - rpc_port_autofill_svc_response_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->response_items = g_list_append(h->response_items, value); - } - } while (0); -} - -int rpc_port_autofill_svc_response_group_create(rpc_port_autofill_svc_response_group_h *h) -{ - struct autofill_svc_response_group_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_response_group_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_response_group_to; - handle->parcelable.from = __autofill_svc_response_group_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_response_group_destroy(rpc_port_autofill_svc_response_group_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_response_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->response_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_response_group_clone(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h *clone) -{ - rpc_port_autofill_svc_response_group_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_response_group_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_response_group handle"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h new_value; - rpc_port_autofill_svc_response_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_svc_response_group_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_response_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_svc_response_group_destroy(handle); - return -1; - } - - handle->response_items = g_list_append(handle->response_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_response_group_add_response_items(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_item_h response_items) -{ - if (!h || !response_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_response_item_h value = NULL; - - rpc_port_autofill_svc_response_item_clone(response_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->response_items = g_list_append(h->response_items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_response_group_foreach_response_items(rpc_port_autofill_svc_response_group_h h, - bool (*callback)(rpc_port_autofill_svc_response_item_h response_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_response_group_remove_response_items(rpc_port_autofill_svc_response_group_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->response_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_response_item_h value = iter->data; - h->response_items = g_list_remove_link(h->response_items, iter); - rpc_port_autofill_svc_response_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_svc_response_group_get_response_items_length(rpc_port_autofill_svc_response_group_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->response_items); - - return 0; -} - -struct autofill_svc_fill_response_s { - rpc_port_parcelable_t parcelable; - char *app_id; - char *view_id; - GList *response_groups; -}; - -static void __autofill_svc_fill_response_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_fill_response_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->app_id ? h->app_id : ""); - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_groups)); - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_svc_fill_response_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_svc_fill_response_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->app_id); - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_response_group_h value = NULL; - - rpc_port_autofill_svc_response_group_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->response_groups = g_list_append(h->response_groups, value); - } - } while (0); -} - -int rpc_port_autofill_svc_fill_response_create(rpc_port_autofill_svc_fill_response_h *h) -{ - struct autofill_svc_fill_response_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_svc_fill_response_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_svc_fill_response_to; - handle->parcelable.from = __autofill_svc_fill_response_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_svc_fill_response_destroy(rpc_port_autofill_svc_fill_response_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) - free(h->app_id); - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - if (value) - rpc_port_autofill_svc_response_group_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->response_groups); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_svc_fill_response_clone(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_fill_response_h *clone) -{ - rpc_port_autofill_svc_fill_response_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_svc_fill_response_create(&handle); - if (!handle) { - _E("Failed to create autofill_svc_fill_response handle"); - return -1; - } - - if (h->app_id) { - handle->app_id = strdup(h->app_id); - if (!handle->app_id) { - _E("Failed to duplicate h->app_id"); - rpc_port_autofill_svc_fill_response_destroy(handle); - return -1; - } - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_svc_fill_response_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h new_value; - rpc_port_autofill_svc_response_group_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_svc_fill_response_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_response_group_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_svc_fill_response_destroy(handle); - return -1; - } - - handle->response_groups = g_list_append(handle->response_groups, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_svc_fill_response_set_app_id(rpc_port_autofill_svc_fill_response_h h, const char *app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->app_id) { - free(h->app_id); - h->app_id = NULL; - } - - h->app_id = strdup(app_id); - if (!h->app_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_fill_response_set_view_id(rpc_port_autofill_svc_fill_response_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_fill_response_add_response_groups(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_response_group_h response_groups) -{ - if (!h || !response_groups) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_response_group_h value = NULL; - - rpc_port_autofill_svc_response_group_clone(response_groups, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->response_groups = g_list_append(h->response_groups, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_fill_response_get_app_id(rpc_port_autofill_svc_fill_response_h h, char **app_id) -{ - if (!h || !app_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->app_id) { - _E("Invalid parameter: h->app_id is NULL"); - return -1; - } - - *app_id = strdup(h->app_id); - if (*app_id == NULL) { - _E("Failed to duplicate app_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_fill_response_get_view_id(rpc_port_autofill_svc_fill_response_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_svc_fill_response_foreach_response_groups(rpc_port_autofill_svc_fill_response_h h, - bool (*callback)(rpc_port_autofill_svc_response_group_h response_groups, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_svc_fill_response_remove_response_groups(rpc_port_autofill_svc_fill_response_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->response_groups, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_response_group_h value = iter->data; - h->response_groups = g_list_remove_link(h->response_groups, iter); - rpc_port_autofill_svc_response_group_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_svc_fill_response_get_response_groups_length(rpc_port_autofill_svc_fill_response_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->response_groups); - - return 0; -} - -struct list_autofill_svc_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_svc_items; -}; - -static void __list_autofill_svc_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_items)); - do { - GList *iter; - - iter = h->list_autofill_svc_items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_svc_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_item_h value = NULL; - - rpc_port_autofill_svc_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_svc_items = g_list_append(h->list_autofill_svc_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_svc_item_create(rpc_port_list_autofill_svc_item_h *h) -{ - struct list_autofill_svc_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_svc_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_svc_item_to; - handle->parcelable.from = __list_autofill_svc_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_item_destroy(rpc_port_list_autofill_svc_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_svc_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_svc_item_clone(rpc_port_list_autofill_svc_item_h h, rpc_port_list_autofill_svc_item_h *clone) -{ - rpc_port_list_autofill_svc_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_svc_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_svc_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_items; - while (iter) { - rpc_port_autofill_svc_item_h new_value; - rpc_port_autofill_svc_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_svc_item_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_svc_item_destroy(handle); - return -1; - } - - handle->list_autofill_svc_items = g_list_append(handle->list_autofill_svc_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_item_add_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, rpc_port_autofill_svc_item_h list_autofill_svc_items) -{ - if (!h || !list_autofill_svc_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_item_h value = NULL; - - rpc_port_autofill_svc_item_clone(list_autofill_svc_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_svc_items = g_list_append(h->list_autofill_svc_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_item_foreach_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, - bool (*callback)(rpc_port_autofill_svc_item_h list_autofill_svc_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_items; - while (iter) { - rpc_port_autofill_svc_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_item_remove_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_svc_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_item_h value = iter->data; - h->list_autofill_svc_items = g_list_remove_link(h->list_autofill_svc_items, iter); - rpc_port_autofill_svc_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_svc_item_get_list_autofill_svc_items_length(rpc_port_list_autofill_svc_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_svc_items); - - return 0; -} - -struct list_autofill_svc_response_group_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_svc_response_groups; -}; - -static void __list_autofill_svc_response_group_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_response_groups)); - do { - GList *iter; - - iter = h->list_autofill_svc_response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_svc_response_group_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_response_group_h value = NULL; - - rpc_port_autofill_svc_response_group_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_svc_response_groups = g_list_append(h->list_autofill_svc_response_groups, value); - } - } while (0); -} - -int rpc_port_list_autofill_svc_response_group_create(rpc_port_list_autofill_svc_response_group_h *h) -{ - struct list_autofill_svc_response_group_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_svc_response_group_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_svc_response_group_to; - handle->parcelable.from = __list_autofill_svc_response_group_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_destroy(rpc_port_list_autofill_svc_response_group_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - if (value) - rpc_port_autofill_svc_response_group_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_svc_response_groups); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_clone(rpc_port_list_autofill_svc_response_group_h h, rpc_port_list_autofill_svc_response_group_h *clone) -{ - rpc_port_list_autofill_svc_response_group_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_svc_response_group_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_svc_response_group handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h new_value; - rpc_port_autofill_svc_response_group_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_svc_response_group_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_response_group_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_svc_response_group_destroy(handle); - return -1; - } - - handle->list_autofill_svc_response_groups = g_list_append(handle->list_autofill_svc_response_groups, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_add_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups) -{ - if (!h || !list_autofill_svc_response_groups) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_response_group_h value = NULL; - - rpc_port_autofill_svc_response_group_clone(list_autofill_svc_response_groups, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_svc_response_groups = g_list_append(h->list_autofill_svc_response_groups, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_foreach_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, - bool (*callback)(rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_groups; - while (iter) { - rpc_port_autofill_svc_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_remove_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_svc_response_groups, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_response_group_h value = iter->data; - h->list_autofill_svc_response_groups = g_list_remove_link(h->list_autofill_svc_response_groups, iter); - rpc_port_autofill_svc_response_group_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_svc_response_group_get_list_autofill_svc_response_groups_length(rpc_port_list_autofill_svc_response_group_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_svc_response_groups); - - return 0; -} - -struct list_autofill_svc_response_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_svc_response_items; -}; - -static void __list_autofill_svc_response_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_response_items)); - do { - GList *iter; - - iter = h->list_autofill_svc_response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_svc_response_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_response_item_h value = NULL; - - rpc_port_autofill_svc_response_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_svc_response_items = g_list_append(h->list_autofill_svc_response_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_svc_response_item_create(rpc_port_list_autofill_svc_response_item_h *h) -{ - struct list_autofill_svc_response_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_svc_response_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_svc_response_item_to; - handle->parcelable.from = __list_autofill_svc_response_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_destroy(rpc_port_list_autofill_svc_response_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_response_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_svc_response_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_clone(rpc_port_list_autofill_svc_response_item_h h, rpc_port_list_autofill_svc_response_item_h *clone) -{ - rpc_port_list_autofill_svc_response_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_svc_response_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_svc_response_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h new_value; - rpc_port_autofill_svc_response_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_svc_response_item_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_response_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_svc_response_item_destroy(handle); - return -1; - } - - handle->list_autofill_svc_response_items = g_list_append(handle->list_autofill_svc_response_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_add_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items) -{ - if (!h || !list_autofill_svc_response_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_response_item_h value = NULL; - - rpc_port_autofill_svc_response_item_clone(list_autofill_svc_response_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_svc_response_items = g_list_append(h->list_autofill_svc_response_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_foreach_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, - bool (*callback)(rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_response_items; - while (iter) { - rpc_port_autofill_svc_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_remove_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_svc_response_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_response_item_h value = iter->data; - h->list_autofill_svc_response_items = g_list_remove_link(h->list_autofill_svc_response_items, iter); - rpc_port_autofill_svc_response_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_svc_response_item_get_list_autofill_svc_response_items_length(rpc_port_list_autofill_svc_response_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_svc_response_items); - - return 0; -} - -struct list_autofill_svc_save_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_svc_save_items; -}; - -static void __list_autofill_svc_save_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_svc_save_items)); - do { - GList *iter; - - iter = h->list_autofill_svc_save_items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_svc_save_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_svc_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_svc_save_item_h value = NULL; - - rpc_port_autofill_svc_save_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_svc_save_items = g_list_append(h->list_autofill_svc_save_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_svc_save_item_create(rpc_port_list_autofill_svc_save_item_h *h) -{ - struct list_autofill_svc_save_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_svc_save_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_svc_save_item_to; - handle->parcelable.from = __list_autofill_svc_save_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_destroy(rpc_port_list_autofill_svc_save_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_save_items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - if (value) - rpc_port_autofill_svc_save_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_svc_save_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_clone(rpc_port_list_autofill_svc_save_item_h h, rpc_port_list_autofill_svc_save_item_h *clone) -{ - rpc_port_list_autofill_svc_save_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_svc_save_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_svc_save_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_save_items; - while (iter) { - rpc_port_autofill_svc_save_item_h new_value; - rpc_port_autofill_svc_save_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_svc_save_item_destroy(handle); - return -1; - } - - rpc_port_autofill_svc_save_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_svc_save_item_destroy(handle); - return -1; - } - - handle->list_autofill_svc_save_items = g_list_append(handle->list_autofill_svc_save_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_add_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items) -{ - if (!h || !list_autofill_svc_save_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_svc_save_item_h value = NULL; - - rpc_port_autofill_svc_save_item_clone(list_autofill_svc_save_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_svc_save_items = g_list_append(h->list_autofill_svc_save_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_foreach_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, - bool (*callback)(rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_svc_save_items; - while (iter) { - rpc_port_autofill_svc_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_remove_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_svc_save_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_svc_save_item_h value = iter->data; - h->list_autofill_svc_save_items = g_list_remove_link(h->list_autofill_svc_save_items, iter); - rpc_port_autofill_svc_save_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_svc_save_item_get_list_autofill_svc_save_items_length(rpc_port_list_autofill_svc_save_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_svc_save_items); - - return 0; -} - -enum AutofillSvcPort_method_e { - AutofillSvcPort_METHOD_Result, - AutofillSvcPort_METHOD_Callback, - AutofillSvcPort_METHOD_Register, - AutofillSvcPort_METHOD_Unregister, - AutofillSvcPort_METHOD_request_auth_info, - AutofillSvcPort_METHOD_send_fill_request, - AutofillSvcPort_METHOD_commit, - AutofillSvcPort_METHOD_request_terminate, -}; - -enum AutofillSvcPort_delegate_e { - AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb = 1, - AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb = 2, -}; - -struct AutofillSvcPort_s { - char *stub_appid; - rpc_port_proxy_h proxy; - rpc_port_h port; - rpc_port_h callback_port; - rpc_port_proxy_AutofillSvcPort_callback_s callback; - void *user_data; - GList *delegates; - GRecMutex mutex; -}; - -struct AutofillSvcPort_autofill_svc_auth_info_cb_s { - rpc_port_parcelable_t parcelable; - int id; - int seq_id; - AutofillSvcPort_autofill_svc_auth_info_cb callback; - bool once; - void *user_data; -}; - -static void __AutofillSvcPort_autofill_svc_auth_info_cb_to(rpc_port_parcel_h parcel, void *data) -{ - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_int32(parcel, handle->id); - rpc_port_parcel_write_int32(parcel, handle->seq_id); - rpc_port_parcel_write_bool(parcel, handle->once); -} - -static void __AutofillSvcPort_autofill_svc_auth_info_cb_from(rpc_port_parcel_h parcel, void *data) -{ - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_int32(parcel, &handle->id); - rpc_port_parcel_read_int32(parcel, &handle->seq_id); - rpc_port_parcel_read_bool(parcel, &handle->once); -} - -rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_create(AutofillSvcPort_autofill_svc_auth_info_cb callback, bool once, void *user_data) -{ - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; - static int seq_num; - - handle = calloc(1, sizeof(struct AutofillSvcPort_autofill_svc_auth_info_cb_s)); - if (!handle) { - _E("Out of memory"); - return NULL; - } - - handle->parcelable.to = __AutofillSvcPort_autofill_svc_auth_info_cb_to; - handle->parcelable.from= __AutofillSvcPort_autofill_svc_auth_info_cb_from; - handle->id = AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb; - handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; - handle->callback = callback; - handle->once = once; - handle->user_data = user_data; - - return handle; -} - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate) -{ - if (!delegate) { - _E("Invalid parameter"); - return -1; - } - - free(delegate); - - return 0; -} - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate) -{ - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; - GList *iter; - - if (!proxy || !delegate) { - _E("Invalid handle %p %p", proxy, delegate); - return -1; - } - - iter = proxy->delegates; - while (iter) { - handle = (struct AutofillSvcPort_autofill_svc_auth_info_cb_s *)iter->data; - if (handle == delegate) { - proxy->delegates = g_list_remove_link(proxy->delegates, iter); - free(handle); - g_list_free(iter); - return 0; - } - iter = g_list_next(iter); - } - - return -1; -} - -static void __AutofillSvcPort_delegate_autofill_svc_auth_info_cb(GList **list, rpc_port_parcel_h parcel, int seq_id, int id) -{ - int context_id; - rpc_port_autofill_svc_auth_info_h auth_info; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_autofill_svc_auth_info_create(&auth_info); - rpc_port_parcel_read(parcel, &auth_info->parcelable, auth_info); - - do { - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle; - GList *iter; - - iter = *list; - while (iter) { - handle = (struct AutofillSvcPort_autofill_svc_auth_info_cb_s *)iter->data; - if (handle->seq_id == seq_id && handle->id == id) { - handle->callback(handle->user_data, context_id, auth_info); - - if (handle->once) { - *list = g_list_remove_link(*list, iter); - free(handle); - g_list_free(iter); - } - break; - } - iter = g_list_next(iter); - } - } while (0); - - rpc_port_autofill_svc_auth_info_destroy(auth_info); -} - -struct AutofillSvcPort_autofill_svc_fill_response_cb_s { - rpc_port_parcelable_t parcelable; - int id; - int seq_id; - AutofillSvcPort_autofill_svc_fill_response_cb callback; - bool once; - void *user_data; -}; - -static void __AutofillSvcPort_autofill_svc_fill_response_cb_to(rpc_port_parcel_h parcel, void *data) -{ - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_int32(parcel, handle->id); - rpc_port_parcel_write_int32(parcel, handle->seq_id); - rpc_port_parcel_write_bool(parcel, handle->once); -} - -static void __AutofillSvcPort_autofill_svc_fill_response_cb_from(rpc_port_parcel_h parcel, void *data) -{ - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_int32(parcel, &handle->id); - rpc_port_parcel_read_int32(parcel, &handle->seq_id); - rpc_port_parcel_read_bool(parcel, &handle->once); -} - -rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_create(AutofillSvcPort_autofill_svc_fill_response_cb callback, bool once, void *user_data) -{ - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; - static int seq_num; - - handle = calloc(1, sizeof(struct AutofillSvcPort_autofill_svc_fill_response_cb_s)); - if (!handle) { - _E("Out of memory"); - return NULL; - } - - handle->parcelable.to = __AutofillSvcPort_autofill_svc_fill_response_cb_to; - handle->parcelable.from= __AutofillSvcPort_autofill_svc_fill_response_cb_from; - handle->id = AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb; - handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; - handle->callback = callback; - handle->once = once; - handle->user_data = user_data; - - return handle; -} - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate) -{ - if (!delegate) { - _E("Invalid parameter"); - return -1; - } - - free(delegate); - - return 0; -} - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate) -{ - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; - GList *iter; - - if (!proxy || !delegate) { - _E("Invalid handle %p %p", proxy, delegate); - return -1; - } - - iter = proxy->delegates; - while (iter) { - handle = (struct AutofillSvcPort_autofill_svc_fill_response_cb_s *)iter->data; - if (handle == delegate) { - proxy->delegates = g_list_remove_link(proxy->delegates, iter); - free(handle); - g_list_free(iter); - return 0; - } - iter = g_list_next(iter); - } - - return -1; -} - -static void __AutofillSvcPort_delegate_autofill_svc_fill_response_cb(GList **list, rpc_port_parcel_h parcel, int seq_id, int id) -{ - int context_id; - rpc_port_autofill_svc_fill_response_h response; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_autofill_svc_fill_response_create(&response); - rpc_port_parcel_read(parcel, &response->parcelable, response); - - do { - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle; - GList *iter; - - iter = *list; - while (iter) { - handle = (struct AutofillSvcPort_autofill_svc_fill_response_cb_s *)iter->data; - if (handle->seq_id == seq_id && handle->id == id) { - handle->callback(handle->user_data, context_id, response); - - if (handle->once) { - *list = g_list_remove_link(*list, iter); - free(handle); - g_list_free(iter); - } - break; - } - iter = g_list_next(iter); - } - } while (0); - - rpc_port_autofill_svc_fill_response_destroy(response); -} - -static proxy_delegate __AutofillSvcPort_delegate_table[] = { - [AutofillSvcPort_DELEGATE_autofill_svc_auth_info_cb] = __AutofillSvcPort_delegate_autofill_svc_auth_info_cb, - [AutofillSvcPort_DELEGATE_autofill_svc_fill_response_cb] = __AutofillSvcPort_delegate_autofill_svc_fill_response_cb, -}; - -static void __AutofillSvcPort_process_received_event(GList **list, rpc_port_parcel_h parcel) -{ - int id; - int seq_id; - bool once; - - rpc_port_parcel_read_int32(parcel, &id); - rpc_port_parcel_read_int32(parcel, &seq_id); - rpc_port_parcel_read_bool(parcel, &once); - - if (id > 0 && id < (sizeof(__AutofillSvcPort_delegate_table) / sizeof(__AutofillSvcPort_delegate_table[0]))) { - if (__AutofillSvcPort_delegate_table[id]) - __AutofillSvcPort_delegate_table[id](list, parcel, seq_id, id); - } else { - _W("Unknown id(%d)", id); - } -} - -static rpc_port_parcel_h __AutofillSvcPort_consume_command(rpc_port_proxy_AutofillSvcPort_h h) -{ - rpc_port_parcel_h parcel = NULL; - int cmd = -1; - - do { - rpc_port_parcel_create_from_port(&parcel, h->port); - if (!parcel) - break; - - rpc_port_parcel_read_int32(parcel, &cmd); - if (cmd == AutofillSvcPort_METHOD_Result) - return parcel; - - rpc_port_parcel_destroy(parcel); - parcel = NULL; - } while (true); - - return NULL; -} - -static void __AutofillSvcPort_on_connected(const char *endpoint, const char *port_name, rpc_port_h port, void *data) -{ - rpc_port_proxy_AutofillSvcPort_h handle = data; - - handle->port = port; - rpc_port_proxy_get_port(handle->proxy, RPC_PORT_PORT_CALLBACK, &handle->callback_port); - if (handle->callback.connected) - handle->callback.connected(handle, handle->user_data); - _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); -} - -static void __AutofillSvcPort_on_disconnected(const char *endpoint, const char *port_name, void *data) -{ - rpc_port_proxy_AutofillSvcPort_h handle = data; - - handle->port = NULL; - if (handle->callback.disconnected) - handle->callback.disconnected(handle, handle->user_data); - _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); -} - -static void __AutofillSvcPort_on_rejected(const char *endpoint, const char *port_name, void *data) -{ - rpc_port_proxy_AutofillSvcPort_h handle = data; - - handle->port = NULL; - if (handle->callback.rejected) - handle->callback.rejected(handle, handle->user_data); - _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); -} - -static void __AutofillSvcPort_on_received(const char *endpoint, const char *port_name, void *data) -{ - rpc_port_proxy_AutofillSvcPort_h handle = data; - rpc_port_parcel_h parcel_received = NULL; - int cmd = -1; - - rpc_port_parcel_create_from_port(&parcel_received, handle->callback_port); - if (!parcel_received) { - _E("Failed to create parcel from port(%s)", port_name); - return; - } - - rpc_port_parcel_read_int32(parcel_received, &cmd); - if (cmd != AutofillSvcPort_METHOD_Callback) { - _E("Invalid protocol"); - rpc_port_parcel_destroy(parcel_received); - return; - } - - __AutofillSvcPort_process_received_event(&handle->delegates, parcel_received); - rpc_port_parcel_destroy(parcel_received); - _I("[__RPC_PORT__] endpoint(%s), port_name(%s)", endpoint, port_name); -} - -int rpc_port_proxy_AutofillSvcPort_invoke_Register(rpc_port_proxy_AutofillSvcPort_h h, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h auth_info_cb, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h fill_response_cb) -{ - rpc_port_parcel_h parcel; - int r; - int ret = -1; - - if (!h || !auth_info_cb || !fill_response_cb) { - _E("Invalid parameter"); - return ret; - } - - if (!h->port) { - _E("Not connected"); - return ret; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_Register); - - do { - struct AutofillSvcPort_autofill_svc_auth_info_cb_s *handle = auth_info_cb; - - rpc_port_parcel_write(parcel, &handle->parcelable, handle); - h->delegates = g_list_append(h->delegates, handle); - } while (0); - - do { - struct AutofillSvcPort_autofill_svc_fill_response_cb_s *handle = fill_response_cb; - - rpc_port_parcel_write(parcel, &handle->parcelable, handle); - h->delegates = g_list_append(h->delegates, handle); - } while (0); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - - g_rec_mutex_lock(&h->mutex); - do { - rpc_port_parcel_h parcel_received; - - parcel_received = __AutofillSvcPort_consume_command(h); - if (!parcel_received) { - _E("Invalid protocol"); - break; - } - - rpc_port_parcel_read_int32(parcel_received, &ret); - - rpc_port_parcel_destroy(parcel_received); - } while (0); - g_rec_mutex_unlock(&h->mutex); - set_last_result(r); - - return ret; -} - -void rpc_port_proxy_AutofillSvcPort_invoke_Unregister(rpc_port_proxy_AutofillSvcPort_h h) -{ - rpc_port_parcel_h parcel; - int r; - - if (!h) { - _E("Invalid parameter"); - return; - } - - if (!h->port) { - _E("Not connected"); - return; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_Unregister); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - set_last_result(r); -} - -void rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi) -{ - rpc_port_parcel_h parcel; - int r; - - if (!h || !vi) { - _E("Invalid parameter"); - return; - } - - if (!h->port) { - _E("Not connected"); - return; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_request_auth_info); - rpc_port_parcel_write_int32(parcel, context_id); - rpc_port_parcel_write(parcel, &vi->parcelable, vi); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - set_last_result(r); -} - -void rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi) -{ - rpc_port_parcel_h parcel; - int r; - - if (!h || !vi) { - _E("Invalid parameter"); - return; - } - - if (!h->port) { - _E("Not connected"); - return; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_send_fill_request); - rpc_port_parcel_write_int32(parcel, context_id); - rpc_port_parcel_write(parcel, &vi->parcelable, vi); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - set_last_result(r); -} - -void rpc_port_proxy_AutofillSvcPort_invoke_commit(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_save_view_info_h si) -{ - rpc_port_parcel_h parcel; - int r; - - if (!h || !si) { - _E("Invalid parameter"); - return; - } - - if (!h->port) { - _E("Not connected"); - return; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_commit); - rpc_port_parcel_write_int32(parcel, context_id); - rpc_port_parcel_write(parcel, &si->parcelable, si); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - set_last_result(r); -} - -void rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(rpc_port_proxy_AutofillSvcPort_h h) -{ - rpc_port_parcel_h parcel; - int r; - - if (!h) { - _E("Invalid parameter"); - return; - } - - if (!h->port) { - _E("Not connected"); - return; - } - - rpc_port_parcel_create(&parcel); - rpc_port_parcel_write_int32(parcel, AutofillSvcPort_METHOD_request_terminate); - - r = rpc_port_parcel_send(parcel, h->port); - if (r != RPC_PORT_ERROR_NONE) { - _E("Failed to send parcel. result(%d)", r); - r = RPC_PORT_ERROR_IO_ERROR; - } - - rpc_port_parcel_destroy(parcel); - set_last_result(r); -} - -static struct AutofillSvcPort_s *__create_AutofillSvcPort(const char *stub_appid, rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data) -{ - struct AutofillSvcPort_s *handle; - - handle = calloc(1, sizeof(struct AutofillSvcPort_s)); - if (!handle) { - _E("Out of memory"); - return NULL; - } - - handle->stub_appid = strdup(stub_appid); - if (!handle->stub_appid) { - _E("Out of memory"); - free(handle); - return NULL; - } - - rpc_port_proxy_create(&handle->proxy); - if (!handle->proxy) { - _E("Failed to create proxy"); - free(handle->stub_appid); - free(handle); - return NULL; - } - - g_rec_mutex_init(&handle->mutex); - - handle->callback = *callback; - handle->user_data = user_data; - - return handle; -} - -static void __destroy_AutofillSvcPort(struct AutofillSvcPort_s *h) -{ - if (!h) - return; - - g_rec_mutex_clear(&h->mutex); - - if (h->delegates) - g_list_free_full(h->delegates, free); - - if (h->proxy) - rpc_port_proxy_destroy(h->proxy); - - if (h->stub_appid) - free(h->stub_appid); - - free(h); -} - -int rpc_port_proxy_AutofillSvcPort_create(const char *stub_appid, rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data, rpc_port_proxy_AutofillSvcPort_h *h) -{ - struct AutofillSvcPort_s *handle; - int r; - - if (!stub_appid || !callback || !h) { - _E("Invalid parameter"); - return -1; - } - - handle = __create_AutofillSvcPort(stub_appid, callback, user_data); - if (!handle) - return -1; - - r = rpc_port_proxy_add_connected_event_cb(handle->proxy, __AutofillSvcPort_on_connected, handle); - if (r != 0) { - _E("Failed to add connected event cb. err = %d", r); - __destroy_AutofillSvcPort(handle); - return r; - } - - r = rpc_port_proxy_add_disconnected_event_cb(handle->proxy, __AutofillSvcPort_on_disconnected, handle); - if (r != 0) { - _E("Failed to add disconnected event cb. err = %d", r); - __destroy_AutofillSvcPort(handle); - return r; - } - - r = rpc_port_proxy_add_rejected_event_cb(handle->proxy, __AutofillSvcPort_on_rejected, handle); - if (r != 0) { - _E("Failed to add rejected event cb. err = %d", r); - __destroy_AutofillSvcPort(handle); - return r; - } - - r = rpc_port_proxy_add_received_event_cb(handle->proxy, __AutofillSvcPort_on_received, handle); - if (r != 0) { - _E("Failed to add received event cb. err = %d", r); - __destroy_AutofillSvcPort(handle); - return r; - } - - *h = handle; - - return 0; -} - -int rpc_port_proxy_AutofillSvcPort_connect(rpc_port_proxy_AutofillSvcPort_h h) -{ - int r; - - if (!h || !h->proxy) { - _E("Invalid parameter"); - return -1; - } - - r = rpc_port_proxy_connect(h->proxy, h->stub_appid, "AutofillSvcPort"); - if (r != 0) { - _E("Failed to connect AutofillSvcPort(%s)", h->stub_appid); - return r; - } - - return 0; -} - -int rpc_port_proxy_AutofillSvcPort_destroy(rpc_port_proxy_AutofillSvcPort_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - __destroy_AutofillSvcPort(h); - return 0; -} diff --git a/src/autofill_service_proxy.h b/src/autofill_service_proxy.h deleted file mode 100644 index 8a0700b..0000000 --- a/src/autofill_service_proxy.h +++ /dev/null @@ -1,346 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct autofill_svc_item_s *rpc_port_autofill_svc_item_h; - -int rpc_port_autofill_svc_item_create(rpc_port_autofill_svc_item_h *h); - -int rpc_port_autofill_svc_item_destroy(rpc_port_autofill_svc_item_h h); - -int rpc_port_autofill_svc_item_clone(rpc_port_autofill_svc_item_h h, rpc_port_autofill_svc_item_h *clone); - -int rpc_port_autofill_svc_item_set_id(rpc_port_autofill_svc_item_h h, const char *id); - -int rpc_port_autofill_svc_item_set_label(rpc_port_autofill_svc_item_h h, const char *label); - -int rpc_port_autofill_svc_item_set_value(rpc_port_autofill_svc_item_h h, const char *value); - -int rpc_port_autofill_svc_item_set_autofill_hint(rpc_port_autofill_svc_item_h h, int autofill_hint); - -int rpc_port_autofill_svc_item_set_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool is_sensitive_data); - -int rpc_port_autofill_svc_item_get_id(rpc_port_autofill_svc_item_h h, char **id); - -int rpc_port_autofill_svc_item_get_label(rpc_port_autofill_svc_item_h h, char **label); - -int rpc_port_autofill_svc_item_get_value(rpc_port_autofill_svc_item_h h, char **value); - -int rpc_port_autofill_svc_item_get_autofill_hint(rpc_port_autofill_svc_item_h h, int *autofill_hint); - -int rpc_port_autofill_svc_item_get_is_sensitive_data(rpc_port_autofill_svc_item_h h, bool *is_sensitive_data); - -typedef struct autofill_svc_view_info_s *rpc_port_autofill_svc_view_info_h; - -int rpc_port_autofill_svc_view_info_create(rpc_port_autofill_svc_view_info_h *h); - -int rpc_port_autofill_svc_view_info_destroy(rpc_port_autofill_svc_view_info_h h); - -int rpc_port_autofill_svc_view_info_clone(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_view_info_h *clone); - -int rpc_port_autofill_svc_view_info_set_app_id(rpc_port_autofill_svc_view_info_h h, const char *app_id); - -int rpc_port_autofill_svc_view_info_set_view_id(rpc_port_autofill_svc_view_info_h h, const char *view_id); - -int rpc_port_autofill_svc_view_info_add_items(rpc_port_autofill_svc_view_info_h h, rpc_port_autofill_svc_item_h items); - -int rpc_port_autofill_svc_view_info_get_app_id(rpc_port_autofill_svc_view_info_h h, char **app_id); - -int rpc_port_autofill_svc_view_info_get_view_id(rpc_port_autofill_svc_view_info_h h, char **view_id); - -int rpc_port_autofill_svc_view_info_foreach_items(rpc_port_autofill_svc_view_info_h h, - bool (*callback)(rpc_port_autofill_svc_item_h items, void *user_data), void *user_data); - -int rpc_port_autofill_svc_view_info_remove_items(rpc_port_autofill_svc_view_info_h h, unsigned int nth); - -int rpc_port_autofill_svc_view_info_get_items_length(rpc_port_autofill_svc_view_info_h h, unsigned int *length); - -typedef struct autofill_svc_save_item_s *rpc_port_autofill_svc_save_item_h; - -int rpc_port_autofill_svc_save_item_create(rpc_port_autofill_svc_save_item_h *h); - -int rpc_port_autofill_svc_save_item_destroy(rpc_port_autofill_svc_save_item_h h); - -int rpc_port_autofill_svc_save_item_clone(rpc_port_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h *clone); - -int rpc_port_autofill_svc_save_item_set_id(rpc_port_autofill_svc_save_item_h h, const char *id); - -int rpc_port_autofill_svc_save_item_set_label(rpc_port_autofill_svc_save_item_h h, const char *label); - -int rpc_port_autofill_svc_save_item_set_value(rpc_port_autofill_svc_save_item_h h, const char *value); - -int rpc_port_autofill_svc_save_item_set_autofill_hint(rpc_port_autofill_svc_save_item_h h, int autofill_hint); - -int rpc_port_autofill_svc_save_item_set_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool is_sensitive_data); - -int rpc_port_autofill_svc_save_item_get_id(rpc_port_autofill_svc_save_item_h h, char **id); - -int rpc_port_autofill_svc_save_item_get_label(rpc_port_autofill_svc_save_item_h h, char **label); - -int rpc_port_autofill_svc_save_item_get_value(rpc_port_autofill_svc_save_item_h h, char **value); - -int rpc_port_autofill_svc_save_item_get_autofill_hint(rpc_port_autofill_svc_save_item_h h, int *autofill_hint); - -int rpc_port_autofill_svc_save_item_get_is_sensitive_data(rpc_port_autofill_svc_save_item_h h, bool *is_sensitive_data); - -typedef struct autofill_svc_save_view_info_s *rpc_port_autofill_svc_save_view_info_h; - -int rpc_port_autofill_svc_save_view_info_create(rpc_port_autofill_svc_save_view_info_h *h); - -int rpc_port_autofill_svc_save_view_info_destroy(rpc_port_autofill_svc_save_view_info_h h); - -int rpc_port_autofill_svc_save_view_info_clone(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_view_info_h *clone); - -int rpc_port_autofill_svc_save_view_info_set_view_id(rpc_port_autofill_svc_save_view_info_h h, const char *view_id); - -int rpc_port_autofill_svc_save_view_info_add_items(rpc_port_autofill_svc_save_view_info_h h, rpc_port_autofill_svc_save_item_h items); - -int rpc_port_autofill_svc_save_view_info_get_view_id(rpc_port_autofill_svc_save_view_info_h h, char **view_id); - -int rpc_port_autofill_svc_save_view_info_foreach_items(rpc_port_autofill_svc_save_view_info_h h, - bool (*callback)(rpc_port_autofill_svc_save_item_h items, void *user_data), void *user_data); - -int rpc_port_autofill_svc_save_view_info_remove_items(rpc_port_autofill_svc_save_view_info_h h, unsigned int nth); - -int rpc_port_autofill_svc_save_view_info_get_items_length(rpc_port_autofill_svc_save_view_info_h h, unsigned int *length); - -typedef struct autofill_svc_auth_info_s *rpc_port_autofill_svc_auth_info_h; - -int rpc_port_autofill_svc_auth_info_create(rpc_port_autofill_svc_auth_info_h *h); - -int rpc_port_autofill_svc_auth_info_destroy(rpc_port_autofill_svc_auth_info_h h); - -int rpc_port_autofill_svc_auth_info_clone(rpc_port_autofill_svc_auth_info_h h, rpc_port_autofill_svc_auth_info_h *clone); - -int rpc_port_autofill_svc_auth_info_set_app_id(rpc_port_autofill_svc_auth_info_h h, const char *app_id); - -int rpc_port_autofill_svc_auth_info_set_view_id(rpc_port_autofill_svc_auth_info_h h, const char *view_id); - -int rpc_port_autofill_svc_auth_info_set_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool exist_autofill_data); - -int rpc_port_autofill_svc_auth_info_set_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool need_authentication); - -int rpc_port_autofill_svc_auth_info_set_service_name(rpc_port_autofill_svc_auth_info_h h, const char *service_name); - -int rpc_port_autofill_svc_auth_info_set_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, const char *service_logo_image_path); - -int rpc_port_autofill_svc_auth_info_set_service_message(rpc_port_autofill_svc_auth_info_h h, const char *service_message); - -int rpc_port_autofill_svc_auth_info_get_app_id(rpc_port_autofill_svc_auth_info_h h, char **app_id); - -int rpc_port_autofill_svc_auth_info_get_view_id(rpc_port_autofill_svc_auth_info_h h, char **view_id); - -int rpc_port_autofill_svc_auth_info_get_exist_autofill_data(rpc_port_autofill_svc_auth_info_h h, bool *exist_autofill_data); - -int rpc_port_autofill_svc_auth_info_get_need_authentication(rpc_port_autofill_svc_auth_info_h h, bool *need_authentication); - -int rpc_port_autofill_svc_auth_info_get_service_name(rpc_port_autofill_svc_auth_info_h h, char **service_name); - -int rpc_port_autofill_svc_auth_info_get_service_logo_image_path(rpc_port_autofill_svc_auth_info_h h, char **service_logo_image_path); - -int rpc_port_autofill_svc_auth_info_get_service_message(rpc_port_autofill_svc_auth_info_h h, char **service_message); - -typedef struct autofill_svc_response_item_s *rpc_port_autofill_svc_response_item_h; - -int rpc_port_autofill_svc_response_item_create(rpc_port_autofill_svc_response_item_h *h); - -int rpc_port_autofill_svc_response_item_destroy(rpc_port_autofill_svc_response_item_h h); - -int rpc_port_autofill_svc_response_item_clone(rpc_port_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h *clone); - -int rpc_port_autofill_svc_response_item_set_id(rpc_port_autofill_svc_response_item_h h, const char *id); - -int rpc_port_autofill_svc_response_item_set_presentation_text(rpc_port_autofill_svc_response_item_h h, const char *presentation_text); - -int rpc_port_autofill_svc_response_item_set_value(rpc_port_autofill_svc_response_item_h h, const char *value); - -int rpc_port_autofill_svc_response_item_get_id(rpc_port_autofill_svc_response_item_h h, char **id); - -int rpc_port_autofill_svc_response_item_get_presentation_text(rpc_port_autofill_svc_response_item_h h, char **presentation_text); - -int rpc_port_autofill_svc_response_item_get_value(rpc_port_autofill_svc_response_item_h h, char **value); - -typedef struct autofill_svc_response_group_s *rpc_port_autofill_svc_response_group_h; - -int rpc_port_autofill_svc_response_group_create(rpc_port_autofill_svc_response_group_h *h); - -int rpc_port_autofill_svc_response_group_destroy(rpc_port_autofill_svc_response_group_h h); - -int rpc_port_autofill_svc_response_group_clone(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h *clone); - -int rpc_port_autofill_svc_response_group_add_response_items(rpc_port_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_item_h response_items); - -int rpc_port_autofill_svc_response_group_foreach_response_items(rpc_port_autofill_svc_response_group_h h, - bool (*callback)(rpc_port_autofill_svc_response_item_h response_items, void *user_data), void *user_data); - -int rpc_port_autofill_svc_response_group_remove_response_items(rpc_port_autofill_svc_response_group_h h, unsigned int nth); - -int rpc_port_autofill_svc_response_group_get_response_items_length(rpc_port_autofill_svc_response_group_h h, unsigned int *length); - -typedef struct autofill_svc_fill_response_s *rpc_port_autofill_svc_fill_response_h; - -int rpc_port_autofill_svc_fill_response_create(rpc_port_autofill_svc_fill_response_h *h); - -int rpc_port_autofill_svc_fill_response_destroy(rpc_port_autofill_svc_fill_response_h h); - -int rpc_port_autofill_svc_fill_response_clone(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_fill_response_h *clone); - -int rpc_port_autofill_svc_fill_response_set_app_id(rpc_port_autofill_svc_fill_response_h h, const char *app_id); - -int rpc_port_autofill_svc_fill_response_set_view_id(rpc_port_autofill_svc_fill_response_h h, const char *view_id); - -int rpc_port_autofill_svc_fill_response_add_response_groups(rpc_port_autofill_svc_fill_response_h h, rpc_port_autofill_svc_response_group_h response_groups); - -int rpc_port_autofill_svc_fill_response_get_app_id(rpc_port_autofill_svc_fill_response_h h, char **app_id); - -int rpc_port_autofill_svc_fill_response_get_view_id(rpc_port_autofill_svc_fill_response_h h, char **view_id); - -int rpc_port_autofill_svc_fill_response_foreach_response_groups(rpc_port_autofill_svc_fill_response_h h, - bool (*callback)(rpc_port_autofill_svc_response_group_h response_groups, void *user_data), void *user_data); - -int rpc_port_autofill_svc_fill_response_remove_response_groups(rpc_port_autofill_svc_fill_response_h h, unsigned int nth); - -int rpc_port_autofill_svc_fill_response_get_response_groups_length(rpc_port_autofill_svc_fill_response_h h, unsigned int *length); - -typedef struct list_autofill_svc_item_s *rpc_port_list_autofill_svc_item_h; - -int rpc_port_list_autofill_svc_item_create(rpc_port_list_autofill_svc_item_h *h); - -int rpc_port_list_autofill_svc_item_destroy(rpc_port_list_autofill_svc_item_h h); - -int rpc_port_list_autofill_svc_item_clone(rpc_port_list_autofill_svc_item_h h, rpc_port_list_autofill_svc_item_h *clone); - -int rpc_port_list_autofill_svc_item_add_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, rpc_port_autofill_svc_item_h list_autofill_svc_items); - -int rpc_port_list_autofill_svc_item_foreach_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, - bool (*callback)(rpc_port_autofill_svc_item_h list_autofill_svc_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_svc_item_remove_list_autofill_svc_items(rpc_port_list_autofill_svc_item_h h, unsigned int nth); - -int rpc_port_list_autofill_svc_item_get_list_autofill_svc_items_length(rpc_port_list_autofill_svc_item_h h, unsigned int *length); - -typedef struct list_autofill_svc_response_group_s *rpc_port_list_autofill_svc_response_group_h; - -int rpc_port_list_autofill_svc_response_group_create(rpc_port_list_autofill_svc_response_group_h *h); - -int rpc_port_list_autofill_svc_response_group_destroy(rpc_port_list_autofill_svc_response_group_h h); - -int rpc_port_list_autofill_svc_response_group_clone(rpc_port_list_autofill_svc_response_group_h h, rpc_port_list_autofill_svc_response_group_h *clone); - -int rpc_port_list_autofill_svc_response_group_add_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups); - -int rpc_port_list_autofill_svc_response_group_foreach_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, - bool (*callback)(rpc_port_autofill_svc_response_group_h list_autofill_svc_response_groups, void *user_data), void *user_data); - -int rpc_port_list_autofill_svc_response_group_remove_list_autofill_svc_response_groups(rpc_port_list_autofill_svc_response_group_h h, unsigned int nth); - -int rpc_port_list_autofill_svc_response_group_get_list_autofill_svc_response_groups_length(rpc_port_list_autofill_svc_response_group_h h, unsigned int *length); - -typedef struct list_autofill_svc_response_item_s *rpc_port_list_autofill_svc_response_item_h; - -int rpc_port_list_autofill_svc_response_item_create(rpc_port_list_autofill_svc_response_item_h *h); - -int rpc_port_list_autofill_svc_response_item_destroy(rpc_port_list_autofill_svc_response_item_h h); - -int rpc_port_list_autofill_svc_response_item_clone(rpc_port_list_autofill_svc_response_item_h h, rpc_port_list_autofill_svc_response_item_h *clone); - -int rpc_port_list_autofill_svc_response_item_add_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items); - -int rpc_port_list_autofill_svc_response_item_foreach_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, - bool (*callback)(rpc_port_autofill_svc_response_item_h list_autofill_svc_response_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_svc_response_item_remove_list_autofill_svc_response_items(rpc_port_list_autofill_svc_response_item_h h, unsigned int nth); - -int rpc_port_list_autofill_svc_response_item_get_list_autofill_svc_response_items_length(rpc_port_list_autofill_svc_response_item_h h, unsigned int *length); - -typedef struct list_autofill_svc_save_item_s *rpc_port_list_autofill_svc_save_item_h; - -int rpc_port_list_autofill_svc_save_item_create(rpc_port_list_autofill_svc_save_item_h *h); - -int rpc_port_list_autofill_svc_save_item_destroy(rpc_port_list_autofill_svc_save_item_h h); - -int rpc_port_list_autofill_svc_save_item_clone(rpc_port_list_autofill_svc_save_item_h h, rpc_port_list_autofill_svc_save_item_h *clone); - -int rpc_port_list_autofill_svc_save_item_add_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items); - -int rpc_port_list_autofill_svc_save_item_foreach_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, - bool (*callback)(rpc_port_autofill_svc_save_item_h list_autofill_svc_save_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_svc_save_item_remove_list_autofill_svc_save_items(rpc_port_list_autofill_svc_save_item_h h, unsigned int nth); - -int rpc_port_list_autofill_svc_save_item_get_list_autofill_svc_save_items_length(rpc_port_list_autofill_svc_save_item_h h, unsigned int *length); - -typedef struct AutofillSvcPort_s *rpc_port_proxy_AutofillSvcPort_h; - -typedef struct { - void (*connected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); - void (*disconnected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); - void (*rejected)(rpc_port_proxy_AutofillSvcPort_h h, void *user_data); -} rpc_port_proxy_AutofillSvcPort_callback_s; - -typedef struct AutofillSvcPort_autofill_svc_auth_info_cb_s *rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h; - -typedef void (*AutofillSvcPort_autofill_svc_auth_info_cb)(void *user_data, int context_id, rpc_port_autofill_svc_auth_info_h auth_info); - -rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_create(AutofillSvcPort_autofill_svc_auth_info_cb callback, bool once, void *user_data); - -int rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate); - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_auth_info_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h delegate); - -typedef struct AutofillSvcPort_autofill_svc_fill_response_cb_s *rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h; - -typedef void (*AutofillSvcPort_autofill_svc_fill_response_cb)(void *user_data, int context_id, rpc_port_autofill_svc_fill_response_h response); - -rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_create(AutofillSvcPort_autofill_svc_fill_response_cb callback, bool once, void *user_data); - -int rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_destroy(rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate); - -int rpc_port_proxy_AutofillSvcPort_autofill_svc_fill_response_cb_dispose(rpc_port_proxy_AutofillSvcPort_h proxy, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h delegate); - -int rpc_port_proxy_AutofillSvcPort_create(const char *stub_appid, - rpc_port_proxy_AutofillSvcPort_callback_s *callback, void *user_data, - rpc_port_proxy_AutofillSvcPort_h *h); - -int rpc_port_proxy_AutofillSvcPort_connect(rpc_port_proxy_AutofillSvcPort_h h); - -int rpc_port_proxy_AutofillSvcPort_destroy(rpc_port_proxy_AutofillSvcPort_h h); - -int rpc_port_proxy_AutofillSvcPort_invoke_Register(rpc_port_proxy_AutofillSvcPort_h h, rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h auth_info_cb, rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h fill_response_cb); - -void rpc_port_proxy_AutofillSvcPort_invoke_Unregister(rpc_port_proxy_AutofillSvcPort_h h); - -void rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi); - -void rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_view_info_h vi); - -void rpc_port_proxy_AutofillSvcPort_invoke_commit(rpc_port_proxy_AutofillSvcPort_h h, int context_id, rpc_port_autofill_svc_save_view_info_h si); - -void rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(rpc_port_proxy_AutofillSvcPort_h h); - -#ifdef __cplusplus -} -#endif diff --git a/src/autofill_stub.c b/src/autofill_stub.c deleted file mode 100644 index 086ada2..0000000 --- a/src/autofill_stub.c +++ /dev/null @@ -1,4148 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "autofill_stub.h" - -#ifdef LOG_TAG -#undef LOG_TAG -#endif - -#define LOG_TAG "RPC_PORT_STUB" - -#ifdef _E -#undef _E -#endif - -#ifdef _W -#undef _W -#endif - -#ifdef _I -#undef _I -#endif - -#ifdef _D -#undef _D -#endif - -#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) -#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > "fmt, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__) - -typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data); - -struct autofill_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *label; - char *value; - int autofill_hint; - bool is_sensitive_data; -}; - -static void __autofill_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); - rpc_port_parcel_write_int32(parcel, h->autofill_hint); - rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); -} - -static void __autofill_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->label); - rpc_port_parcel_read_string(parcel, &h->value); - rpc_port_parcel_read_int32(parcel, &h->autofill_hint); - rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); -} - -int rpc_port_autofill_item_create(rpc_port_autofill_item_h *h) -{ - struct autofill_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_item_to; - handle->parcelable.from = __autofill_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_item_destroy(rpc_port_autofill_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->label) - free(h->label); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_item_clone(rpc_port_autofill_item_h h, rpc_port_autofill_item_h *clone) -{ - rpc_port_autofill_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_item_destroy(handle); - return -1; - } - } - - if (h->label) { - handle->label = strdup(h->label); - if (!handle->label) { - _E("Failed to duplicate h->label"); - rpc_port_autofill_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_item_destroy(handle); - return -1; - } - } - - handle->autofill_hint = h->autofill_hint; - handle->is_sensitive_data = h->is_sensitive_data; - *clone = handle; - - return 0; -} - -int rpc_port_autofill_item_set_id(rpc_port_autofill_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_set_label(rpc_port_autofill_item_h h, const char *label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (h->label) { - free(h->label); - h->label = NULL; - } - - h->label = strdup(label); - if (!h->label) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_set_value(rpc_port_autofill_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_set_autofill_hint(rpc_port_autofill_item_h h, int autofill_hint) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->autofill_hint = autofill_hint; - return 0; -} - -int rpc_port_autofill_item_set_is_sensitive_data(rpc_port_autofill_item_h h, bool is_sensitive_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->is_sensitive_data = is_sensitive_data; - return 0; -} - -int rpc_port_autofill_item_get_id(rpc_port_autofill_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_get_label(rpc_port_autofill_item_h h, char **label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (!h->label) { - _E("Invalid parameter: h->label is NULL"); - return -1; - } - - *label = strdup(h->label); - if (*label == NULL) { - _E("Failed to duplicate label"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_get_value(rpc_port_autofill_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_item_get_autofill_hint(rpc_port_autofill_item_h h, int *autofill_hint) -{ - if (!h || !autofill_hint) { - _E("Invalid parameter"); - return -1; - } - - *autofill_hint = h->autofill_hint; - return 0; -} - -int rpc_port_autofill_item_get_is_sensitive_data(rpc_port_autofill_item_h h, bool *is_sensitive_data) -{ - if (!h || !is_sensitive_data) { - _E("Invalid parameter"); - return -1; - } - - *is_sensitive_data = h->is_sensitive_data; - return 0; -} - -struct autofill_view_info_s { - rpc_port_parcelable_t parcelable; - char *view_id; - GList *items; -}; - -static void __autofill_view_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_view_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_item_h value = NULL; - - rpc_port_autofill_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->items = g_list_append(h->items, value); - } - } while (0); -} - -int rpc_port_autofill_view_info_create(rpc_port_autofill_view_info_h *h) -{ - struct autofill_view_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_view_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_view_info_to; - handle->parcelable.from = __autofill_view_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_view_info_destroy(rpc_port_autofill_view_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - if (value) - rpc_port_autofill_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_view_info_clone(rpc_port_autofill_view_info_h h, rpc_port_autofill_view_info_h *clone) -{ - rpc_port_autofill_view_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_view_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_view_info handle"); - return -1; - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_view_info_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_item_h new_value; - rpc_port_autofill_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_view_info_destroy(handle); - return -1; - } - - rpc_port_autofill_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_view_info_destroy(handle); - return -1; - } - - handle->items = g_list_append(handle->items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_view_info_set_view_id(rpc_port_autofill_view_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_view_info_add_items(rpc_port_autofill_view_info_h h, rpc_port_autofill_item_h items) -{ - if (!h || !items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_item_h value = NULL; - - rpc_port_autofill_item_clone(items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->items = g_list_append(h->items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_view_info_get_view_id(rpc_port_autofill_view_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_view_info_foreach_items(rpc_port_autofill_view_info_h h, - bool (*callback)(rpc_port_autofill_item_h items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_view_info_remove_items(rpc_port_autofill_view_info_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_item_h value = iter->data; - h->items = g_list_remove_link(h->items, iter); - rpc_port_autofill_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_view_info_get_items_length(rpc_port_autofill_view_info_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->items); - - return 0; -} - -struct autofill_save_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *label; - char *value; - int autofill_hint; - bool is_sensitive_data; -}; - -static void __autofill_save_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->label ? h->label : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); - rpc_port_parcel_write_int32(parcel, h->autofill_hint); - rpc_port_parcel_write_bool(parcel, h->is_sensitive_data); -} - -static void __autofill_save_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->label); - rpc_port_parcel_read_string(parcel, &h->value); - rpc_port_parcel_read_int32(parcel, &h->autofill_hint); - rpc_port_parcel_read_bool(parcel, &h->is_sensitive_data); -} - -int rpc_port_autofill_save_item_create(rpc_port_autofill_save_item_h *h) -{ - struct autofill_save_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_save_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_save_item_to; - handle->parcelable.from = __autofill_save_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_save_item_destroy(rpc_port_autofill_save_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->label) - free(h->label); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_save_item_clone(rpc_port_autofill_save_item_h h, rpc_port_autofill_save_item_h *clone) -{ - rpc_port_autofill_save_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_save_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_save_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_save_item_destroy(handle); - return -1; - } - } - - if (h->label) { - handle->label = strdup(h->label); - if (!handle->label) { - _E("Failed to duplicate h->label"); - rpc_port_autofill_save_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_save_item_destroy(handle); - return -1; - } - } - - handle->autofill_hint = h->autofill_hint; - handle->is_sensitive_data = h->is_sensitive_data; - *clone = handle; - - return 0; -} - -int rpc_port_autofill_save_item_set_id(rpc_port_autofill_save_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_set_label(rpc_port_autofill_save_item_h h, const char *label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (h->label) { - free(h->label); - h->label = NULL; - } - - h->label = strdup(label); - if (!h->label) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_set_value(rpc_port_autofill_save_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_set_autofill_hint(rpc_port_autofill_save_item_h h, int autofill_hint) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->autofill_hint = autofill_hint; - return 0; -} - -int rpc_port_autofill_save_item_set_is_sensitive_data(rpc_port_autofill_save_item_h h, bool is_sensitive_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->is_sensitive_data = is_sensitive_data; - return 0; -} - -int rpc_port_autofill_save_item_get_id(rpc_port_autofill_save_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_get_label(rpc_port_autofill_save_item_h h, char **label) -{ - if (!h || !label) { - _E("Invalid parameter"); - return -1; - } - - if (!h->label) { - _E("Invalid parameter: h->label is NULL"); - return -1; - } - - *label = strdup(h->label); - if (*label == NULL) { - _E("Failed to duplicate label"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_get_value(rpc_port_autofill_save_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_item_get_autofill_hint(rpc_port_autofill_save_item_h h, int *autofill_hint) -{ - if (!h || !autofill_hint) { - _E("Invalid parameter"); - return -1; - } - - *autofill_hint = h->autofill_hint; - return 0; -} - -int rpc_port_autofill_save_item_get_is_sensitive_data(rpc_port_autofill_save_item_h h, bool *is_sensitive_data) -{ - if (!h || !is_sensitive_data) { - _E("Invalid parameter"); - return -1; - } - - *is_sensitive_data = h->is_sensitive_data; - return 0; -} - -struct autofill_save_view_info_s { - rpc_port_parcelable_t parcelable; - char *view_id; - GList *items; -}; - -static void __autofill_save_view_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_save_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->items)); - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_save_view_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_save_view_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_save_item_h value = NULL; - - rpc_port_autofill_save_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->items = g_list_append(h->items, value); - } - } while (0); -} - -int rpc_port_autofill_save_view_info_create(rpc_port_autofill_save_view_info_h *h) -{ - struct autofill_save_view_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_save_view_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_save_view_info_to; - handle->parcelable.from = __autofill_save_view_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_save_view_info_destroy(rpc_port_autofill_save_view_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - if (value) - rpc_port_autofill_save_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_save_view_info_clone(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_view_info_h *clone) -{ - rpc_port_autofill_save_view_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_save_view_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_save_view_info handle"); - return -1; - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_save_view_info_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_save_item_h new_value; - rpc_port_autofill_save_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_save_view_info_destroy(handle); - return -1; - } - - rpc_port_autofill_save_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_save_view_info_destroy(handle); - return -1; - } - - handle->items = g_list_append(handle->items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_save_view_info_set_view_id(rpc_port_autofill_save_view_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_view_info_add_items(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_item_h items) -{ - if (!h || !items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_save_item_h value = NULL; - - rpc_port_autofill_save_item_clone(items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->items = g_list_append(h->items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_save_view_info_get_view_id(rpc_port_autofill_save_view_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_save_view_info_foreach_items(rpc_port_autofill_save_view_info_h h, - bool (*callback)(rpc_port_autofill_save_item_h items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_save_view_info_remove_items(rpc_port_autofill_save_view_info_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_save_item_h value = iter->data; - h->items = g_list_remove_link(h->items, iter); - rpc_port_autofill_save_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_save_view_info_get_items_length(rpc_port_autofill_save_view_info_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->items); - - return 0; -} - -struct autofill_auth_info_s { - rpc_port_parcelable_t parcelable; - char *view_id; - bool exist_autofill_data; - bool need_authentication; - char *service_name; - char *service_logo_image_path; - char *service_message; -}; - -static void __autofill_auth_info_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_auth_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_bool(parcel, h->exist_autofill_data); - rpc_port_parcel_write_bool(parcel, h->need_authentication); - rpc_port_parcel_write_string(parcel, h->service_name ? h->service_name : ""); - rpc_port_parcel_write_string(parcel, h->service_logo_image_path ? h->service_logo_image_path : ""); - rpc_port_parcel_write_string(parcel, h->service_message ? h->service_message : ""); -} - -static void __autofill_auth_info_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_auth_info_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->view_id); - rpc_port_parcel_read_bool(parcel, &h->exist_autofill_data); - rpc_port_parcel_read_bool(parcel, &h->need_authentication); - rpc_port_parcel_read_string(parcel, &h->service_name); - rpc_port_parcel_read_string(parcel, &h->service_logo_image_path); - rpc_port_parcel_read_string(parcel, &h->service_message); -} - -int rpc_port_autofill_auth_info_create(rpc_port_autofill_auth_info_h *h) -{ - struct autofill_auth_info_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_auth_info_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_auth_info_to; - handle->parcelable.from = __autofill_auth_info_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_auth_info_destroy(rpc_port_autofill_auth_info_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) - free(h->view_id); - - if (h->service_name) - free(h->service_name); - - if (h->service_logo_image_path) - free(h->service_logo_image_path); - - if (h->service_message) - free(h->service_message); - - free(h); - - return 0; -} - -int rpc_port_autofill_auth_info_clone(rpc_port_autofill_auth_info_h h, rpc_port_autofill_auth_info_h *clone) -{ - rpc_port_autofill_auth_info_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_auth_info_create(&handle); - if (!handle) { - _E("Failed to create autofill_auth_info handle"); - return -1; - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_auth_info_destroy(handle); - return -1; - } - } - - handle->exist_autofill_data = h->exist_autofill_data; - handle->need_authentication = h->need_authentication; - if (h->service_name) { - handle->service_name = strdup(h->service_name); - if (!handle->service_name) { - _E("Failed to duplicate h->service_name"); - rpc_port_autofill_auth_info_destroy(handle); - return -1; - } - } - - if (h->service_logo_image_path) { - handle->service_logo_image_path = strdup(h->service_logo_image_path); - if (!handle->service_logo_image_path) { - _E("Failed to duplicate h->service_logo_image_path"); - rpc_port_autofill_auth_info_destroy(handle); - return -1; - } - } - - if (h->service_message) { - handle->service_message = strdup(h->service_message); - if (!handle->service_message) { - _E("Failed to duplicate h->service_message"); - rpc_port_autofill_auth_info_destroy(handle); - return -1; - } - } - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_auth_info_set_view_id(rpc_port_autofill_auth_info_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_set_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool exist_autofill_data) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->exist_autofill_data = exist_autofill_data; - return 0; -} - -int rpc_port_autofill_auth_info_set_need_authentication(rpc_port_autofill_auth_info_h h, bool need_authentication) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - h->need_authentication = need_authentication; - return 0; -} - -int rpc_port_autofill_auth_info_set_service_name(rpc_port_autofill_auth_info_h h, const char *service_name) -{ - if (!h || !service_name) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_name) { - free(h->service_name); - h->service_name = NULL; - } - - h->service_name = strdup(service_name); - if (!h->service_name) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_set_service_logo_image_path(rpc_port_autofill_auth_info_h h, const char *service_logo_image_path) -{ - if (!h || !service_logo_image_path) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_logo_image_path) { - free(h->service_logo_image_path); - h->service_logo_image_path = NULL; - } - - h->service_logo_image_path = strdup(service_logo_image_path); - if (!h->service_logo_image_path) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_set_service_message(rpc_port_autofill_auth_info_h h, const char *service_message) -{ - if (!h || !service_message) { - _E("Invalid parameter"); - return -1; - } - - if (h->service_message) { - free(h->service_message); - h->service_message = NULL; - } - - h->service_message = strdup(service_message); - if (!h->service_message) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_get_view_id(rpc_port_autofill_auth_info_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_get_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool *exist_autofill_data) -{ - if (!h || !exist_autofill_data) { - _E("Invalid parameter"); - return -1; - } - - *exist_autofill_data = h->exist_autofill_data; - return 0; -} - -int rpc_port_autofill_auth_info_get_need_authentication(rpc_port_autofill_auth_info_h h, bool *need_authentication) -{ - if (!h || !need_authentication) { - _E("Invalid parameter"); - return -1; - } - - *need_authentication = h->need_authentication; - return 0; -} - -int rpc_port_autofill_auth_info_get_service_name(rpc_port_autofill_auth_info_h h, char **service_name) -{ - if (!h || !service_name) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_name) { - _E("Invalid parameter: h->service_name is NULL"); - return -1; - } - - *service_name = strdup(h->service_name); - if (*service_name == NULL) { - _E("Failed to duplicate service_name"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_get_service_logo_image_path(rpc_port_autofill_auth_info_h h, char **service_logo_image_path) -{ - if (!h || !service_logo_image_path) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_logo_image_path) { - _E("Invalid parameter: h->service_logo_image_path is NULL"); - return -1; - } - - *service_logo_image_path = strdup(h->service_logo_image_path); - if (*service_logo_image_path == NULL) { - _E("Failed to duplicate service_logo_image_path"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_auth_info_get_service_message(rpc_port_autofill_auth_info_h h, char **service_message) -{ - if (!h || !service_message) { - _E("Invalid parameter"); - return -1; - } - - if (!h->service_message) { - _E("Invalid parameter: h->service_message is NULL"); - return -1; - } - - *service_message = strdup(h->service_message); - if (*service_message == NULL) { - _E("Failed to duplicate service_message"); - return -1; - } - - return 0; -} - -struct autofill_response_item_s { - rpc_port_parcelable_t parcelable; - char *id; - char *presentation_text; - char *value; -}; - -static void __autofill_response_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->id ? h->id : ""); - rpc_port_parcel_write_string(parcel, h->presentation_text ? h->presentation_text : ""); - rpc_port_parcel_write_string(parcel, h->value ? h->value : ""); -} - -static void __autofill_response_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->id); - rpc_port_parcel_read_string(parcel, &h->presentation_text); - rpc_port_parcel_read_string(parcel, &h->value); -} - -int rpc_port_autofill_response_item_create(rpc_port_autofill_response_item_h *h) -{ - struct autofill_response_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_response_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_response_item_to; - handle->parcelable.from = __autofill_response_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_response_item_destroy(rpc_port_autofill_response_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) - free(h->id); - - if (h->presentation_text) - free(h->presentation_text); - - if (h->value) - free(h->value); - - free(h); - - return 0; -} - -int rpc_port_autofill_response_item_clone(rpc_port_autofill_response_item_h h, rpc_port_autofill_response_item_h *clone) -{ - rpc_port_autofill_response_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_response_item_create(&handle); - if (!handle) { - _E("Failed to create autofill_response_item handle"); - return -1; - } - - if (h->id) { - handle->id = strdup(h->id); - if (!handle->id) { - _E("Failed to duplicate h->id"); - rpc_port_autofill_response_item_destroy(handle); - return -1; - } - } - - if (h->presentation_text) { - handle->presentation_text = strdup(h->presentation_text); - if (!handle->presentation_text) { - _E("Failed to duplicate h->presentation_text"); - rpc_port_autofill_response_item_destroy(handle); - return -1; - } - } - - if (h->value) { - handle->value = strdup(h->value); - if (!handle->value) { - _E("Failed to duplicate h->value"); - rpc_port_autofill_response_item_destroy(handle); - return -1; - } - } - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_response_item_set_id(rpc_port_autofill_response_item_h h, const char *id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (h->id) { - free(h->id); - h->id = NULL; - } - - h->id = strdup(id); - if (!h->id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_response_item_set_presentation_text(rpc_port_autofill_response_item_h h, const char *presentation_text) -{ - if (!h || !presentation_text) { - _E("Invalid parameter"); - return -1; - } - - if (h->presentation_text) { - free(h->presentation_text); - h->presentation_text = NULL; - } - - h->presentation_text = strdup(presentation_text); - if (!h->presentation_text) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_response_item_set_value(rpc_port_autofill_response_item_h h, const char *value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (h->value) { - free(h->value); - h->value = NULL; - } - - h->value = strdup(value); - if (!h->value) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_response_item_get_id(rpc_port_autofill_response_item_h h, char **id) -{ - if (!h || !id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->id) { - _E("Invalid parameter: h->id is NULL"); - return -1; - } - - *id = strdup(h->id); - if (*id == NULL) { - _E("Failed to duplicate id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_response_item_get_presentation_text(rpc_port_autofill_response_item_h h, char **presentation_text) -{ - if (!h || !presentation_text) { - _E("Invalid parameter"); - return -1; - } - - if (!h->presentation_text) { - _E("Invalid parameter: h->presentation_text is NULL"); - return -1; - } - - *presentation_text = strdup(h->presentation_text); - if (*presentation_text == NULL) { - _E("Failed to duplicate presentation_text"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_response_item_get_value(rpc_port_autofill_response_item_h h, char **value) -{ - if (!h || !value) { - _E("Invalid parameter"); - return -1; - } - - if (!h->value) { - _E("Invalid parameter: h->value is NULL"); - return -1; - } - - *value = strdup(h->value); - if (*value == NULL) { - _E("Failed to duplicate value"); - return -1; - } - - return 0; -} - -struct autofill_response_group_s { - rpc_port_parcelable_t parcelable; - GList *response_items; -}; - -static void __autofill_response_group_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_items)); - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_response_group_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_response_item_h value = NULL; - - rpc_port_autofill_response_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->response_items = g_list_append(h->response_items, value); - } - } while (0); -} - -int rpc_port_autofill_response_group_create(rpc_port_autofill_response_group_h *h) -{ - struct autofill_response_group_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_response_group_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_response_group_to; - handle->parcelable.from = __autofill_response_group_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_response_group_destroy(rpc_port_autofill_response_group_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - if (value) - rpc_port_autofill_response_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->response_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_response_group_clone(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_group_h *clone) -{ - rpc_port_autofill_response_group_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_response_group_create(&handle); - if (!handle) { - _E("Failed to create autofill_response_group handle"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_response_item_h new_value; - rpc_port_autofill_response_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_response_group_destroy(handle); - return -1; - } - - rpc_port_autofill_response_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_response_group_destroy(handle); - return -1; - } - - handle->response_items = g_list_append(handle->response_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_response_group_add_response_items(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_item_h response_items) -{ - if (!h || !response_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_response_item_h value = NULL; - - rpc_port_autofill_response_item_clone(response_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->response_items = g_list_append(h->response_items, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_response_group_foreach_response_items(rpc_port_autofill_response_group_h h, - bool (*callback)(rpc_port_autofill_response_item_h response_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_response_group_remove_response_items(rpc_port_autofill_response_group_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->response_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_response_item_h value = iter->data; - h->response_items = g_list_remove_link(h->response_items, iter); - rpc_port_autofill_response_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_response_group_get_response_items_length(rpc_port_autofill_response_group_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->response_items); - - return 0; -} - -struct autofill_fill_response_s { - rpc_port_parcelable_t parcelable; - char *view_id; - GList *response_groups; -}; - -static void __autofill_fill_response_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_fill_response_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_string(parcel, h->view_id ? h->view_id : ""); - rpc_port_parcel_write_array_count(parcel, g_list_length(h->response_groups)); - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __autofill_fill_response_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_autofill_fill_response_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_string(parcel, &h->view_id); - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_response_group_h value = NULL; - - rpc_port_autofill_response_group_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->response_groups = g_list_append(h->response_groups, value); - } - } while (0); -} - -int rpc_port_autofill_fill_response_create(rpc_port_autofill_fill_response_h *h) -{ - struct autofill_fill_response_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct autofill_fill_response_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __autofill_fill_response_to; - handle->parcelable.from = __autofill_fill_response_from; - - *h = handle; - - return 0; -} - -int rpc_port_autofill_fill_response_destroy(rpc_port_autofill_fill_response_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) - free(h->view_id); - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - if (value) - rpc_port_autofill_response_group_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->response_groups); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_autofill_fill_response_clone(rpc_port_autofill_fill_response_h h, rpc_port_autofill_fill_response_h *clone) -{ - rpc_port_autofill_fill_response_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_autofill_fill_response_create(&handle); - if (!handle) { - _E("Failed to create autofill_fill_response handle"); - return -1; - } - - if (h->view_id) { - handle->view_id = strdup(h->view_id); - if (!handle->view_id) { - _E("Failed to duplicate h->view_id"); - rpc_port_autofill_fill_response_destroy(handle); - return -1; - } - } - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_response_group_h new_value; - rpc_port_autofill_response_group_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_autofill_fill_response_destroy(handle); - return -1; - } - - rpc_port_autofill_response_group_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_autofill_fill_response_destroy(handle); - return -1; - } - - handle->response_groups = g_list_append(handle->response_groups, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_autofill_fill_response_set_view_id(rpc_port_autofill_fill_response_h h, const char *view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (h->view_id) { - free(h->view_id); - h->view_id = NULL; - } - - h->view_id = strdup(view_id); - if (!h->view_id) { - _E("Failed to duplicate data"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_fill_response_add_response_groups(rpc_port_autofill_fill_response_h h, rpc_port_autofill_response_group_h response_groups) -{ - if (!h || !response_groups) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_response_group_h value = NULL; - - rpc_port_autofill_response_group_clone(response_groups, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->response_groups = g_list_append(h->response_groups, value); - } while (0); - - return 0; -} - -int rpc_port_autofill_fill_response_get_view_id(rpc_port_autofill_fill_response_h h, char **view_id) -{ - if (!h || !view_id) { - _E("Invalid parameter"); - return -1; - } - - if (!h->view_id) { - _E("Invalid parameter: h->view_id is NULL"); - return -1; - } - - *view_id = strdup(h->view_id); - if (*view_id == NULL) { - _E("Failed to duplicate view_id"); - return -1; - } - - return 0; -} - -int rpc_port_autofill_fill_response_foreach_response_groups(rpc_port_autofill_fill_response_h h, - bool (*callback)(rpc_port_autofill_response_group_h response_groups, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_autofill_fill_response_remove_response_groups(rpc_port_autofill_fill_response_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->response_groups, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_response_group_h value = iter->data; - h->response_groups = g_list_remove_link(h->response_groups, iter); - rpc_port_autofill_response_group_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_autofill_fill_response_get_response_groups_length(rpc_port_autofill_fill_response_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->response_groups); - - return 0; -} - -struct list_autofill_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_items; -}; - -static void __list_autofill_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_items)); - do { - GList *iter; - - iter = h->list_autofill_items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_item_h value = NULL; - - rpc_port_autofill_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_items = g_list_append(h->list_autofill_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_item_create(rpc_port_list_autofill_item_h *h) -{ - struct list_autofill_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_item_to; - handle->parcelable.from = __list_autofill_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_item_destroy(rpc_port_list_autofill_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - if (value) - rpc_port_autofill_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_item_clone(rpc_port_list_autofill_item_h h, rpc_port_list_autofill_item_h *clone) -{ - rpc_port_list_autofill_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_items; - while (iter) { - rpc_port_autofill_item_h new_value; - rpc_port_autofill_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_item_destroy(handle); - return -1; - } - - rpc_port_autofill_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_item_destroy(handle); - return -1; - } - - handle->list_autofill_items = g_list_append(handle->list_autofill_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_item_add_list_autofill_items(rpc_port_list_autofill_item_h h, rpc_port_autofill_item_h list_autofill_items) -{ - if (!h || !list_autofill_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_item_h value = NULL; - - rpc_port_autofill_item_clone(list_autofill_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_items = g_list_append(h->list_autofill_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_item_foreach_list_autofill_items(rpc_port_list_autofill_item_h h, - bool (*callback)(rpc_port_autofill_item_h list_autofill_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_items; - while (iter) { - rpc_port_autofill_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_item_remove_list_autofill_items(rpc_port_list_autofill_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_item_h value = iter->data; - h->list_autofill_items = g_list_remove_link(h->list_autofill_items, iter); - rpc_port_autofill_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_item_get_list_autofill_items_length(rpc_port_list_autofill_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_items); - - return 0; -} - -struct list_autofill_response_group_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_response_groups; -}; - -static void __list_autofill_response_group_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_response_groups)); - do { - GList *iter; - - iter = h->list_autofill_response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_response_group_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_response_group_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_response_group_h value = NULL; - - rpc_port_autofill_response_group_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_response_groups = g_list_append(h->list_autofill_response_groups, value); - } - } while (0); -} - -int rpc_port_list_autofill_response_group_create(rpc_port_list_autofill_response_group_h *h) -{ - struct list_autofill_response_group_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_response_group_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_response_group_to; - handle->parcelable.from = __list_autofill_response_group_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_response_group_destroy(rpc_port_list_autofill_response_group_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - if (value) - rpc_port_autofill_response_group_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_response_groups); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_response_group_clone(rpc_port_list_autofill_response_group_h h, rpc_port_list_autofill_response_group_h *clone) -{ - rpc_port_list_autofill_response_group_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_response_group_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_response_group handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_groups; - while (iter) { - rpc_port_autofill_response_group_h new_value; - rpc_port_autofill_response_group_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_response_group_destroy(handle); - return -1; - } - - rpc_port_autofill_response_group_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_response_group_destroy(handle); - return -1; - } - - handle->list_autofill_response_groups = g_list_append(handle->list_autofill_response_groups, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_response_group_add_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, rpc_port_autofill_response_group_h list_autofill_response_groups) -{ - if (!h || !list_autofill_response_groups) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_response_group_h value = NULL; - - rpc_port_autofill_response_group_clone(list_autofill_response_groups, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_response_groups = g_list_append(h->list_autofill_response_groups, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_response_group_foreach_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, - bool (*callback)(rpc_port_autofill_response_group_h list_autofill_response_groups, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_groups; - while (iter) { - rpc_port_autofill_response_group_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_response_group_remove_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_response_groups, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_response_group_h value = iter->data; - h->list_autofill_response_groups = g_list_remove_link(h->list_autofill_response_groups, iter); - rpc_port_autofill_response_group_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_response_group_get_list_autofill_response_groups_length(rpc_port_list_autofill_response_group_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_response_groups); - - return 0; -} - -struct list_autofill_response_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_response_items; -}; - -static void __list_autofill_response_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_response_items)); - do { - GList *iter; - - iter = h->list_autofill_response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_response_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_response_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_response_item_h value = NULL; - - rpc_port_autofill_response_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_response_items = g_list_append(h->list_autofill_response_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_response_item_create(rpc_port_list_autofill_response_item_h *h) -{ - struct list_autofill_response_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_response_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_response_item_to; - handle->parcelable.from = __list_autofill_response_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_response_item_destroy(rpc_port_list_autofill_response_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - if (value) - rpc_port_autofill_response_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_response_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_response_item_clone(rpc_port_list_autofill_response_item_h h, rpc_port_list_autofill_response_item_h *clone) -{ - rpc_port_list_autofill_response_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_response_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_response_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_items; - while (iter) { - rpc_port_autofill_response_item_h new_value; - rpc_port_autofill_response_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_response_item_destroy(handle); - return -1; - } - - rpc_port_autofill_response_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_response_item_destroy(handle); - return -1; - } - - handle->list_autofill_response_items = g_list_append(handle->list_autofill_response_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_response_item_add_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, rpc_port_autofill_response_item_h list_autofill_response_items) -{ - if (!h || !list_autofill_response_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_response_item_h value = NULL; - - rpc_port_autofill_response_item_clone(list_autofill_response_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_response_items = g_list_append(h->list_autofill_response_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_response_item_foreach_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, - bool (*callback)(rpc_port_autofill_response_item_h list_autofill_response_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_response_items; - while (iter) { - rpc_port_autofill_response_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_response_item_remove_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_response_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_response_item_h value = iter->data; - h->list_autofill_response_items = g_list_remove_link(h->list_autofill_response_items, iter); - rpc_port_autofill_response_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_response_item_get_list_autofill_response_items_length(rpc_port_list_autofill_response_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_response_items); - - return 0; -} - -struct list_autofill_save_item_s { - rpc_port_parcelable_t parcelable; - GList *list_autofill_save_items; -}; - -static void __list_autofill_save_item_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_array_count(parcel, g_list_length(h->list_autofill_save_items)); - do { - GList *iter; - - iter = h->list_autofill_save_items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - rpc_port_parcel_write(parcel, &value->parcelable, value); - } - } while (0); -} - -static void __list_autofill_save_item_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_list_autofill_save_item_h h = data; - - if (!parcel || !h) { - _E("Invalid parameter"); - return; - } - - do { - int len = 0; - - rpc_port_parcel_read_array_count(parcel, &len); - for (int i = 0; i < len; i++) { - rpc_port_autofill_save_item_h value = NULL; - - rpc_port_autofill_save_item_create(&value); - if (!value) { - _E("Failed to create handle"); - return; - } - - rpc_port_parcel_read(parcel, &value->parcelable, value); - h->list_autofill_save_items = g_list_append(h->list_autofill_save_items, value); - } - } while (0); -} - -int rpc_port_list_autofill_save_item_create(rpc_port_list_autofill_save_item_h *h) -{ - struct list_autofill_save_item_s *handle; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct list_autofill_save_item_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __list_autofill_save_item_to; - handle->parcelable.from = __list_autofill_save_item_from; - - *h = handle; - - return 0; -} - -int rpc_port_list_autofill_save_item_destroy(rpc_port_list_autofill_save_item_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_save_items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - if (value) - rpc_port_autofill_save_item_destroy(value); - - iter = g_list_next(iter); - } - g_list_free(h->list_autofill_save_items); - } while (0); - - free(h); - - return 0; -} - -int rpc_port_list_autofill_save_item_clone(rpc_port_list_autofill_save_item_h h, rpc_port_list_autofill_save_item_h *clone) -{ - rpc_port_list_autofill_save_item_h handle = NULL; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - rpc_port_list_autofill_save_item_create(&handle); - if (!handle) { - _E("Failed to create list_autofill_save_item handle"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_save_items; - while (iter) { - rpc_port_autofill_save_item_h new_value; - rpc_port_autofill_save_item_h value = iter->data; - - if (!value) { - _E("Error: value is NULL"); - rpc_port_list_autofill_save_item_destroy(handle); - return -1; - } - - rpc_port_autofill_save_item_clone(value, &new_value); - if (!new_value) { - _E("Failed to duplicate value"); - rpc_port_list_autofill_save_item_destroy(handle); - return -1; - } - - handle->list_autofill_save_items = g_list_append(handle->list_autofill_save_items, new_value); - iter = g_list_next(iter); - } - } while (0); - - *clone = handle; - - return 0; -} - -int rpc_port_list_autofill_save_item_add_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, rpc_port_autofill_save_item_h list_autofill_save_items) -{ - if (!h || !list_autofill_save_items) { - _E("Invalid parameter"); - return -1; - } - - do { - rpc_port_autofill_save_item_h value = NULL; - - rpc_port_autofill_save_item_clone(list_autofill_save_items, &value); - if (!value) { - _E("Out of memory"); - return -1; - } - - h->list_autofill_save_items = g_list_append(h->list_autofill_save_items, value); - } while (0); - - return 0; -} - -int rpc_port_list_autofill_save_item_foreach_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, - bool (*callback)(rpc_port_autofill_save_item_h list_autofill_save_items, void *user_data), void *user_data) -{ - if (!h || !callback) { - _E("Invalid parameter"); - return -1; - } - - do { - GList *iter; - - iter = h->list_autofill_save_items; - while (iter) { - rpc_port_autofill_save_item_h value = iter->data; - - iter = g_list_next(iter); - if (!value) { - _W("Warning: value is NULL"); - continue; - } - - bool ret = callback(value, user_data); - if (!ret) - break; - } - } while (0); - - return 0; -} - -int rpc_port_list_autofill_save_item_remove_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, unsigned int nth) -{ - GList *iter; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - iter = g_list_nth(h->list_autofill_save_items, nth); - if (iter == NULL) - return -1; - - rpc_port_autofill_save_item_h value = iter->data; - h->list_autofill_save_items = g_list_remove_link(h->list_autofill_save_items, iter); - rpc_port_autofill_save_item_destroy(value); - g_list_free(iter); - - return 0; -} - -int rpc_port_list_autofill_save_item_get_list_autofill_save_items_length(rpc_port_list_autofill_save_item_h h, unsigned int *length) -{ - if (!h || !length) { - _E("Invalid parameter"); - return -1; - } - - *length = g_list_length(h->list_autofill_save_items); - - return 0; -} - -enum AutofillAppPort_method_e { - AutofillAppPort_METHOD_Result, - AutofillAppPort_METHOD_Callback, - AutofillAppPort_METHOD_Register, - AutofillAppPort_METHOD_Unregister, - AutofillAppPort_METHOD_request_auth_info, - AutofillAppPort_METHOD_send_fill_request, - AutofillAppPort_METHOD_commit, -}; - -enum AutofillAppPort_delegate_e { - AutofillAppPort_DELEGATE_autofill_auth_info_received_cb = 1, - AutofillAppPort_DELEGATE_autofill_fill_response_received_cb = 2, -}; - -static rpc_port_stub_h __AutofillAppPort_stub; -static rpc_port_stub_AutofillAppPort_callback_s __AutofillAppPort_callback; -static void *__AutofillAppPort_user_data; -static GList *__AutofillAppPort_contexts; - -struct AutofillAppPort_context_s { - char *sender; - char *instance; - rpc_port_h port; - void *tag; - rpc_port_stub_AutofillAppPort_callback_s callback; - void *user_data; -}; - -static struct AutofillAppPort_context_s *__create_AutofillAppPort_context(const char *sender, const char *instance) -{ - struct AutofillAppPort_context_s *handle; - - handle = calloc(1, sizeof(struct AutofillAppPort_context_s)); - if (!handle) { - _E("Out of memory"); - return NULL; - } - - handle->sender = strdup(sender); - if (!handle->sender) { - _E("Out of memory"); - free(handle); - return NULL; - } - - handle->instance = strdup(instance); - if (!handle->instance) { - _E("Out of memory"); - free(handle->sender); - free(handle); - return NULL; - } - - handle->callback = __AutofillAppPort_callback; - handle->user_data = __AutofillAppPort_user_data; - - return handle; -} - -static void __destroy_AutofillAppPort_context(gpointer data) -{ - struct AutofillAppPort_context_s *handle = data; - - if (!handle) { - _E("Critical error!"); - return; - } - - free(handle->instance); - free(handle->sender); - free(handle); -} - -static struct AutofillAppPort_context_s *__find_AutofillAppPort_context(const char *instance) -{ - struct AutofillAppPort_context_s *handle; - GList *iter; - - iter = __AutofillAppPort_contexts; - while (iter) { - handle = (struct AutofillAppPort_context_s *)iter->data; - if (!strcmp(handle->instance, instance)) - return handle; - iter = g_list_next(iter); - } - - return NULL; -} - -int rpc_port_stub_AutofillAppPort_context_set_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void *tag) -{ - if (!ctx) { - _E("Invalid parameter"); - return -1; - } - - ctx->tag = tag; - - return 0; -} - -int rpc_port_stub_AutofillAppPort_context_get_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void **tag) -{ - if (!ctx || !tag) { - _E("Invalid parameter"); - return -1; - } - - *tag = ctx->tag; - - return 0; -} - -int rpc_port_stub_AutofillAppPort_context_get_sender(rpc_port_stub_AutofillAppPort_context_h ctx, char **sender) -{ - if (!ctx || !sender) { - _E("Invalid parameter"); - return -1; - } - - *sender = strdup(ctx->sender); - if (*sender == NULL) { - _E("Out of memory"); - return -1; - } - - return 0; -} - -struct AutofillAppPort_autofill_auth_info_received_cb_s { - rpc_port_parcelable_t parcelable; - rpc_port_h port; - int id; - int seq_id; - bool once; - bool valid; -}; - -static void __AutofillAppPort_autofill_auth_info_received_cb_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_int32(parcel, handle->id); - rpc_port_parcel_write_int32(parcel, handle->seq_id); - rpc_port_parcel_write_bool(parcel, handle->once); -} - -static void __AutofillAppPort_autofill_auth_info_received_cb_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_int32(parcel, &handle->id); - rpc_port_parcel_read_int32(parcel, &handle->seq_id); - rpc_port_parcel_read_bool(parcel, &handle->once); -} - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_create(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *h) -{ - struct AutofillAppPort_autofill_auth_info_received_cb_s *handle; - static int seq_num; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct AutofillAppPort_autofill_auth_info_received_cb_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __AutofillAppPort_autofill_auth_info_received_cb_to; - handle->parcelable.from = __AutofillAppPort_autofill_auth_info_received_cb_from; - handle->id = AutofillAppPort_DELEGATE_autofill_auth_info_received_cb; - handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; - handle->once = false; - handle->valid = true; - - *h = handle; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - free(h); - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_clone(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *clone) -{ - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h handle; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct AutofillAppPort_autofill_auth_info_received_cb_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable = h->parcelable; - handle->port = h->port; - handle->id = h->id; - handle->seq_id = h->seq_id; - handle->once = h->once; - handle->valid = h->valid; - - *clone = handle; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_autofill_auth_info_h auth_info) -{ - rpc_port_parcel_h parcel = NULL; - - if (!h || !h->port) { - _E("Invalid parameter"); - return -1; - } - - if (h->once && !h->valid) { - _E("Invalid callback"); - return -1; - } - - rpc_port_parcel_create(&parcel); - if (!parcel) { - _E("Failed to create parcel"); - return -1; - } - - rpc_port_parcel_write_int32(parcel, AutofillAppPort_METHOD_Callback); - rpc_port_parcel_write(parcel, &h->parcelable, h); - rpc_port_parcel_write(parcel, &auth_info->parcelable, auth_info); - - rpc_port_parcel_send(parcel, h->port); - rpc_port_parcel_destroy(parcel); - h->valid = false; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_set_port(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_h port) -{ - if (!h || !port) { - _E("Invalid parameter"); - return -1; - } - - h->port = port; - - return 0; -} - -struct AutofillAppPort_autofill_fill_response_received_cb_s { - rpc_port_parcelable_t parcelable; - rpc_port_h port; - int id; - int seq_id; - bool once; - bool valid; -}; - -static void __AutofillAppPort_autofill_fill_response_received_cb_to(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_write_int32(parcel, handle->id); - rpc_port_parcel_write_int32(parcel, handle->seq_id); - rpc_port_parcel_write_bool(parcel, handle->once); -} - -static void __AutofillAppPort_autofill_fill_response_received_cb_from(rpc_port_parcel_h parcel, void *data) -{ - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle = data; - - if (!handle) { - _E("Invalid parameter"); - return; - } - - rpc_port_parcel_read_int32(parcel, &handle->id); - rpc_port_parcel_read_int32(parcel, &handle->seq_id); - rpc_port_parcel_read_bool(parcel, &handle->once); -} - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_create(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *h) -{ - struct AutofillAppPort_autofill_fill_response_received_cb_s *handle; - static int seq_num; - - if (!h) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct AutofillAppPort_autofill_fill_response_received_cb_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable.to = __AutofillAppPort_autofill_fill_response_received_cb_to; - handle->parcelable.from = __AutofillAppPort_autofill_fill_response_received_cb_from; - handle->id = AutofillAppPort_DELEGATE_autofill_fill_response_received_cb; - handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1; - handle->once = false; - handle->valid = true; - - *h = handle; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h) -{ - if (!h) { - _E("Invalid parameter"); - return -1; - } - - free(h); - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_clone(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *clone) -{ - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h handle; - - if (!h || !clone) { - _E("Invalid parameter"); - return -1; - } - - handle = calloc(1, sizeof(struct AutofillAppPort_autofill_fill_response_received_cb_s)); - if (!handle) { - _E("Out of memory"); - return -1; - } - - handle->parcelable = h->parcelable; - handle->port = h->port; - handle->id = h->id; - handle->seq_id = h->seq_id; - handle->once = h->once; - handle->valid = h->valid; - - *clone = handle; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_autofill_fill_response_h response) -{ - rpc_port_parcel_h parcel = NULL; - - if (!h || !h->port) { - _E("Invalid parameter"); - return -1; - } - - if (h->once && !h->valid) { - _E("Invalid callback"); - return -1; - } - - rpc_port_parcel_create(&parcel); - if (!parcel) { - _E("Failed to create parcel"); - return -1; - } - - rpc_port_parcel_write_int32(parcel, AutofillAppPort_METHOD_Callback); - rpc_port_parcel_write(parcel, &h->parcelable, h); - rpc_port_parcel_write(parcel, &response->parcelable, response); - - rpc_port_parcel_send(parcel, h->port); - rpc_port_parcel_destroy(parcel); - h->valid = false; - - return 0; -} - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_set_port(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_h port) -{ - if (!h || !port) { - _E("Invalid parameter"); - return -1; - } - - h->port = port; - - return 0; -} - -static int __AutofillAppPort_method_Register(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - int context_id; - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb = NULL; - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_cb = NULL; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_create(&auth_info_cb); - - if (!auth_info_cb) { - _E("Failed to create handle"); - return -1; - } - - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_set_port(auth_info_cb, callback_port); - rpc_port_parcel_read(parcel, &auth_info_cb->parcelable, auth_info_cb); - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_create(&fill_response_cb); - - if (!fill_response_cb) { - _E("Failed to create handle"); - return -1; - } - - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_set_port(fill_response_cb, callback_port); - rpc_port_parcel_read(parcel, &fill_response_cb->parcelable, fill_response_cb); - - int ret = context->callback.Register(context, context_id, auth_info_cb, fill_response_cb, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); - rpc_port_parcel_write_int32(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(auth_info_cb); - rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(fill_response_cb); - return 0; -} - -static int __AutofillAppPort_method_Unregister(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - int context_id; - - rpc_port_parcel_read_int32(parcel, &context_id); - - context->callback.Unregister(context, context_id, context->user_data); - - return 0; -} - -static int __AutofillAppPort_method_request_auth_info(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - int context_id; - rpc_port_autofill_view_info_h vi = NULL; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_autofill_view_info_create(&vi); - rpc_port_parcel_read(parcel, &vi->parcelable, vi); - - int ret = context->callback.request_auth_info(context, context_id, vi, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); - rpc_port_parcel_write_int32(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - rpc_port_autofill_view_info_destroy(vi); - return 0; -} - -static int __AutofillAppPort_method_send_fill_request(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - int context_id; - rpc_port_autofill_view_info_h vi = NULL; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_autofill_view_info_create(&vi); - rpc_port_parcel_read(parcel, &vi->parcelable, vi); - - int ret = context->callback.send_fill_request(context, context_id, vi, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); - rpc_port_parcel_write_int32(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - rpc_port_autofill_view_info_destroy(vi); - return 0; -} - -static int __AutofillAppPort_method_commit(rpc_port_h port, rpc_port_parcel_h parcel, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context = data; - rpc_port_h callback_port; - int r; - - r = rpc_port_stub_get_port(__AutofillAppPort_stub, RPC_PORT_PORT_CALLBACK, context->instance, &callback_port); - if (r != 0) { - _E("Failed to get callback port"); - return -1; - } - - int context_id; - rpc_port_autofill_save_view_info_h vi = NULL; - - rpc_port_parcel_read_int32(parcel, &context_id); - rpc_port_autofill_save_view_info_create(&vi); - rpc_port_parcel_read(parcel, &vi->parcelable, vi); - - int ret = context->callback.commit(context, context_id, vi, context->user_data); - do { - rpc_port_parcel_h result; - - rpc_port_parcel_create(&result); - rpc_port_parcel_write_int32(result, AutofillAppPort_METHOD_Result); - rpc_port_parcel_write_int32(result, ret); - rpc_port_parcel_send(result, port); - rpc_port_parcel_destroy(result); - } while (0); - - rpc_port_autofill_save_view_info_destroy(vi); - return 0; -} - -static stub_method __AutofillAppPort_method_table[] = { - [AutofillAppPort_METHOD_Register] = __AutofillAppPort_method_Register, - [AutofillAppPort_METHOD_Unregister] = __AutofillAppPort_method_Unregister, - [AutofillAppPort_METHOD_request_auth_info] = __AutofillAppPort_method_request_auth_info, - [AutofillAppPort_METHOD_send_fill_request] = __AutofillAppPort_method_send_fill_request, - [AutofillAppPort_METHOD_commit] = __AutofillAppPort_method_commit, -}; - -static void __AutofillAppPort_on_connected(const char *sender, const char *instance, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __create_AutofillAppPort_context(sender, instance); - if (!context) - return; - - if (context->callback.create) - context->callback.create(context, context->user_data); - __AutofillAppPort_contexts = g_list_append(__AutofillAppPort_contexts, context); -} - -static void __AutofillAppPort_on_disconnected(const char *sender, const char *instance, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __find_AutofillAppPort_context(instance); - if (!context) - return; - - if (context->callback.terminate) - context->callback.terminate(context, context->user_data); - __AutofillAppPort_contexts = g_list_remove(__AutofillAppPort_contexts, context); - __destroy_AutofillAppPort_context(context); -} - -static int __AutofillAppPort_on_received(const char *sender, const char *instance, rpc_port_h port, void *data) -{ - rpc_port_stub_AutofillAppPort_context_h context; - rpc_port_parcel_h parcel; - int cmd = -1; - int r; - - _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance); - context = __find_AutofillAppPort_context(instance); - if (!context) { - _E("Failed to find AutofillAppPort context(%s)", instance); - return -1; - } - - context->port = port; - r = rpc_port_parcel_create_from_port(&parcel, port); - if (r != 0) { - _E("Failed to create parcel from port"); - return r; - } - - rpc_port_parcel_read_int32(parcel, &cmd); - if (cmd > 1 && cmd < (sizeof(__AutofillAppPort_method_table) / sizeof(__AutofillAppPort_method_table[0]))) { - if (__AutofillAppPort_method_table[cmd]) - r = __AutofillAppPort_method_table[cmd](port, parcel, context); - } else { - _E("Unknown Command(%d)", cmd); - r = -1; - } - - rpc_port_parcel_destroy(parcel); - - return r; -} - -static int __AutofillAppPort_add_privileges(void) -{ - - return 0; -} - -int rpc_port_stub_AutofillAppPort_register(rpc_port_stub_AutofillAppPort_callback_s *callback, void *user_data) -{ - int r; - - if (__AutofillAppPort_stub) { - _W("Already exists"); - return -1; - } - - if (!callback) { - _E("Invalid parameter"); - return -1; - } - - __AutofillAppPort_callback = *callback; - __AutofillAppPort_user_data = user_data; - r = rpc_port_stub_create(&__AutofillAppPort_stub, "AutofillAppPort"); - if (r != 0) { - _E("Failed to create stub handle"); - return r; - } - - r = rpc_port_stub_add_received_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_received, NULL); - if (r != 0) { - _E("Failed to add received event callback"); - rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - return r; - } - - r = rpc_port_stub_add_connected_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_connected, NULL); - if (r != 0) { - _E("Failed to add connected event callback"); - rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - return r; - } - - r = rpc_port_stub_add_disconnected_event_cb(__AutofillAppPort_stub, __AutofillAppPort_on_disconnected, NULL); - if (r != 0) { - _E("Failed to add disconnected event callback"); - rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - return r; - } - - r = __AutofillAppPort_add_privileges(); - if (r != 0) { - _E("Failed to add privileges"); - rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - return r; - } - - r = rpc_port_stub_listen(__AutofillAppPort_stub); - if (r != 0) { - _E("Failed to listen stub"); - rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - return r; - } - - return 0; -} - -int rpc_port_stub_AutofillAppPort_unregister(void) -{ - int r; - - if (!__AutofillAppPort_stub) - return -1; - - if (__AutofillAppPort_contexts) { - g_list_free_full(__AutofillAppPort_contexts, __destroy_AutofillAppPort_context); - __AutofillAppPort_contexts = NULL; - } - - r = rpc_port_stub_destroy(__AutofillAppPort_stub); - __AutofillAppPort_stub = NULL; - - return r; -} - -int rpc_port_stub_AutofillAppPort_get_client_number(unsigned int *n) -{ - if (!n) { - _E("Invalid parameter"); - return -1; - } - - if (!__AutofillAppPort_stub) { - _E("AutofillAppPort Stub is not ready"); - return -1; - } - - *n = g_list_length(__AutofillAppPort_contexts); - - return 0; -} diff --git a/src/autofill_stub.h b/src/autofill_stub.h deleted file mode 100644 index 9a3682c..0000000 --- a/src/autofill_stub.h +++ /dev/null @@ -1,327 +0,0 @@ -/* - * Generated by tidlc 1.3.2. - * - * Copyright (c) 2018 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct autofill_item_s *rpc_port_autofill_item_h; - -int rpc_port_autofill_item_create(rpc_port_autofill_item_h *h); - -int rpc_port_autofill_item_destroy(rpc_port_autofill_item_h h); - -int rpc_port_autofill_item_clone(rpc_port_autofill_item_h h, rpc_port_autofill_item_h *clone); - -int rpc_port_autofill_item_set_id(rpc_port_autofill_item_h h, const char *id); - -int rpc_port_autofill_item_set_label(rpc_port_autofill_item_h h, const char *label); - -int rpc_port_autofill_item_set_value(rpc_port_autofill_item_h h, const char *value); - -int rpc_port_autofill_item_set_autofill_hint(rpc_port_autofill_item_h h, int autofill_hint); - -int rpc_port_autofill_item_set_is_sensitive_data(rpc_port_autofill_item_h h, bool is_sensitive_data); - -int rpc_port_autofill_item_get_id(rpc_port_autofill_item_h h, char **id); - -int rpc_port_autofill_item_get_label(rpc_port_autofill_item_h h, char **label); - -int rpc_port_autofill_item_get_value(rpc_port_autofill_item_h h, char **value); - -int rpc_port_autofill_item_get_autofill_hint(rpc_port_autofill_item_h h, int *autofill_hint); - -int rpc_port_autofill_item_get_is_sensitive_data(rpc_port_autofill_item_h h, bool *is_sensitive_data); - -typedef struct autofill_view_info_s *rpc_port_autofill_view_info_h; - -int rpc_port_autofill_view_info_create(rpc_port_autofill_view_info_h *h); - -int rpc_port_autofill_view_info_destroy(rpc_port_autofill_view_info_h h); - -int rpc_port_autofill_view_info_clone(rpc_port_autofill_view_info_h h, rpc_port_autofill_view_info_h *clone); - -int rpc_port_autofill_view_info_set_view_id(rpc_port_autofill_view_info_h h, const char *view_id); - -int rpc_port_autofill_view_info_add_items(rpc_port_autofill_view_info_h h, rpc_port_autofill_item_h items); - -int rpc_port_autofill_view_info_get_view_id(rpc_port_autofill_view_info_h h, char **view_id); - -int rpc_port_autofill_view_info_foreach_items(rpc_port_autofill_view_info_h h, - bool (*callback)(rpc_port_autofill_item_h items, void *user_data), void *user_data); - -int rpc_port_autofill_view_info_remove_items(rpc_port_autofill_view_info_h h, unsigned int nth); - -int rpc_port_autofill_view_info_get_items_length(rpc_port_autofill_view_info_h h, unsigned int *length); - -typedef struct autofill_save_item_s *rpc_port_autofill_save_item_h; - -int rpc_port_autofill_save_item_create(rpc_port_autofill_save_item_h *h); - -int rpc_port_autofill_save_item_destroy(rpc_port_autofill_save_item_h h); - -int rpc_port_autofill_save_item_clone(rpc_port_autofill_save_item_h h, rpc_port_autofill_save_item_h *clone); - -int rpc_port_autofill_save_item_set_id(rpc_port_autofill_save_item_h h, const char *id); - -int rpc_port_autofill_save_item_set_label(rpc_port_autofill_save_item_h h, const char *label); - -int rpc_port_autofill_save_item_set_value(rpc_port_autofill_save_item_h h, const char *value); - -int rpc_port_autofill_save_item_set_autofill_hint(rpc_port_autofill_save_item_h h, int autofill_hint); - -int rpc_port_autofill_save_item_set_is_sensitive_data(rpc_port_autofill_save_item_h h, bool is_sensitive_data); - -int rpc_port_autofill_save_item_get_id(rpc_port_autofill_save_item_h h, char **id); - -int rpc_port_autofill_save_item_get_label(rpc_port_autofill_save_item_h h, char **label); - -int rpc_port_autofill_save_item_get_value(rpc_port_autofill_save_item_h h, char **value); - -int rpc_port_autofill_save_item_get_autofill_hint(rpc_port_autofill_save_item_h h, int *autofill_hint); - -int rpc_port_autofill_save_item_get_is_sensitive_data(rpc_port_autofill_save_item_h h, bool *is_sensitive_data); - -typedef struct autofill_save_view_info_s *rpc_port_autofill_save_view_info_h; - -int rpc_port_autofill_save_view_info_create(rpc_port_autofill_save_view_info_h *h); - -int rpc_port_autofill_save_view_info_destroy(rpc_port_autofill_save_view_info_h h); - -int rpc_port_autofill_save_view_info_clone(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_view_info_h *clone); - -int rpc_port_autofill_save_view_info_set_view_id(rpc_port_autofill_save_view_info_h h, const char *view_id); - -int rpc_port_autofill_save_view_info_add_items(rpc_port_autofill_save_view_info_h h, rpc_port_autofill_save_item_h items); - -int rpc_port_autofill_save_view_info_get_view_id(rpc_port_autofill_save_view_info_h h, char **view_id); - -int rpc_port_autofill_save_view_info_foreach_items(rpc_port_autofill_save_view_info_h h, - bool (*callback)(rpc_port_autofill_save_item_h items, void *user_data), void *user_data); - -int rpc_port_autofill_save_view_info_remove_items(rpc_port_autofill_save_view_info_h h, unsigned int nth); - -int rpc_port_autofill_save_view_info_get_items_length(rpc_port_autofill_save_view_info_h h, unsigned int *length); - -typedef struct autofill_auth_info_s *rpc_port_autofill_auth_info_h; - -int rpc_port_autofill_auth_info_create(rpc_port_autofill_auth_info_h *h); - -int rpc_port_autofill_auth_info_destroy(rpc_port_autofill_auth_info_h h); - -int rpc_port_autofill_auth_info_clone(rpc_port_autofill_auth_info_h h, rpc_port_autofill_auth_info_h *clone); - -int rpc_port_autofill_auth_info_set_view_id(rpc_port_autofill_auth_info_h h, const char *view_id); - -int rpc_port_autofill_auth_info_set_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool exist_autofill_data); - -int rpc_port_autofill_auth_info_set_need_authentication(rpc_port_autofill_auth_info_h h, bool need_authentication); - -int rpc_port_autofill_auth_info_set_service_name(rpc_port_autofill_auth_info_h h, const char *service_name); - -int rpc_port_autofill_auth_info_set_service_logo_image_path(rpc_port_autofill_auth_info_h h, const char *service_logo_image_path); - -int rpc_port_autofill_auth_info_set_service_message(rpc_port_autofill_auth_info_h h, const char *service_message); - -int rpc_port_autofill_auth_info_get_view_id(rpc_port_autofill_auth_info_h h, char **view_id); - -int rpc_port_autofill_auth_info_get_exist_autofill_data(rpc_port_autofill_auth_info_h h, bool *exist_autofill_data); - -int rpc_port_autofill_auth_info_get_need_authentication(rpc_port_autofill_auth_info_h h, bool *need_authentication); - -int rpc_port_autofill_auth_info_get_service_name(rpc_port_autofill_auth_info_h h, char **service_name); - -int rpc_port_autofill_auth_info_get_service_logo_image_path(rpc_port_autofill_auth_info_h h, char **service_logo_image_path); - -int rpc_port_autofill_auth_info_get_service_message(rpc_port_autofill_auth_info_h h, char **service_message); - -typedef struct autofill_response_item_s *rpc_port_autofill_response_item_h; - -int rpc_port_autofill_response_item_create(rpc_port_autofill_response_item_h *h); - -int rpc_port_autofill_response_item_destroy(rpc_port_autofill_response_item_h h); - -int rpc_port_autofill_response_item_clone(rpc_port_autofill_response_item_h h, rpc_port_autofill_response_item_h *clone); - -int rpc_port_autofill_response_item_set_id(rpc_port_autofill_response_item_h h, const char *id); - -int rpc_port_autofill_response_item_set_presentation_text(rpc_port_autofill_response_item_h h, const char *presentation_text); - -int rpc_port_autofill_response_item_set_value(rpc_port_autofill_response_item_h h, const char *value); - -int rpc_port_autofill_response_item_get_id(rpc_port_autofill_response_item_h h, char **id); - -int rpc_port_autofill_response_item_get_presentation_text(rpc_port_autofill_response_item_h h, char **presentation_text); - -int rpc_port_autofill_response_item_get_value(rpc_port_autofill_response_item_h h, char **value); - -typedef struct autofill_response_group_s *rpc_port_autofill_response_group_h; - -int rpc_port_autofill_response_group_create(rpc_port_autofill_response_group_h *h); - -int rpc_port_autofill_response_group_destroy(rpc_port_autofill_response_group_h h); - -int rpc_port_autofill_response_group_clone(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_group_h *clone); - -int rpc_port_autofill_response_group_add_response_items(rpc_port_autofill_response_group_h h, rpc_port_autofill_response_item_h response_items); - -int rpc_port_autofill_response_group_foreach_response_items(rpc_port_autofill_response_group_h h, - bool (*callback)(rpc_port_autofill_response_item_h response_items, void *user_data), void *user_data); - -int rpc_port_autofill_response_group_remove_response_items(rpc_port_autofill_response_group_h h, unsigned int nth); - -int rpc_port_autofill_response_group_get_response_items_length(rpc_port_autofill_response_group_h h, unsigned int *length); - -typedef struct autofill_fill_response_s *rpc_port_autofill_fill_response_h; - -int rpc_port_autofill_fill_response_create(rpc_port_autofill_fill_response_h *h); - -int rpc_port_autofill_fill_response_destroy(rpc_port_autofill_fill_response_h h); - -int rpc_port_autofill_fill_response_clone(rpc_port_autofill_fill_response_h h, rpc_port_autofill_fill_response_h *clone); - -int rpc_port_autofill_fill_response_set_view_id(rpc_port_autofill_fill_response_h h, const char *view_id); - -int rpc_port_autofill_fill_response_add_response_groups(rpc_port_autofill_fill_response_h h, rpc_port_autofill_response_group_h response_groups); - -int rpc_port_autofill_fill_response_get_view_id(rpc_port_autofill_fill_response_h h, char **view_id); - -int rpc_port_autofill_fill_response_foreach_response_groups(rpc_port_autofill_fill_response_h h, - bool (*callback)(rpc_port_autofill_response_group_h response_groups, void *user_data), void *user_data); - -int rpc_port_autofill_fill_response_remove_response_groups(rpc_port_autofill_fill_response_h h, unsigned int nth); - -int rpc_port_autofill_fill_response_get_response_groups_length(rpc_port_autofill_fill_response_h h, unsigned int *length); - -typedef struct list_autofill_item_s *rpc_port_list_autofill_item_h; - -int rpc_port_list_autofill_item_create(rpc_port_list_autofill_item_h *h); - -int rpc_port_list_autofill_item_destroy(rpc_port_list_autofill_item_h h); - -int rpc_port_list_autofill_item_clone(rpc_port_list_autofill_item_h h, rpc_port_list_autofill_item_h *clone); - -int rpc_port_list_autofill_item_add_list_autofill_items(rpc_port_list_autofill_item_h h, rpc_port_autofill_item_h list_autofill_items); - -int rpc_port_list_autofill_item_foreach_list_autofill_items(rpc_port_list_autofill_item_h h, - bool (*callback)(rpc_port_autofill_item_h list_autofill_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_item_remove_list_autofill_items(rpc_port_list_autofill_item_h h, unsigned int nth); - -int rpc_port_list_autofill_item_get_list_autofill_items_length(rpc_port_list_autofill_item_h h, unsigned int *length); - -typedef struct list_autofill_response_group_s *rpc_port_list_autofill_response_group_h; - -int rpc_port_list_autofill_response_group_create(rpc_port_list_autofill_response_group_h *h); - -int rpc_port_list_autofill_response_group_destroy(rpc_port_list_autofill_response_group_h h); - -int rpc_port_list_autofill_response_group_clone(rpc_port_list_autofill_response_group_h h, rpc_port_list_autofill_response_group_h *clone); - -int rpc_port_list_autofill_response_group_add_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, rpc_port_autofill_response_group_h list_autofill_response_groups); - -int rpc_port_list_autofill_response_group_foreach_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, - bool (*callback)(rpc_port_autofill_response_group_h list_autofill_response_groups, void *user_data), void *user_data); - -int rpc_port_list_autofill_response_group_remove_list_autofill_response_groups(rpc_port_list_autofill_response_group_h h, unsigned int nth); - -int rpc_port_list_autofill_response_group_get_list_autofill_response_groups_length(rpc_port_list_autofill_response_group_h h, unsigned int *length); - -typedef struct list_autofill_response_item_s *rpc_port_list_autofill_response_item_h; - -int rpc_port_list_autofill_response_item_create(rpc_port_list_autofill_response_item_h *h); - -int rpc_port_list_autofill_response_item_destroy(rpc_port_list_autofill_response_item_h h); - -int rpc_port_list_autofill_response_item_clone(rpc_port_list_autofill_response_item_h h, rpc_port_list_autofill_response_item_h *clone); - -int rpc_port_list_autofill_response_item_add_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, rpc_port_autofill_response_item_h list_autofill_response_items); - -int rpc_port_list_autofill_response_item_foreach_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, - bool (*callback)(rpc_port_autofill_response_item_h list_autofill_response_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_response_item_remove_list_autofill_response_items(rpc_port_list_autofill_response_item_h h, unsigned int nth); - -int rpc_port_list_autofill_response_item_get_list_autofill_response_items_length(rpc_port_list_autofill_response_item_h h, unsigned int *length); - -typedef struct list_autofill_save_item_s *rpc_port_list_autofill_save_item_h; - -int rpc_port_list_autofill_save_item_create(rpc_port_list_autofill_save_item_h *h); - -int rpc_port_list_autofill_save_item_destroy(rpc_port_list_autofill_save_item_h h); - -int rpc_port_list_autofill_save_item_clone(rpc_port_list_autofill_save_item_h h, rpc_port_list_autofill_save_item_h *clone); - -int rpc_port_list_autofill_save_item_add_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, rpc_port_autofill_save_item_h list_autofill_save_items); - -int rpc_port_list_autofill_save_item_foreach_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, - bool (*callback)(rpc_port_autofill_save_item_h list_autofill_save_items, void *user_data), void *user_data); - -int rpc_port_list_autofill_save_item_remove_list_autofill_save_items(rpc_port_list_autofill_save_item_h h, unsigned int nth); - -int rpc_port_list_autofill_save_item_get_list_autofill_save_items_length(rpc_port_list_autofill_save_item_h h, unsigned int *length); - -typedef struct AutofillAppPort_context_s* rpc_port_stub_AutofillAppPort_context_h; - -int rpc_port_stub_AutofillAppPort_context_set_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void *tag); - -int rpc_port_stub_AutofillAppPort_context_get_tag(rpc_port_stub_AutofillAppPort_context_h ctx, void **tag); - -int rpc_port_stub_AutofillAppPort_context_get_sender(rpc_port_stub_AutofillAppPort_context_h ctx, char **sender); - -typedef struct AutofillAppPort_autofill_auth_info_received_cb_s *rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h; - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h); - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_clone(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h *clone); - -int rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h h, rpc_port_autofill_auth_info_h auth_info); - -typedef struct AutofillAppPort_autofill_fill_response_received_cb_s *rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h; - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h); - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_clone(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h *clone); - -int rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h h, rpc_port_autofill_fill_response_h response); - -typedef struct { - void (*create)(rpc_port_stub_AutofillAppPort_context_h context, void *user_data); - void (*terminate)(rpc_port_stub_AutofillAppPort_context_h context, void *user_data); - - int (*Register)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb, rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_cb, void *user_data); - void (*Unregister)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, void *user_data); - int (*request_auth_info)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data); - int (*send_fill_request)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data); - int (*commit)(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_save_view_info_h vi, void *user_data); -} rpc_port_stub_AutofillAppPort_callback_s; - -int rpc_port_stub_AutofillAppPort_register(rpc_port_stub_AutofillAppPort_callback_s *callback, void *user_data); - -int rpc_port_stub_AutofillAppPort_unregister(void); - -int rpc_port_stub_AutofillAppPort_get_client_number(unsigned int *n); - -#ifdef __cplusplus -} -#endif -- 2.7.4 From 2154e137d7e075cb6af39a5c1e80ae03473d9c60 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 24 Dec 2018 17:08:51 +0900 Subject: [PATCH 10/16] Update package version to 1.0.4 Change-Id: I27ac6d51d44a45e5755bbf509edbe0ef75e25a7c Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 63eb4cc..8c55bab 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From 97cdb029e4f11c989527d76e480ada08563f302b Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Wed, 2 Jan 2019 11:08:50 +0900 Subject: [PATCH 11/16] Use system config before setting autofill service to use autofill manager API Change-Id: I79001586f7d31ecaa5c9b615d17870d4efa6f359 Signed-off-by: Jihoon Kim --- src/autofill-daemon.c | 9 ++++++--- src/autofill_config.c | 7 ++++++- src/autofill_config.h | 2 +- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index 5967d6c..749c287 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -636,7 +636,7 @@ static char * __manager_get_autofill_service_cb(rpc_port_stub_AutofillManagerPor } char *app_id = NULL; - autofill_config_get_autofill_service_app_id(&app_id); + autofill_config_get_autofill_service_app_id(&app_id, NULL); LOGD("app id : %s", app_id); @@ -717,7 +717,8 @@ static int connect_service() } char *active_autofill_service_id = NULL; - autofill_config_get_autofill_service_app_id(&active_autofill_service_id); + bool sys_config = false; + autofill_config_get_autofill_service_app_id(&active_autofill_service_id, &sys_config); LOGD("autofill service : '%s'", active_autofill_service_id); if (!active_autofill_service_id) { @@ -725,7 +726,9 @@ static int connect_service() } if (active_autofill_service_id) { - autofill_config_set_autofill_service_app_id(active_autofill_service_id); + if (!sys_config) + autofill_config_set_autofill_service_app_id(active_autofill_service_id); + service_id_len = strlen(active_autofill_service_id); if (service_id_len > 0) { diff --git a/src/autofill_config.c b/src/autofill_config.c index 5430b60..778d826 100644 --- a/src/autofill_config.c +++ b/src/autofill_config.c @@ -26,7 +26,7 @@ #define SETTING_ACTIVE_AUTOFILL_SERVICE "ActiveAutofillService" #define AUTOFILL_SYSTEM_CONFIG_FILE "/etc/autofill/config" -bool autofill_config_get_autofill_service_app_id(char **app_id) +bool autofill_config_get_autofill_service_app_id(char **app_id, bool *sys_config) { char *active_autofill_service_id = NULL; FILE *pFile = NULL; @@ -36,6 +36,9 @@ bool autofill_config_get_autofill_service_app_id(char **app_id) bool ret = false; char strTemp[1024]; + if (sys_config) + *sys_config = false; + if (preference_get_string(SETTING_ACTIVE_AUTOFILL_SERVICE, &active_autofill_service_id) == PREFERENCE_ERROR_NONE) { LOGD("preference active autofill service : %s", active_autofill_service_id); *app_id = active_autofill_service_id; @@ -75,6 +78,8 @@ bool autofill_config_get_autofill_service_app_id(char **app_id) if (app_id && value_str) { *app_id = strdup(value_str); ret = true; + if (sys_config) + *sys_config = true; } eina_strbuf_free(sb_value); diff --git a/src/autofill_config.h b/src/autofill_config.h index 57eb00e..4abf71c 100644 --- a/src/autofill_config.h +++ b/src/autofill_config.h @@ -25,7 +25,7 @@ extern "C" { #endif -bool autofill_config_get_autofill_service_app_id(char **app_id); +bool autofill_config_get_autofill_service_app_id(char **app_id, bool *sys_config); bool autofill_config_set_autofill_service_app_id(const char *app_id); /** -- 2.7.4 From 8d77da9238221cb4ad8406801c08bb77cda417e2 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Wed, 2 Jan 2019 11:15:16 +0900 Subject: [PATCH 12/16] Update package version to 1.0.5 Change-Id: If3b7fc1d5132071d592c901ca8b4c9a00ebbb777 Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 8c55bab..81240dd 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From 3e72cd8ff529fefbfa7f1d6f2b24842d9c843082 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 7 Jan 2019 07:56:49 +0900 Subject: [PATCH 13/16] Send app id in fill response and authentication information Change-Id: Id27c30c6bb366255192770512f2cc48ff8cd3316 Signed-off-by: Jihoon Kim --- src/autofill-daemon.c | 2 ++ tidl/autofill.tidl | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/autofill-daemon.c b/src/autofill-daemon.c index 749c287..6bfb347 100644 --- a/src/autofill-daemon.c +++ b/src/autofill-daemon.c @@ -510,6 +510,7 @@ static void __fill_response_recv_cb(void *user_data, int context_id, rpc_port_au rpc_port_autofill_svc_fill_response_get_app_id(response_h, &app_id); rpc_port_autofill_svc_fill_response_get_view_id(response_h, &view_id); + rpc_port_autofill_fill_response_set_app_id(fill_response_h, app_id); rpc_port_autofill_fill_response_set_view_id(fill_response_h, view_id); rpc_port_autofill_svc_fill_response_foreach_response_groups(response_h, fill_response_group_cb, fill_response_h); @@ -550,6 +551,7 @@ static void __auth_info_recv_cb(void *user_data, int context_id, rpc_port_autofi /* transfer auth info */ rpc_port_autofill_auth_info_h auth_info_h = NULL; rpc_port_autofill_auth_info_create(&auth_info_h); + rpc_port_autofill_auth_info_set_app_id(auth_info_h, app_id); rpc_port_autofill_auth_info_set_view_id(auth_info_h, view_id); rpc_port_autofill_auth_info_set_exist_autofill_data(auth_info_h, exist_autofill_data); rpc_port_autofill_auth_info_set_need_authentication(auth_info_h, need_authentication); diff --git a/tidl/autofill.tidl b/tidl/autofill.tidl index 8c3d185..6f4ccac 100644 --- a/tidl/autofill.tidl +++ b/tidl/autofill.tidl @@ -25,6 +25,7 @@ struct autofill_save_view_info { } struct autofill_auth_info { + string app_id; string view_id; bool exist_autofill_data; bool need_authentication; @@ -45,6 +46,7 @@ struct autofill_response_group { } struct autofill_fill_response { + string app_id; string view_id; list response_groups; } -- 2.7.4 From aaf6ba1bf6c9f2dec14fe229b4a72f2c781ea438 Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Mon, 7 Jan 2019 07:57:35 +0900 Subject: [PATCH 14/16] Update package version to 1.0.6 Change-Id: I5a0cbc203cdf144a37d8bba39a35ee1cab812e7c Signed-off-by: Jihoon Kim --- tizen-manifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 81240dd..1a05706 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4 From f3e5b8e2a506d7f41b9df8524edc7e642373e53e Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Thu, 17 Jan 2019 19:27:49 +0900 Subject: [PATCH 15/16] Support rpm build with signing as platform level Change-Id: I6ce44ddcd23e5721d8daaa3efd03d986c7d70dd6 Signed-off-by: Jihoon Kim --- CMakeLists.txt | 47 +++++++++++++++++++++++++ org.tizen.autofilld.manifest | 5 +++ org.tizen.autofilld.xml | 14 ++++++++ packaging/org.tizen.autofilld.spec | 71 ++++++++++++++++++++++++++++++++++++++ src/autofill_daemon_dlog.h | 11 ++++++ 5 files changed, 148 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 org.tizen.autofilld.manifest create mode 100644 org.tizen.autofilld.xml create mode 100644 packaging/org.tizen.autofilld.spec diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..7eca8bf --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,47 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(autofilld C) + +SET(SRCS + src/autofill-daemon.c + src/autofill_config.c + src/autofill_stub.c + src/autofill_manager_stub.c + src/autofill_service_proxy.c +) + +INCLUDE(FindPkgConfig) +pkg_check_modules(pkgs_test REQUIRED + dlog + rpc-port + glib-2.0 + eina + capi-appfw-service-application + capi-appfw-app-manager + capi-appfw-preference +) + +INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}/include) + +FOREACH(flag ${pkgs_test_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +ADD_DEFINITIONS("-DEXPORTED=__attribute__((visibility(\"default\")))") + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIE") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") + +FIND_PROGRAM(UNAME NAMES uname) +EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH") +IF("${ARCH}" STREQUAL "arm") + ADD_DEFINITIONS("-DTARGET") + MESSAGE("add -DTARGET") +ENDIF("${ARCH}" STREQUAL "arm") + +ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS}) + +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_test_LDFLAGS}) + +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${TZ_SYS_RO_APP}/org.tizen.${PROJECT_NAME}/bin) +INSTALL(FILES ${CMAKE_BINARY_DIR}/org.tizen.autofilld.xml DESTINATION ${TZ_SYS_RO_PACKAGES}) +#INSTALL(FILES ${CMAKE_BINARY_DIR}/autofilld.manifest DESTINATION ${TZ_SYS_RO_PACKAGES}) diff --git a/org.tizen.autofilld.manifest b/org.tizen.autofilld.manifest new file mode 100644 index 0000000..017d22d --- /dev/null +++ b/org.tizen.autofilld.manifest @@ -0,0 +1,5 @@ + + + + + diff --git a/org.tizen.autofilld.xml b/org.tizen.autofilld.xml new file mode 100644 index 0000000..dcd9018 --- /dev/null +++ b/org.tizen.autofilld.xml @@ -0,0 +1,14 @@ + + + + Jihoon Kim + autofilld + + + + + + http://tizen.org/privilege/appmanager.launch + http://tizen.org/privilege/datasharing + + diff --git a/packaging/org.tizen.autofilld.spec b/packaging/org.tizen.autofilld.spec new file mode 100644 index 0000000..f5b0f62 --- /dev/null +++ b/packaging/org.tizen.autofilld.spec @@ -0,0 +1,71 @@ +Name: org.tizen.autofilld +Summary: Autofill Daemon +Version: 1.0.6 +Release: 1 +Group: Graphics & UI Framework/Input +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz +BuildRequires: cmake +BuildRequires: tidl +BuildRequires: hash-signer +BuildRequires: pkgconfig(libtzplatform-config) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(efl) +BuildRequires: pkgconfig(eina) +BuildRequires: pkgconfig(rpc-port) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(capi-appfw-service-application) +BuildRequires: pkgconfig(capi-appfw-preference) +BuildRequires: pkgconfig(capi-appfw-app-manager) + + +%description +Autofill Daemon + + +%prep +%setup -q + +tidlc -s -l C -i tidl/autofill.tidl -o autofill_stub +mv autofill_stub.h ./src/ +mv autofill_stub.c ./src/ + +tidlc -p -l C -i tidl/autofill_service.tidl -o autofill_service_proxy +mv autofill_service_proxy.h ./src/ +mv autofill_service_proxy.c ./src/ + +tidlc -s -l C -i tidl/autofill_manager.tidl -o autofill_manager_stub +mv autofill_manager_stub.h ./src/ +mv autofill_manager_stub.c ./src/ + + +%build +export CFLAGS+=" -DTIZEN_DEBUG_ENABLE -fvisibility=hidden -Werror" +export CXXFLAGS+=" -DTIZEN_DEBUG_ENABLE -fvisibility=hidden -Werror" +export FFLAGS+=" -DTIZEN_DEBUG_ENABLE -fvisibility=hidden" + +rm -rf CMakeFiles +rm -rf CMakeCache.txt +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} -DLIB_INSTALL_DIR:PATH=%{_libdir} \ + -DTZ_SYS_RO_APP=%TZ_SYS_RO_APP -DTZ_SYS_RO_PACKAGES=%TZ_SYS_RO_PACKAGES + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + +%define tizen_sign 1 +%define tizen_sign_base /usr/apps/%{name} +%define tizen_sign_level platform +%define tizen_author_sign 1 +%define tizen_dist_sign 1 + + +%post + +%files +%manifest %{name}.manifest +%{TZ_SYS_RO_PACKAGES}/%{name}.xml +%{TZ_SYS_RO_APP}/%{name}/* diff --git a/src/autofill_daemon_dlog.h b/src/autofill_daemon_dlog.h index 454e14e..b6d9372 100644 --- a/src/autofill_daemon_dlog.h +++ b/src/autofill_daemon_dlog.h @@ -35,10 +35,21 @@ #define COLOR_LIGHTBLUE "\033[0;37m" #define COLOR_END "\033[0;m" +#ifndef LOGI #define LOGI(fmt, arg...) dlog_print(DLOG_INFO, LOG_TAG, "%s (%d) %s : " fmt, __FILE__, __LINE__, __FUNCTION__, ##arg) +#endif + +#ifndef LOGD #define LOGD(fmt, arg...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s (%d) %s : " fmt, __FILE__, __LINE__, __FUNCTION__, ##arg) +#endif + +#ifndef LOGW #define LOGW(fmt, arg...) dlog_print(DLOG_WARN, LOG_TAG, "%s (%d) %s : " fmt, __FILE__, __LINE__, __FUNCTION__, ##arg) +#endif + +#ifndef LOGE #define LOGE(fmt, arg...) dlog_print(DLOG_ERROR, LOG_TAG, "%s (%d) %s : " fmt, __FILE__, __LINE__, __FUNCTION__, ##arg) +#endif #define PLOG(fmt, args...) LOGD(fmt, ##args) #define PINFO(fmt, args...) LOGI(COLOR_PURPLE "* Info * " fmt COLOR_END, ##args) -- 2.7.4 From df3e34e742d1660fad9696a9d16dfc94816c007c Mon Sep 17 00:00:00 2001 From: Jihoon Kim Date: Thu, 17 Jan 2019 19:30:56 +0900 Subject: [PATCH 16/16] Update package version to 1.0.7 Change-Id: I64820ba15315fcbf4ee32467504d309d4622ee8b Signed-off-by: Jihoon Kim --- org.tizen.autofilld.xml | 2 +- packaging/org.tizen.autofilld.spec | 2 +- tizen-manifest.xml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/org.tizen.autofilld.xml b/org.tizen.autofilld.xml index dcd9018..0972cfc 100644 --- a/org.tizen.autofilld.xml +++ b/org.tizen.autofilld.xml @@ -1,5 +1,5 @@ - + Jihoon Kim autofilld diff --git a/packaging/org.tizen.autofilld.spec b/packaging/org.tizen.autofilld.spec index f5b0f62..3d32df8 100644 --- a/packaging/org.tizen.autofilld.spec +++ b/packaging/org.tizen.autofilld.spec @@ -1,6 +1,6 @@ Name: org.tizen.autofilld Summary: Autofill Daemon -Version: 1.0.6 +Version: 1.0.7 Release: 1 Group: Graphics & UI Framework/Input License: Apache-2.0 diff --git a/tizen-manifest.xml b/tizen-manifest.xml index 1a05706..75301c9 100644 --- a/tizen-manifest.xml +++ b/tizen-manifest.xml @@ -1,5 +1,5 @@ - + -- 2.7.4