src/autofill-daemon.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <tizen.h>
  18 #include <stdlib.h>
  19 #include <service_app.h>
  20 #include <dlog.h>
  21 #include <glib.h>
  22 #include <rpc-port.h>
  23 #include <app_manager.h>
  24
  25 #include "autofill_daemon_dlog.h"
  26 #include "autofill_stub.h"
  27 #include "autofill_service_proxy.h"
  28 #include "autofill_manager_stub.h"
  29 #include "autofill_config.h"
  30
  31 static rpc_port_proxy_AutofillSvcPort_h svc_rpc_h = NULL;
  32
  33 static int connect_service();
  34
  35 typedef struct {
  36     char *app_id;
  37     int context_id;
  38
  39     rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb;
  40     rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_received_cb;
  41 } autofill_client_s;
  42
  43 static GList *__client_list = NULL;
  44
  45 static autofill_client_s *
  46 get_autofill_client(const char *app_id, int context_id)
  47 {
  48     GList *iter;
  49     autofill_client_s *client;
  50
  51     iter = __client_list;
  52     while (iter) {
  53         client = iter->data;
  54
  55         iter = g_list_next(iter);
  56
  57         if (!client) {
  58             LOGW("Warning: value is NULL");
  59             continue;
  60         }
  61
  62         if ((client->context_id == context_id) &&
  63             client->app_id && strcmp(client->app_id, app_id) == 0) {
  64             return client;
  65         }
  66     }
  67
  68     return NULL;
  69 }
  70
  71 static autofill_client_s *__create_client(const char *app_id, int context_id,
  72         rpc_port_AutofillAppPort_autofill_auth_info_received_cb_h auth_info_cb,
  73         rpc_port_AutofillAppPort_autofill_fill_response_received_cb_h fill_response_received_cb)
  74 {
  75     LOGD("");
  76     autofill_client_s *handle;
  77
  78     handle = calloc(1, sizeof(autofill_client_s));
  79     if (!handle) {
  80         LOGE("Out of memory");
  81         return NULL;
  82     }
  83
  84     handle->app_id = strdup(app_id);
  85     if (!handle->app_id) {
  86         LOGE("Out of memory");
  87         free(handle);
  88         return NULL;
  89     }
  90
  91     handle->context_id = context_id;
  92
  93     rpc_port_AutofillAppPort_autofill_auth_info_received_cb_clone(auth_info_cb, &handle->auth_info_cb);
  94     if (!handle->auth_info_cb) {
  95         LOGE("Out of memory");
  96         free(handle->app_id);
  97         free(handle);
  98         return NULL;
  99     }
 100
 101     rpc_port_AutofillAppPort_autofill_fill_response_received_cb_clone(fill_response_received_cb, &handle->fill_response_received_cb);
 102
 103     if (!handle->fill_response_received_cb) {
 104         LOGE("Out of memory");
 105         free(handle->app_id);
 106         rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(handle->auth_info_cb);
 107         free(handle);
 108         return NULL;
 109     }
 110
 111     return handle;
 112 }
 113
 114 static void __destroy_client(gpointer data)
 115 {
 116     LOGD("");
 117     autofill_client_s *handle = data;
 118
 119     if (!handle)
 120         return;
 121
 122     if (handle->auth_info_cb) {
 123         rpc_port_AutofillAppPort_autofill_auth_info_received_cb_destroy(handle->auth_info_cb);
 124         handle->auth_info_cb = NULL;
 125     }
 126
 127     if (handle->fill_response_received_cb) {
 128         rpc_port_AutofillAppPort_autofill_fill_response_received_cb_destroy(handle->fill_response_received_cb);
 129         handle->fill_response_received_cb = NULL;
 130     }
 131
 132     if (handle->app_id) {
 133         free(handle->app_id);
 134         handle->app_id = NULL;
 135     }
 136
 137     free(handle);
 138 }
 139
 140 static void __remove_client(rpc_port_stub_AutofillAppPort_context_h context)
 141 {
 142     autofill_client_s *client = NULL;
 143     rpc_port_stub_AutofillAppPort_context_get_tag(context, (void *)&client);
 144     if (!client)
 145         return;
 146
 147     rpc_port_stub_AutofillAppPort_context_set_tag(context, NULL);
 148
 149     LOGI("name(%s)", client->app_id);
 150
 151     __client_list = g_list_remove(__client_list, client);
 152     __destroy_client(client);
 153 }
 154
 155 static void __message_create(rpc_port_stub_AutofillAppPort_context_h context,
 156         void *user_data)
 157 {
 158     LOGD("");
 159     char *sender = NULL;
 160
 161     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 162     if (!sender)
 163         return;
 164
 165     LOGD("sender(%s)", sender);
 166     free(sender);
 167 }
 168
 169 static void __message_terminate(rpc_port_stub_AutofillAppPort_context_h context,
 170         void *user_data)
 171 {
 172     LOGD("");
 173     char *sender = NULL;
 174
 175     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 176     if (!sender)
 177         return;
 178
 179     LOGD("[__RPC_PORT__] sender(%s)", sender);
 180     free(sender);
 181
 182     __remove_client(context);
 183 }
 184
 185 static int __message_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_received_cb, void *user_data)
 186 {
 187     LOGD("");
 188     char *sender = NULL;
 189     autofill_client_s *client = NULL;
 190
 191     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 192     if (!sender)
 193         return -1;
 194
 195     LOGD("sender(%s)", sender);
 196
 197     client = __create_client(sender, context_id, auth_info_cb, fill_response_received_cb);
 198     free(sender);
 199
 200     if (!client)
 201         return -1;
 202
 203     __client_list = g_list_append(__client_list, client);
 204
 205     rpc_port_stub_AutofillAppPort_context_set_tag(context, client);
 206
 207     return 0;
 208 }
 209
 210 static void __message_unregister(rpc_port_stub_AutofillAppPort_context_h context, int context_id, void *user_data)
 211 {
 212     __remove_client(context);
 213 }
 214
 215 static void __manager_create(rpc_port_stub_AutofillManagerPort_context_h context,
 216         void *user_data)
 217 {
 218     LOGD("");
 219 }
 220
 221 static void __manager_terminate(rpc_port_stub_AutofillManagerPort_context_h context,
 222         void *user_data)
 223 {
 224     LOGD("");
 225 }
 226
 227 bool __view_info_item_cb(rpc_port_autofill_item_h items, void *user_data)
 228 {
 229     char *id = NULL;
 230     char *label = NULL;
 231     char *value = NULL;
 232     int autofill_hint;
 233     bool sensitive_data;
 234
 235     rpc_port_autofill_svc_view_info_h svi = (rpc_port_autofill_svc_view_info_h)user_data;
 236
 237     rpc_port_autofill_svc_item_h svc_item = NULL;
 238
 239     if (rpc_port_autofill_svc_item_create(&svc_item) != 0) {
 240         LOGW("Failed to create autofill item");
 241         return true;
 242     }
 243
 244     rpc_port_autofill_item_get_id(items, &id);
 245     rpc_port_autofill_svc_item_set_id(svc_item, id);
 246     if (id) {
 247         free(id);
 248     }
 249
 250     rpc_port_autofill_item_get_label(items, &label);
 251     rpc_port_autofill_svc_item_set_label(svc_item, label);
 252     if (label) {
 253         free(label);
 254     }
 255
 256     rpc_port_autofill_item_get_value(items, &value);
 257     rpc_port_autofill_svc_item_set_value(svc_item, value);
 258     if (value) {
 259         free(value);
 260     }
 261
 262     rpc_port_autofill_item_get_autofill_hint(items, &autofill_hint);
 263     rpc_port_autofill_svc_item_set_autofill_hint(svc_item, autofill_hint);
 264
 265     rpc_port_autofill_item_get_is_sensitive_data(items, &sensitive_data);
 266     rpc_port_autofill_svc_item_set_is_sensitive_data(svc_item, sensitive_data);
 267
 268     if (rpc_port_autofill_svc_view_info_add_items(svi, svc_item) != 0) {
 269         LOGW("Failed to add item");
 270     }
 271
 272     rpc_port_autofill_svc_item_destroy(svc_item);
 273
 274     return true;
 275 }
 276
 277 bool __save_item_cb(rpc_port_autofill_save_item_h items, void *user_data)
 278 {
 279     char *id = NULL;
 280     char *label = NULL;
 281     char *value = NULL;
 282     int autofill_hint;
 283     bool sensitive_data;
 284
 285     rpc_port_autofill_svc_save_view_info_h svi = (rpc_port_autofill_svc_save_view_info_h)user_data;
 286
 287     rpc_port_autofill_svc_save_item_h svc_save_item = NULL;
 288
 289     if (rpc_port_autofill_svc_save_item_create(&svc_save_item) != 0)
 290         return true;
 291
 292     rpc_port_autofill_save_item_get_id(items, &id);
 293     rpc_port_autofill_svc_save_item_set_id(svc_save_item, id);
 294     if (id) {
 295         free(id);
 296     }
 297
 298     rpc_port_autofill_save_item_get_label(items, &label);
 299     rpc_port_autofill_svc_save_item_set_label(svc_save_item, label);
 300     if (label) {
 301         free(label);
 302     }
 303
 304     rpc_port_autofill_save_item_get_value(items, &value);
 305     rpc_port_autofill_svc_save_item_set_value(svc_save_item, value);
 306     if (value) {
 307         free(value);
 308     }
 309
 310     rpc_port_autofill_save_item_get_autofill_hint(items, &autofill_hint);
 311     rpc_port_autofill_svc_save_item_set_autofill_hint(svc_save_item, autofill_hint);
 312
 313     rpc_port_autofill_save_item_get_is_sensitive_data(items, &sensitive_data);
 314     rpc_port_autofill_svc_save_item_set_is_sensitive_data(svc_save_item, sensitive_data);
 315
 316     rpc_port_autofill_svc_save_view_info_add_items(svi, svc_save_item);
 317
 318     rpc_port_autofill_svc_save_item_destroy(svc_save_item);
 319
 320     return true;
 321 }
 322
 323 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)
 324 {
 325     char *sender = NULL;
 326
 327     if (!svc_rpc_h) {
 328         LOGW("Not initialized");
 329         return 0;
 330     }
 331
 332     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 333     char *view_id = NULL;
 334
 335     rpc_port_autofill_view_info_get_view_id(vi, &view_id);
 336     LOGD("app id : %s, view id : %s", sender, view_id);
 337
 338     /* create view info */
 339     rpc_port_autofill_svc_view_info_h svi = NULL;
 340     if (rpc_port_autofill_svc_view_info_create(&svi) != 0) {
 341         goto end;
 342     }
 343
 344     rpc_port_autofill_svc_view_info_set_app_id(svi, sender);
 345     rpc_port_autofill_svc_view_info_set_view_id(svi, view_id);
 346
 347     rpc_port_autofill_view_info_foreach_items(vi, __view_info_item_cb, svi);
 348
 349     rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(svc_rpc_h, context_id, svi);
 350
 351     rpc_port_autofill_svc_view_info_destroy(svi);
 352
 353 end:
 354     if (sender) {
 355         free(sender);
 356     }
 357
 358     if (view_id) {
 359         free(view_id);
 360     }
 361
 362     return 0;
 363 }
 364
 365 static int __autofill_fill_request_cb(rpc_port_stub_AutofillAppPort_context_h context, int context_id, rpc_port_autofill_view_info_h vi, void *user_data)
 366 {
 367     char *sender = NULL;
 368     char *view_id = NULL;
 369
 370     if (!svc_rpc_h) {
 371         LOGW("Not initialized");
 372         return 0;
 373     }
 374
 375     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 376     rpc_port_autofill_view_info_get_view_id(vi, &view_id);
 377
 378     LOGD("app id : %s, view id : %s, context id : %d", sender, view_id, context_id);
 379
 380     rpc_port_autofill_svc_view_info_h svi = NULL;
 381     if (rpc_port_autofill_svc_view_info_create(&svi) != 0) {
 382         goto end;
 383     }
 384
 385     rpc_port_autofill_svc_view_info_set_app_id(svi, sender);
 386     rpc_port_autofill_svc_view_info_set_view_id(svi, view_id);
 387
 388     rpc_port_autofill_view_info_foreach_items(vi, __view_info_item_cb, svi);
 389
 390     rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(svc_rpc_h, context_id, svi);
 391
 392     rpc_port_autofill_svc_view_info_destroy(svi);
 393
 394 end:
 395     if (sender)
 396         free(sender);
 397
 398     if (view_id)
 399         free(view_id);
 400
 401     return 0;
 402 }
 403
 404 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)
 405 {
 406     char *sender = NULL;
 407     char *view_id = NULL;
 408
 409     if (!svc_rpc_h) {
 410         LOGW("Not initialized");
 411         return 0;
 412     }
 413
 414     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 415     if (sender) {
 416         LOGD("sender(%s)", sender);
 417         free(sender);
 418     }
 419
 420     rpc_port_autofill_svc_save_view_info_h svi = NULL;
 421     if (rpc_port_autofill_svc_save_view_info_create(&svi) != 0) {
 422         return 0;
 423     }
 424
 425     rpc_port_autofill_save_view_info_get_view_id(vi, &view_id);
 426     if (view_id) {
 427         LOGD("view id : %s", view_id);
 428     }
 429     rpc_port_autofill_svc_save_view_info_set_view_id(svi, view_id);
 430
 431     rpc_port_autofill_save_view_info_foreach_items(vi, __save_item_cb, svi);
 432
 433     rpc_port_proxy_AutofillSvcPort_invoke_commit(svc_rpc_h, context_id, svi);
 434
 435     if (view_id)
 436         free(view_id);
 437
 438     rpc_port_autofill_svc_save_view_info_destroy(svi);
 439
 440     return 0;
 441 }
 442
 443 bool fill_response_item_cb(rpc_port_autofill_svc_response_item_h response_items, void *user_data)
 444 {
 445     rpc_port_autofill_response_group_h res_group = (rpc_port_autofill_response_group_h)user_data;
 446
 447     char *id = NULL;
 448     char *presentation_text = NULL;
 449     char *value = NULL;
 450
 451     rpc_port_autofill_response_item_h res_item = NULL;
 452
 453     if (rpc_port_autofill_response_item_create(&res_item) != 0) {
 454         return true;
 455     }
 456
 457     rpc_port_autofill_svc_response_item_get_id(response_items, &id);
 458     rpc_port_autofill_response_item_set_id(res_item, id);
 459
 460     rpc_port_autofill_svc_response_item_get_presentation_text(response_items, &presentation_text);
 461     rpc_port_autofill_response_item_set_presentation_text(res_item, presentation_text);
 462
 463     rpc_port_autofill_svc_response_item_get_value(response_items, &value);
 464     rpc_port_autofill_response_item_set_value(res_item, value);
 465
 466     rpc_port_autofill_response_group_add_response_items(res_group, res_item);
 467
 468     if (id)
 469         free(id);
 470
 471     if (presentation_text)
 472         free(presentation_text);
 473
 474     if (value)
 475         free(value);
 476
 477     rpc_port_autofill_response_item_destroy(res_item);
 478
 479     return true;
 480 }
 481
 482 bool fill_response_group_cb(rpc_port_autofill_svc_response_group_h response_groups, void *user_data)
 483 {
 484     rpc_port_autofill_fill_response_h fr_h = (rpc_port_autofill_fill_response_h)user_data;
 485
 486     rpc_port_autofill_response_group_h res_group = NULL;
 487     if (rpc_port_autofill_response_group_create(&res_group) != 0)
 488         return true;
 489
 490     rpc_port_autofill_svc_response_group_foreach_response_items(response_groups, fill_response_item_cb, res_group);
 491
 492     rpc_port_autofill_fill_response_add_response_groups(fr_h, res_group);
 493
 494     rpc_port_autofill_response_group_destroy(res_group);
 495
 496     return true;
 497 }
 498
 499 static void __fill_response_recv_cb(void *user_data, int context_id, rpc_port_autofill_svc_fill_response_h response_h)
 500 {
 501     // recv fill response from service
 502     char *view_id = NULL;
 503     char *app_id = NULL;
 504
 505     /* create autofill response */
 506     rpc_port_autofill_fill_response_h fill_response_h = NULL;
 507     if (rpc_port_autofill_fill_response_create(&fill_response_h) != 0)
 508         return;
 509
 510     rpc_port_autofill_svc_fill_response_get_app_id(response_h, &app_id);
 511     rpc_port_autofill_svc_fill_response_get_view_id(response_h, &view_id);
 512
 513     rpc_port_autofill_fill_response_set_view_id(fill_response_h, view_id);
 514
 515     rpc_port_autofill_svc_fill_response_foreach_response_groups(response_h, fill_response_group_cb, fill_response_h);
 516
 517     autofill_client_s *sender_client = get_autofill_client(app_id, context_id);
 518     if (sender_client)
 519         rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(sender_client->fill_response_received_cb, fill_response_h);
 520
 521     rpc_port_autofill_fill_response_destroy(fill_response_h);
 522
 523     if (app_id)
 524         free(app_id);
 525
 526     if (view_id)
 527         free(view_id);
 528 }
 529
 530 static void __auth_info_recv_cb(void *user_data, int context_id, rpc_port_autofill_svc_auth_info_h svc_auth_info_h)
 531 {
 532     bool exist_autofill_data = false;
 533     bool need_authentication = false;
 534     char *service_name = NULL;
 535     char *service_logo_image_path = NULL;
 536     char *service_message = NULL;
 537     char *app_id = NULL;
 538     char *view_id = NULL;
 539
 540     rpc_port_autofill_svc_auth_info_get_app_id(svc_auth_info_h, &app_id);
 541     rpc_port_autofill_svc_auth_info_get_view_id(svc_auth_info_h, &view_id);
 542     rpc_port_autofill_svc_auth_info_get_exist_autofill_data(svc_auth_info_h, &exist_autofill_data);
 543     rpc_port_autofill_svc_auth_info_get_need_authentication(svc_auth_info_h, &need_authentication);
 544     rpc_port_autofill_svc_auth_info_get_service_name(svc_auth_info_h, &service_name);
 545     rpc_port_autofill_svc_auth_info_get_service_logo_image_path(svc_auth_info_h, &service_logo_image_path);
 546     rpc_port_autofill_svc_auth_info_get_service_message(svc_auth_info_h, &service_message);
 547
 548     LOGD("app id : %s, service name : %s, message : %s, logo path : %s", app_id, service_name, service_message, service_logo_image_path);
 549
 550     /* transfer auth info */
 551     rpc_port_autofill_auth_info_h auth_info_h = NULL;
 552     rpc_port_autofill_auth_info_create(&auth_info_h);
 553     rpc_port_autofill_auth_info_set_view_id(auth_info_h, view_id);
 554     rpc_port_autofill_auth_info_set_exist_autofill_data(auth_info_h, exist_autofill_data);
 555     rpc_port_autofill_auth_info_set_need_authentication(auth_info_h, need_authentication);
 556     rpc_port_autofill_auth_info_set_service_name(auth_info_h, service_name);
 557     rpc_port_autofill_auth_info_set_service_message(auth_info_h, service_message);
 558     rpc_port_autofill_auth_info_set_service_logo_image_path(auth_info_h, service_logo_image_path);
 559
 560     autofill_client_s *sender_client = get_autofill_client(app_id, context_id);
 561     if (sender_client)
 562         rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(sender_client->auth_info_cb, auth_info_h);
 563
 564     rpc_port_autofill_auth_info_destroy(auth_info_h);
 565
 566     if (app_id)
 567         free(app_id);
 568
 569     if (view_id)
 570         free(view_id);
 571
 572     if (service_name)
 573         free(service_name);
 574
 575     if (service_logo_image_path)
 576         free(service_logo_image_path);
 577
 578     if (service_message)
 579         free(service_message);
 580 }
 581
 582 static void __on_connected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 583 {
 584     LOGI("[__RPC_PORT__] connected");
 585
 586     rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_h fill_response_received_cb_h = rpc_port_AutofillSvcPort_autofill_svc_fill_response_cb_create(__fill_response_recv_cb, false, NULL);
 587     rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_h auth_info_cb_h = rpc_port_AutofillSvcPort_autofill_svc_auth_info_cb_create(__auth_info_recv_cb, false, NULL);
 588
 589     int r = rpc_port_proxy_AutofillSvcPort_invoke_Register(h, auth_info_cb_h, fill_response_received_cb_h);
 590     if (r != 0)
 591         LOGD("Failed to invoke Register");
 592 }
 593
 594 //LCOV_EXCL_START
 595 static void __on_disconnected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 596 {
 597     LOGD("disconnected");
 598
 599     svc_rpc_h = NULL;
 600 }
 601
 602 static void __on_rejected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 603 {
 604     LOGD("rejected");
 605 }
 606 //LCOV_EXCL_STOP
 607
 608 static bool __manager_set_autofill_service_cb(rpc_port_stub_AutofillManagerPort_context_h context, const char *app_id, void *user_data)
 609 {
 610     LOGD("app id : %s", app_id);
 611
 612     if (app_id)
 613         autofill_config_set_autofill_service_app_id(app_id);
 614
 615     if (svc_rpc_h) {
 616         LOGD("send terminate");
 617         // terminate service
 618         rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(svc_rpc_h);
 619
 620         int ret = rpc_port_proxy_AutofillSvcPort_destroy(svc_rpc_h);
 621         LOGD("ret : %d", ret);
 622     }
 623
 624     svc_rpc_h = NULL;
 625
 626     connect_service();
 627
 628     return true;
 629 }
 630
 631 static char * __manager_get_autofill_service_cb(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data)
 632 {
 633     if (!svc_rpc_h) {
 634         LOGW("Not initialized");
 635         return false;
 636     }
 637
 638     char *app_id = NULL;
 639     autofill_config_get_autofill_service_app_id(&app_id);
 640
 641     LOGD("app id : %s", app_id);
 642
 643     return app_id;
 644 }
 645
 646 bool add_autofill_service_cb(app_info_h app_info, void *user_data)
 647 {
 648     char *app_id = NULL;
 649     rpc_port_list_string_h service_info_list = (rpc_port_list_string_h)user_data;
 650
 651     int ret = app_info_get_app_id(app_info, &app_id);
 652     if (ret != APP_MANAGER_ERROR_NONE) {
 653         LOGW("app_info_get_app_id failed (%d)", ret);
 654         return true;
 655     }
 656
 657     LOGD("Find autofill service : %s", app_id);
 658
 659     rpc_port_list_string_add_list_strings(service_info_list, app_id);
 660
 661     if (app_id) {
 662         free(app_id);
 663     }
 664
 665     return true;
 666 }
 667
 668 static bool __manager_get_autofill_service_list_cb(rpc_port_stub_AutofillManagerPort_context_h context, rpc_port_list_string_h *service_info_list, void *user_data)
 669 {
 670     int ret;
 671     app_info_metadata_filter_h handle = NULL;
 672
 673     // Get the Autofill service list
 674     ret = app_info_metadata_filter_create(&handle);
 675     if (ret != APP_MANAGER_ERROR_NONE) {
 676         LOGW("app_info_metadata_filter_create failed (%d)", ret);
 677         app_info_metadata_filter_destroy(handle);
 678         return false;
 679     }
 680
 681     ret = app_info_metadata_filter_add(handle, "autofill-service", "true");
 682     if (ret != APP_MANAGER_ERROR_NONE) {
 683         LOGW("app_info_metadata_filter_add failed (%d)", ret);
 684         app_info_metadata_filter_destroy(handle);
 685         return false;
 686     }
 687
 688     rpc_port_list_string_h app_id_list_h = NULL;
 689     rpc_port_list_string_create(&app_id_list_h);
 690
 691     ret = app_info_metadata_filter_foreach(handle, add_autofill_service_cb, app_id_list_h);
 692     if (ret != APP_MANAGER_ERROR_NONE) {
 693         LOGW("app_info_metadata_filter_foreach failed (%d)", ret);
 694     }
 695
 696     *service_info_list = app_id_list_h;
 697
 698     app_info_metadata_filter_destroy(handle);
 699
 700     return true;
 701 }
 702
 703 static int connect_service()
 704 {
 705     int ret;
 706     size_t service_id_len = 0;
 707
 708     rpc_port_proxy_AutofillSvcPort_callback_s rpc_callback = {
 709         .connected = __on_connected,
 710         .disconnected = __on_disconnected,
 711         .rejected = __on_rejected
 712     };
 713
 714     if (svc_rpc_h) {
 715         LOGI("already connected\n");
 716         return RPC_PORT_ERROR_NONE;
 717     }
 718
 719     char *active_autofill_service_id = NULL;
 720     autofill_config_get_autofill_service_app_id(&active_autofill_service_id);
 721     LOGD("autofill service : '%s'", active_autofill_service_id);
 722
 723     if (!active_autofill_service_id) {
 724         active_autofill_service_id = strdup(AUTOFILL_SERVICE_APP_ID);
 725     }
 726
 727     if (active_autofill_service_id) {
 728         autofill_config_set_autofill_service_app_id(active_autofill_service_id);
 729         service_id_len = strlen(active_autofill_service_id);
 730
 731         if (service_id_len > 0) {
 732             ret = rpc_port_proxy_AutofillSvcPort_create(active_autofill_service_id, &rpc_callback, NULL, &svc_rpc_h);
 733         }
 734         free(active_autofill_service_id);
 735
 736         if (service_id_len == 0) {
 737             LOGD("No Autofill service to connect");
 738             return false;
 739         }
 740
 741         if (ret != RPC_PORT_ERROR_NONE) {
 742             LOGW("Failed to create rpc port. err = %d", ret);
 743             return false;
 744         }
 745     }
 746
 747     ret = rpc_port_proxy_AutofillSvcPort_connect(svc_rpc_h);
 748     if (ret != RPC_PORT_ERROR_NONE) {
 749         LOGW("Failed to connect. err = %d", ret);
 750         return false;
 751     }
 752
 753     return ret;
 754 }
 755
 756 bool service_app_create(void *data)
 757 {
 758     // Todo: add your code here.
 759     LOGD("");
 760
 761     int ret;
 762     // register app port
 763     rpc_port_stub_AutofillAppPort_callback_s callback = {
 764         __message_create,
 765         __message_terminate,
 766         __message_register,
 767         __message_unregister,
 768         __auth_info_request_cb,
 769         __autofill_fill_request_cb,
 770         __commit_cb,
 771     };
 772
 773     ret = rpc_port_stub_AutofillAppPort_register(&callback, NULL);
 774     if (ret != 0)
 775         LOGI("Failed to register app port");
 776     else
 777         LOGI("Succeeded to register app port");
 778
 779     // register manager port
 780     rpc_port_stub_AutofillManagerPort_callback_s manager_callback = {
 781         __manager_create,
 782         __manager_terminate,
 783         __manager_set_autofill_service_cb,
 784         __manager_get_autofill_service_cb,
 785         __manager_get_autofill_service_list_cb,
 786     };
 787
 788     ret = rpc_port_stub_AutofillManagerPort_register(&manager_callback, NULL);
 789     if (ret != 0)
 790         LOGI("Failed to register manager port");
 791     else
 792         LOGI("Succeeded to register manager port");
 793
 794     connect_service();
 795
 796     return true;
 797 }
 798
 799 void service_app_terminate(void *data)
 800 {
 801     // Todo: add your code here.
 802     LOGD("");
 803
 804     if (__client_list) {
 805         g_list_free_full(__client_list, __destroy_client);
 806         __client_list = NULL;
 807     }
 808
 809     rpc_port_stub_AutofillAppPort_unregister();
 810
 811     return;
 812 }
 813
 814 void service_app_control(app_control_h app_control, void *data)
 815 {
 816     // Todo: add your code here.
 817     return;
 818 }
 819
 820 static void
 821 service_app_lang_changed(app_event_info_h event_info, void *user_data)
 822 {
 823     /*APP_EVENT_LANGUAGE_CHANGED*/
 824     return;
 825 }
 826
 827 static void
 828 service_app_region_changed(app_event_info_h event_info, void *user_data)
 829 {
 830     /*APP_EVENT_REGION_FORMAT_CHANGED*/
 831 }
 832
 833 static void
 834 service_app_low_battery(app_event_info_h event_info, void *user_data)
 835 {
 836     /*APP_EVENT_LOW_BATTERY*/
 837 }
 838
 839 static void
 840 service_app_low_memory(app_event_info_h event_info, void *user_data)
 841 {
 842     /*APP_EVENT_LOW_MEMORY*/
 843 }
 844
 845 /**
 846  * Entry point for this application.
 847  */
 848 int main(int argc, char *argv[])
 849 {
 850     LOGI("BEGIN");
 851
 852     char ad[50] = {0,};
 853     service_app_lifecycle_callback_s event_callback;
 854     app_event_handler_h handlers[5] = {NULL, };
 855
 856     event_callback.create = service_app_create;
 857     event_callback.terminate = service_app_terminate;
 858     event_callback.app_control = service_app_control;
 859
 860     service_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, service_app_low_battery, &ad);
 861     service_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, service_app_low_memory, &ad);
 862     service_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, service_app_lang_changed, &ad);
 863     service_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, service_app_region_changed, &ad);
 864
 865     return service_app_main(argc, argv, &event_callback, ad);
 866 }