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