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;
 238
 239     rpc_port_autofill_svc_item_create(&svc_item);
 240
 241     rpc_port_autofill_item_get_id(items, &id);
 242     rpc_port_autofill_svc_item_set_id(svc_item, id);
 243     if (id) {
 244         free(id);
 245     }
 246
 247     rpc_port_autofill_item_get_label(items, &label);
 248     rpc_port_autofill_svc_item_set_label(svc_item, label);
 249     if (label) {
 250         free(label);
 251     }
 252
 253     rpc_port_autofill_item_get_value(items, &value);
 254     rpc_port_autofill_svc_item_set_value(svc_item, value);
 255     if (value) {
 256         free(value);
 257     }
 258
 259     rpc_port_autofill_item_get_autofill_hint(items, &autofill_hint);
 260     rpc_port_autofill_svc_item_set_autofill_hint(svc_item, autofill_hint);
 261
 262     rpc_port_autofill_item_get_is_sensitive_data(items, &sensitive_data);
 263     rpc_port_autofill_svc_item_set_is_sensitive_data(svc_item, sensitive_data);
 264
 265     rpc_port_autofill_svc_view_info_add_items(svi, svc_item);
 266
 267     rpc_port_autofill_svc_item_destroy(svc_item);
 268
 269     return true;
 270 }
 271
 272 bool __save_item_cb(rpc_port_autofill_save_item_h items, void *user_data)
 273 {
 274     char *id = NULL;
 275     char *label = NULL;
 276     char *value = NULL;
 277     int autofill_hint;
 278     bool sensitive_data;
 279
 280     rpc_port_autofill_svc_save_view_info_h svi = (rpc_port_autofill_svc_save_view_info_h)user_data;
 281
 282     rpc_port_autofill_svc_save_item_h svc_save_item;
 283
 284     rpc_port_autofill_svc_save_item_create(&svc_save_item);
 285
 286     rpc_port_autofill_save_item_get_id(items, &id);
 287     rpc_port_autofill_svc_save_item_set_id(svc_save_item, id);
 288     if (id) {
 289         free(id);
 290     }
 291
 292     rpc_port_autofill_save_item_get_label(items, &label);
 293     rpc_port_autofill_svc_save_item_set_label(svc_save_item, label);
 294     if (label) {
 295         free(label);
 296     }
 297
 298     rpc_port_autofill_save_item_get_value(items, &value);
 299     rpc_port_autofill_svc_save_item_set_value(svc_save_item, value);
 300     if (value) {
 301         free(value);
 302     }
 303
 304     rpc_port_autofill_save_item_get_autofill_hint(items, &autofill_hint);
 305     rpc_port_autofill_svc_save_item_set_autofill_hint(svc_save_item, autofill_hint);
 306
 307     rpc_port_autofill_save_item_get_is_sensitive_data(items, &sensitive_data);
 308     rpc_port_autofill_svc_save_item_set_is_sensitive_data(svc_save_item, sensitive_data);
 309
 310     rpc_port_autofill_svc_save_view_info_add_items(svi, svc_save_item);
 311
 312     rpc_port_autofill_svc_save_item_destroy(svc_save_item);
 313
 314     return true;
 315 }
 316
 317 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)
 318 {
 319     char *sender = NULL;
 320     autofill_client_s *sender_client;
 321
 322     if (!svc_rpc_h) {
 323         LOGW("Not initialized");
 324         return -1;
 325     }
 326
 327     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 328     char *view_id = NULL;
 329
 330     rpc_port_autofill_view_info_get_view_id(vi, &view_id);
 331     LOGD("app id : %s, view id : %s", sender, view_id);
 332
 333     rpc_port_stub_AutofillAppPort_context_get_tag(context, (void *)&sender_client);
 334
 335     /* create view info */
 336     rpc_port_autofill_svc_view_info_h svi;
 337     rpc_port_autofill_svc_view_info_create(&svi);
 338     rpc_port_autofill_svc_view_info_set_app_id(svi, sender);
 339     rpc_port_autofill_svc_view_info_set_view_id(svi, view_id);
 340
 341     rpc_port_autofill_view_info_foreach_items(vi, __view_info_item_cb, svi);
 342
 343     rpc_port_proxy_AutofillSvcPort_invoke_request_auth_info(svc_rpc_h, context_id, svi);
 344
 345     if (sender) {
 346         free(sender);
 347     }
 348
 349     if (view_id) {
 350         free(view_id);
 351     }
 352
 353     rpc_port_autofill_svc_view_info_destroy(svi);
 354
 355     return 0;
 356 }
 357
 358 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)
 359 {
 360     char *sender = NULL;
 361     char *view_id = NULL;
 362
 363     if (!svc_rpc_h) {
 364         LOGW("Not initialized");
 365         return -1;
 366     }
 367
 368     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 369     rpc_port_autofill_view_info_get_view_id(vi, &view_id);
 370
 371     LOGD("app id : %s, view id : %s, context id : %d", sender, view_id, context_id);
 372
 373     rpc_port_autofill_svc_view_info_h svi;
 374     rpc_port_autofill_svc_view_info_create(&svi);
 375     rpc_port_autofill_svc_view_info_set_app_id(svi, sender);
 376     rpc_port_autofill_svc_view_info_set_view_id(svi, view_id);
 377
 378     rpc_port_autofill_view_info_foreach_items(vi, __view_info_item_cb, svi);
 379
 380     rpc_port_proxy_AutofillSvcPort_invoke_send_fill_request(svc_rpc_h, context_id, svi);
 381
 382     if (sender)
 383         free(sender);
 384
 385     if (view_id)
 386         free(view_id);
 387
 388     rpc_port_autofill_svc_view_info_destroy(svi);
 389
 390     return 0;
 391 }
 392
 393 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)
 394 {
 395     char *sender = NULL;
 396     autofill_client_s *sender_client;
 397
 398     if (!svc_rpc_h) {
 399         LOGW("Not initialized");
 400         return -1;
 401     }
 402
 403     rpc_port_stub_AutofillAppPort_context_get_sender(context, &sender);
 404     if (sender) {
 405         LOGD("sender(%s)", sender);
 406         free(sender);
 407     }
 408
 409     char *view_id = NULL;
 410     rpc_port_autofill_save_view_info_get_view_id(vi, &view_id);
 411     if (view_id) {
 412         LOGD("view id : %s", view_id);
 413     }
 414
 415     rpc_port_autofill_svc_save_view_info_h svi;
 416     rpc_port_autofill_svc_save_view_info_create(&svi);
 417     rpc_port_autofill_svc_save_view_info_set_view_id(svi, view_id);
 418
 419     rpc_port_stub_AutofillAppPort_context_get_tag(context, (void *)&sender_client);
 420     rpc_port_autofill_save_view_info_foreach_items(vi, __save_item_cb, svi);
 421
 422     rpc_port_proxy_AutofillSvcPort_invoke_commit(svc_rpc_h, context_id, svi);
 423
 424     if (view_id)
 425         free(view_id);
 426
 427     rpc_port_autofill_svc_save_view_info_destroy(svi);
 428
 429     return 0;
 430 }
 431
 432 bool fill_response_item_cb(rpc_port_autofill_svc_response_item_h response_items, void *user_data)
 433 {
 434     rpc_port_autofill_response_group_h res_group = (rpc_port_autofill_response_group_h)user_data;
 435
 436     char *id = NULL;
 437     char *presentation_text = NULL;
 438     char *value = NULL;
 439
 440     rpc_port_autofill_response_item_h res_item;
 441
 442     rpc_port_autofill_response_item_create(&res_item);
 443
 444     rpc_port_autofill_svc_response_item_get_id(response_items, &id);
 445     rpc_port_autofill_response_item_set_id(res_item, id);
 446
 447     rpc_port_autofill_svc_response_item_get_presentation_text(response_items, &presentation_text);
 448     rpc_port_autofill_response_item_set_presentation_text(res_item, presentation_text);
 449
 450     rpc_port_autofill_svc_response_item_get_value(response_items, &value);
 451     rpc_port_autofill_response_item_set_value(res_item, value);
 452
 453     rpc_port_autofill_response_group_add_response_items(res_group, res_item);
 454
 455     if (id)
 456         free(id);
 457
 458     if (presentation_text)
 459         free(presentation_text);
 460
 461     if (value)
 462         free(value);
 463
 464     rpc_port_autofill_response_item_destroy(res_item);
 465
 466     return true;
 467 }
 468
 469 bool fill_response_group_cb(rpc_port_autofill_svc_response_group_h response_groups, void *user_data)
 470 {
 471     rpc_port_autofill_fill_response_h fr_h = (rpc_port_autofill_fill_response_h)user_data;
 472
 473     rpc_port_autofill_response_group_h res_group;
 474     rpc_port_autofill_response_group_create(&res_group);
 475
 476     rpc_port_autofill_svc_response_group_foreach_response_items(response_groups, fill_response_item_cb, res_group);
 477
 478     rpc_port_autofill_fill_response_add_response_groups(fr_h, res_group);
 479
 480     rpc_port_autofill_response_group_destroy(res_group);
 481
 482     return true;
 483 }
 484
 485 static void __fill_response_recv_cb(void *user_data, int context_id, rpc_port_autofill_svc_fill_response_h response_h)
 486 {
 487     // recv fill response from service
 488     char *view_id = NULL;
 489     char *app_id = NULL;
 490
 491     rpc_port_autofill_svc_fill_response_get_app_id(response_h, &app_id);
 492     rpc_port_autofill_svc_fill_response_get_view_id(response_h, &view_id);
 493
 494     /* create autofill response */
 495     rpc_port_autofill_fill_response_h fill_response_h;
 496     rpc_port_autofill_fill_response_create(&fill_response_h);
 497     rpc_port_autofill_fill_response_set_view_id(fill_response_h, view_id);
 498
 499     rpc_port_autofill_svc_fill_response_foreach_response_groups(response_h, fill_response_group_cb, fill_response_h);
 500
 501     autofill_client_s *sender_client = get_autofill_client(app_id, context_id);
 502     if (sender_client)
 503         rpc_port_AutofillAppPort_autofill_fill_response_received_cb_invoke(sender_client->fill_response_received_cb, fill_response_h);
 504
 505     rpc_port_autofill_fill_response_destroy(fill_response_h);
 506
 507     if (app_id)
 508         free(app_id);
 509
 510     if (view_id)
 511         free(view_id);
 512 }
 513
 514 static void __auth_info_recv_cb(void *user_data, int context_id, rpc_port_autofill_svc_auth_info_h svc_auth_info_h)
 515 {
 516     bool exist_autofill_data;
 517     bool need_authentication;
 518     char *service_name = NULL;
 519     char *service_logo_image_path = NULL;
 520     char *service_message = NULL;
 521     char *app_id = NULL;
 522     char *view_id = NULL;
 523
 524     rpc_port_autofill_svc_auth_info_get_app_id(svc_auth_info_h, &app_id);
 525     rpc_port_autofill_svc_auth_info_get_view_id(svc_auth_info_h, &view_id);
 526     rpc_port_autofill_svc_auth_info_get_exist_autofill_data(svc_auth_info_h, &exist_autofill_data);
 527     rpc_port_autofill_svc_auth_info_get_need_authentication(svc_auth_info_h, &need_authentication);
 528     rpc_port_autofill_svc_auth_info_get_service_name(svc_auth_info_h, &service_name);
 529     rpc_port_autofill_svc_auth_info_get_service_logo_image_path(svc_auth_info_h, &service_logo_image_path);
 530     rpc_port_autofill_svc_auth_info_get_service_message(svc_auth_info_h, &service_message);
 531
 532     LOGD("app id : %s, service name : %s, message : %s, logo path : %s", app_id, service_name, service_message, service_logo_image_path);
 533
 534     /* transfer auth info */
 535     rpc_port_autofill_auth_info_h auth_info_h;
 536     rpc_port_autofill_auth_info_create(&auth_info_h);
 537     rpc_port_autofill_auth_info_set_view_id(auth_info_h, view_id);
 538     rpc_port_autofill_auth_info_set_exist_autofill_data(auth_info_h, exist_autofill_data);
 539     rpc_port_autofill_auth_info_set_need_authentication(auth_info_h, need_authentication);
 540     rpc_port_autofill_auth_info_set_service_name(auth_info_h, service_name);
 541     rpc_port_autofill_auth_info_set_service_message(auth_info_h, service_message);
 542     rpc_port_autofill_auth_info_set_service_logo_image_path(auth_info_h, service_logo_image_path);
 543
 544     autofill_client_s *sender_client = get_autofill_client(app_id, context_id);
 545     if (sender_client)
 546         rpc_port_AutofillAppPort_autofill_auth_info_received_cb_invoke(sender_client->auth_info_cb, auth_info_h);
 547
 548     rpc_port_autofill_auth_info_destroy(auth_info_h);
 549
 550     if (app_id)
 551         free(app_id);
 552
 553     if (view_id)
 554         free(view_id);
 555
 556     if (service_name)
 557         free(service_name);
 558
 559     if (service_logo_image_path)
 560         free(service_logo_image_path);
 561
 562     if (service_message)
 563         free(service_message);
 564 }
 565
 566 static void __on_connected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 567 {
 568     LOGI("[__RPC_PORT__] connected");
 569
 570     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);
 571     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);
 572
 573     int r = rpc_port_proxy_AutofillSvcPort_invoke_Register(h, auth_info_cb_h, fill_response_received_cb_h);
 574     if (r != 0)
 575         LOGD("Failed to invoke Register");
 576 }
 577
 578 //LCOV_EXCL_START
 579 static void __on_disconnected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 580 {
 581     LOGD("disconnected");
 582
 583     svc_rpc_h = NULL;
 584 }
 585
 586 static void __on_rejected(rpc_port_proxy_AutofillSvcPort_h h, void *user_data)
 587 {
 588     LOGD("rejected");
 589 }
 590 //LCOV_EXCL_STOP
 591
 592 static bool __manager_set_autofill_service_cb(rpc_port_stub_AutofillManagerPort_context_h context, const char *app_id, void *user_data)
 593 {
 594     LOGD("app id : %s", app_id);
 595
 596     if (app_id)
 597         autofill_config_set_autofill_service_app_id(app_id);
 598
 599     if (svc_rpc_h) {
 600         LOGD("send terminate");
 601         // terminate service
 602         rpc_port_proxy_AutofillSvcPort_invoke_request_terminate(svc_rpc_h);
 603
 604         int ret = rpc_port_proxy_AutofillSvcPort_destroy(svc_rpc_h);
 605         LOGD("ret : %d", ret);
 606     }
 607     else {
 608         LOGW("Not initialized");
 609         return false;
 610     }
 611     svc_rpc_h = NULL;
 612
 613     connect_service();
 614
 615     return true;
 616 }
 617
 618 static char * __manager_get_autofill_service_cb(rpc_port_stub_AutofillManagerPort_context_h context, void *user_data)
 619 {
 620     if (!svc_rpc_h) {
 621         LOGW("Not initialized");
 622         return false;
 623     }
 624
 625     char *app_id;
 626     autofill_config_get_autofill_service_app_id(&app_id);
 627
 628     LOGD("app id : %s", app_id);
 629
 630     return app_id;
 631 }
 632
 633 bool add_autofill_service_cb(app_info_h app_info, void *user_data)
 634 {
 635     char *app_id = NULL;
 636     rpc_port_list_string_h service_info_list = (rpc_port_list_string_h)user_data;
 637
 638     int ret = app_info_get_app_id(app_info, &app_id);
 639     if (ret != APP_MANAGER_ERROR_NONE) {
 640         LOGW("app_info_get_app_id failed (%d)", ret);
 641         return true;
 642     }
 643
 644     LOGD("Find autofill service : %s", app_id);
 645
 646     rpc_port_list_string_add_list_strings(service_info_list, app_id);
 647
 648     if (app_id) {
 649         free(app_id);
 650     }
 651
 652     return true;
 653 }
 654
 655 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)
 656 {
 657     int ret;
 658     app_info_metadata_filter_h handle = NULL;
 659
 660     // Get the Autofill service list
 661     ret = app_info_metadata_filter_create(&handle);
 662     if (ret != APP_MANAGER_ERROR_NONE) {
 663         LOGW("app_info_metadata_filter_create failed (%d)", ret);
 664         app_info_metadata_filter_destroy(handle);
 665         return false;
 666     }
 667
 668     ret = app_info_metadata_filter_add(handle, "autofill-service", "true");
 669     if (ret != APP_MANAGER_ERROR_NONE) {
 670         LOGW("app_info_metadata_filter_add failed (%d)", ret);
 671         app_info_metadata_filter_destroy(handle);
 672         return false;
 673     }
 674
 675     rpc_port_list_string_h app_id_list_h;
 676     rpc_port_list_string_create(&app_id_list_h);
 677
 678     ret = app_info_metadata_filter_foreach(handle, add_autofill_service_cb, app_id_list_h);
 679     if (ret != APP_MANAGER_ERROR_NONE) {
 680         LOGW("app_info_metadata_filter_foreach failed (%d)", ret);
 681     }
 682
 683     *service_info_list = app_id_list_h;
 684
 685     app_info_metadata_filter_destroy(handle);
 686
 687     return true;
 688 }
 689
 690 static int connect_service()
 691 {
 692     int ret;
 693
 694     rpc_port_proxy_AutofillSvcPort_callback_s rpc_callback = {
 695         .connected = __on_connected,
 696         .disconnected = __on_disconnected,
 697         .rejected = __on_rejected
 698     };
 699
 700     if (svc_rpc_h) {
 701         LOGI("already connected\n");
 702         return RPC_PORT_ERROR_NONE;
 703     }
 704
 705     char *active_autofill_service_id = NULL;
 706     autofill_config_get_autofill_service_app_id(&active_autofill_service_id);
 707     LOGD("autofill service : %s", active_autofill_service_id);
 708
 709     if (!active_autofill_service_id) {
 710         active_autofill_service_id = strdup(AUTOFILL_SERVICE_APP_ID);
 711     }
 712
 713     if (active_autofill_service_id) {
 714         autofill_config_set_autofill_service_app_id(active_autofill_service_id);
 715         ret = rpc_port_proxy_AutofillSvcPort_create(active_autofill_service_id, &rpc_callback, NULL, &svc_rpc_h);
 716         free(active_autofill_service_id);
 717         if (ret != RPC_PORT_ERROR_NONE) {
 718             LOGW("Failed to create rpc port. err = %d", ret);
 719             return false;
 720         }
 721     }
 722
 723     ret = rpc_port_proxy_AutofillSvcPort_connect(svc_rpc_h);
 724     if (ret != RPC_PORT_ERROR_NONE) {
 725         LOGW("Failed to connect. err = %d", ret);
 726         return false;
 727     }
 728
 729     return ret;
 730 }
 731
 732 bool service_app_create(void *data)
 733 {
 734     // Todo: add your code here.
 735     LOGD("");
 736
 737     int ret;
 738     // register app port
 739     rpc_port_stub_AutofillAppPort_callback_s callback = {
 740         __message_create,
 741         __message_terminate,
 742         __message_register,
 743         __message_unregister,
 744         __auth_info_request_cb,
 745         __autofill_fill_request_cb,
 746         __commit_cb,
 747     };
 748
 749     ret = rpc_port_stub_AutofillAppPort_register(&callback, NULL);
 750     if (ret != 0)
 751         LOGI("Failed to register app port");
 752     else
 753         LOGI("Succeeded to register app port");
 754
 755     // register manager port
 756     rpc_port_stub_AutofillManagerPort_callback_s manager_callback = {
 757         __manager_create,
 758         __manager_terminate,
 759         __manager_set_autofill_service_cb,
 760         __manager_get_autofill_service_cb,
 761         __manager_get_autofill_service_list_cb,
 762     };
 763
 764     ret = rpc_port_stub_AutofillManagerPort_register(&manager_callback, NULL);
 765     if (ret != 0)
 766         LOGI("Failed to register manager port");
 767     else
 768         LOGI("Succeeded to register manager port");
 769
 770     connect_service();
 771
 772     return true;
 773 }
 774
 775 void service_app_terminate(void *data)
 776 {
 777     // Todo: add your code here.
 778     LOGD("");
 779
 780     if (__client_list) {
 781         g_list_free_full(__client_list, __destroy_client);
 782         __client_list = NULL;
 783     }
 784
 785     rpc_port_stub_AutofillAppPort_unregister();
 786
 787     return;
 788 }
 789
 790 void service_app_control(app_control_h app_control, void *data)
 791 {
 792     // Todo: add your code here.
 793     return;
 794 }
 795
 796 static void
 797 service_app_lang_changed(app_event_info_h event_info, void *user_data)
 798 {
 799     /*APP_EVENT_LANGUAGE_CHANGED*/
 800     return;
 801 }
 802
 803 static void
 804 service_app_region_changed(app_event_info_h event_info, void *user_data)
 805 {
 806     /*APP_EVENT_REGION_FORMAT_CHANGED*/
 807 }
 808
 809 static void
 810 service_app_low_battery(app_event_info_h event_info, void *user_data)
 811 {
 812     /*APP_EVENT_LOW_BATTERY*/
 813 }
 814
 815 static void
 816 service_app_low_memory(app_event_info_h event_info, void *user_data)
 817 {
 818     /*APP_EVENT_LOW_MEMORY*/
 819 }
 820
 821 /**
 822  * Entry point for this application.
 823  */
 824 int main(int argc, char *argv[])
 825 {
 826     LOGI("BEGIN");
 827
 828     char ad[50] = {0,};
 829     service_app_lifecycle_callback_s event_callback;
 830     app_event_handler_h handlers[5] = {NULL, };
 831
 832     event_callback.create = service_app_create;
 833     event_callback.terminate = service_app_terminate;
 834     event_callback.app_control = service_app_control;
 835
 836     service_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, service_app_low_battery, &ad);
 837     service_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, service_app_low_memory, &ad);
 838     service_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, service_app_lang_changed, &ad);
 839     service_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, service_app_region_changed, &ad);
 840
 841     return service_app_main(argc, argv, &event_callback, ad);
 842 }