src/bt-share-ui-ipc.c

   1 /*
   2 * bluetooth-share-ui
   3 *
   4 * Copyright 2012 Samsung Electronics Co., Ltd
   5 *
   6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
   7 *           GirishAshok Joshi <girish.joshi@samsung.com>
   8 *           DoHyun Pyun <dh79.pyun@samsung.com>
   9 *
  10 * Licensed under the Flora License, Version 1.0 (the "License");
  11 * you may not use this file except in compliance with the License.
  12 * You may obtain a copy of the License at
  13 *
  14 * http://www.tizenopensource.org/license
  15 *
  16 * Unless required by applicable law or agreed to in writing,
  17 * software distributed under the License is distributed on an "AS IS" BASIS,
  18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19 * See the License for the specific language governing permissions and
  20 * limitations under the License.
  21 *
  22 */
  23
  24 #include <dbus/dbus.h>
  25 #include <dbus/dbus-glib-bindings.h>
  26 #include <glib.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <notification.h>
  30 #include <bluetooth-share-api.h>
  31 #include "applog.h"
  32 #include "bt-share-ui-main.h"
  33 #include "bt-share-ui-ipc.h"
  34 #include "bt-share-ui-view.h"
  35 #include "bt-share-ui-popup.h"
  36 #include "bt-share-ui-resource.h"
  37 #include "bt-share-ui-widget.h"
  38
  39 #define BT_ADDRESS_LENGTH_MAX   6
  40 #define DBUS_CORE_APPS_PATH "/Org/Tizen/Coreapps/home/raise"
  41 #define DBUS_CORE_APPS_INTERFACE "org.tizen.coreapps.home.raise"
  42 #define DBUS_CORE_APPS_MEMBER "homeraise"
  43
  44 static gboolean opc_launched_session;
  45
  46 void _bt_set_opc_launched_session(gboolean value)
  47 {
  48         opc_launched_session = value;
  49 }
  50
  51 static void __handle_opp_client_signal(void *data, DBusMessage *msg)
  52 {
  53         bt_share_event_param_t event_info = { 0, };
  54         int result = BT_SHARE_UI_ERROR_NONE;
  55         const char *member = dbus_message_get_member(msg);
  56
  57         retm_if(data == NULL, "Invalid argument: data is NULL\n");
  58         retm_if(msg == NULL, "Invalid argument: msg is NULL\n");
  59         bt_share_appdata_t *ad = (bt_share_appdata_t *)data;
  60         retm_if(ad->tr_type == BT_TR_INBOUND, "Invalid tr_type: BT_TR_INBOUND");
  61         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
  62                 return;
  63
  64         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
  65                 return;
  66
  67         if (!dbus_message_has_path(msg, BT_OPP_CLIENT_PATH))
  68                 return;
  69
  70         ret_if(member == NULL);
  71
  72         if (strcasecmp(member, BT_OPP_CONNECTED) == 0) {
  73                 char *address = NULL;
  74                 int request_id = 0;
  75                 DBG("BT_OPP_CONNECTED signal");
  76                 if (!dbus_message_get_args(msg, NULL,
  77                         DBUS_TYPE_INT32, &result,
  78                         DBUS_TYPE_STRING, &address,
  79                         DBUS_TYPE_INT32, &request_id,
  80                         DBUS_TYPE_INVALID)) {
  81                         ERR("Unexpected parameters in signal");
  82                         return;
  83                 }
  84                 event_info.event = BT_SHARE_UI_EVENT_OPC_CONNECTED;
  85                 event_info.param_data = address;
  86                 event_info.result = result;
  87                 event_info.user_data = data;
  88                 DBG("Event BT_SHARE_UI_EVENT_OPC_CONNECTED");
  89                 _bt_share_ui_event_handler(BT_SHARE_UI_EVENT_OPC_CONNECTED,
  90                                 &event_info, event_info.user_data);
  91         } else if (strcasecmp(member, BT_TRANSFER_STARTED) == 0) {
  92                 char *file_path = NULL;
  93                 char *file_name = NULL;
  94                 char *device_addr = NULL;
  95                 int request_id = 0;
  96                 guint64 size = 0;
  97                 bt_share_transfer_info_t transfer_info;
  98
  99                 if (!dbus_message_get_args(msg, NULL,
 100                         DBUS_TYPE_INT32, &result,
 101                         DBUS_TYPE_STRING, &device_addr,
 102                         DBUS_TYPE_STRING, &file_path,
 103                         DBUS_TYPE_UINT64, &size,
 104                         DBUS_TYPE_INT32, &request_id,
 105                         DBUS_TYPE_INVALID)) {
 106                         ERR("Unexpected parameters in signal");
 107                         return;
 108                 }
 109
 110                 file_name = g_path_get_basename(file_path);
 111                 DBG("file_name:%s file_path:%s", file_name, file_path);
 112
 113                 memset(&transfer_info, 0x00, sizeof(bt_share_transfer_info_t));
 114
 115                 transfer_info.device_addr = g_strdup(device_addr);
 116                 transfer_info.filename = g_strdup(file_name);
 117                 transfer_info.size = size;
 118                 transfer_info.percentage = 0;
 119
 120                 event_info.event = BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED;
 121                 event_info.param_data = &transfer_info;
 122                 event_info.result = result;
 123                 event_info.user_data = data;
 124
 125                 _bt_share_ui_event_handler(
 126                                 BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED,
 127                                 &event_info, event_info.user_data);
 128
 129                 g_free(transfer_info.device_addr);
 130                 g_free(transfer_info.filename);
 131                 g_free(file_name);
 132         } else if (strcasecmp(member, BT_TRANSFER_PROGRESS) == 0) {
 133                 char *file_name = NULL;
 134                 int request_id = 0;
 135                 guint64 size = 0;
 136                 int progress = 0;
 137                 bt_share_transfer_info_t transfer_info;
 138
 139                 if (!dbus_message_get_args(msg, NULL,
 140                         DBUS_TYPE_INT32, &result,
 141                         DBUS_TYPE_STRING, &file_name,
 142                         DBUS_TYPE_UINT64, &size,
 143                         DBUS_TYPE_INT32, &progress,
 144                         DBUS_TYPE_INT32, &request_id,
 145                         DBUS_TYPE_INVALID)) {
 146                         ERR("Unexpected parameters in signal");
 147                         return;
 148                 }
 149
 150                 memset(&transfer_info, 0x00, sizeof(bt_share_transfer_info_t));
 151
 152                 transfer_info.filename = g_strdup(file_name);
 153                 transfer_info.size = size;
 154                 transfer_info.percentage = progress;
 155
 156                 event_info.event = BT_SHARE_UI_EVENT_OPC_TRANSFER_PROGRESS;
 157                 event_info.param_data = &transfer_info;
 158                 event_info.result = result;
 159                 event_info.user_data = data;
 160
 161                 _bt_share_ui_event_handler(
 162                                 BT_SHARE_UI_EVENT_OPC_TRANSFER_PROGRESS,
 163                                 &event_info, event_info.user_data);
 164
 165                 g_free(transfer_info.filename);
 166         } else if (strcasecmp(member, BT_TRANSFER_COMPLETED) == 0) {
 167                 char *file_name = NULL;
 168                 char *device_addr = NULL;
 169                 int request_id = 0;
 170                 guint64 size = 0;
 171                 bt_share_transfer_info_t transfer_info;
 172
 173                 if (!dbus_message_get_args(msg, NULL,
 174                         DBUS_TYPE_INT32, &result,
 175                         DBUS_TYPE_STRING, &device_addr,
 176                         DBUS_TYPE_STRING, &file_name,
 177                         DBUS_TYPE_UINT64, &size,
 178                         DBUS_TYPE_INT32, &request_id,
 179                         DBUS_TYPE_INVALID)) {
 180                         ERR("Unexpected parameters in signal");
 181                         return;
 182                 }
 183
 184                 memset(&transfer_info, 0x00, sizeof(bt_share_transfer_info_t));
 185
 186                 transfer_info.device_addr = g_strdup(device_addr);
 187                 transfer_info.filename = g_strdup(file_name);
 188                 transfer_info.size = size;
 189
 190                 event_info.event = BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE;
 191                 event_info.param_data = &transfer_info;
 192                 event_info.result = result;
 193                 event_info.user_data = data;
 194
 195                 _bt_share_ui_event_handler(
 196                                 BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE,
 197                                 &event_info, event_info.user_data);
 198
 199                 g_free(transfer_info.device_addr);
 200                 g_free(transfer_info.filename);
 201         } else if (strcasecmp(member, BT_OPP_CLIENT_DISCONNECTED) == 0) {
 202                 DBG("BT_OPP_CLIENT_DISCONNECTED signal");
 203                 char *device_addr = NULL;
 204                 int request_id = 0;
 205
 206                 if (!dbus_message_get_args(msg, NULL,
 207                         DBUS_TYPE_INT32, &result,
 208                         DBUS_TYPE_STRING, &device_addr,
 209                         DBUS_TYPE_INT32, &request_id,
 210                         DBUS_TYPE_INVALID)) {
 211                         ERR("Unexpected parameters in signal");
 212                         return;
 213                 }
 214
 215                 event_info.event = BT_SHARE_UI_EVENT_OPC_DISCONNECTED;
 216                 event_info.param_data = device_addr;
 217                 event_info.result = result;
 218                 event_info.user_data = data;
 219
 220                 _bt_share_ui_event_handler(
 221                                 BT_SHARE_UI_EVENT_OPC_DISCONNECTED,
 222                                 &event_info, event_info.user_data);
 223         }
 224 }
 225
 226 static void __handle_obex_server_signal(void *data, DBusMessage *msg)
 227 {
 228         bt_share_event_param_t event_info = { 0, };
 229         int result = BT_SHARE_UI_ERROR_NONE;
 230         const char *member = dbus_message_get_member(msg);
 231
 232         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 233         retm_if(msg == NULL, "Invalid argument: msg is NULL\n");
 234         bt_share_appdata_t *ad = (bt_share_appdata_t *)data;
 235         retm_if(ad->tr_type == BT_TR_OUTBOUND, "Invalid tr_type: BT_TR_OUTBOUND");
 236         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 237                 return;
 238
 239         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 240                 return;
 241
 242         if (!dbus_message_has_path(msg, BT_OPP_SERVER_PATH))
 243                 return;
 244
 245         retm_if(member == NULL, "member value is NULL\n");
 246         if (strcasecmp(member, BT_TRANSFER_STARTED) == 0) {
 247                 char *file_name = NULL;
 248                 char *type = NULL;
 249                 char *device_name = NULL;
 250                 char *device_addr = NULL;
 251                 int transfer_id = 0;
 252                 int server_type = 0; /* bt_server_type_t */
 253                 guint64 size = 0;
 254                 bt_share_server_transfer_info_t transfer_info;
 255
 256                 if (!dbus_message_get_args(msg, NULL,
 257                         DBUS_TYPE_INT32, &result,
 258                         DBUS_TYPE_STRING, &device_name,
 259                         DBUS_TYPE_STRING, &file_name,
 260                         DBUS_TYPE_STRING, &type,
 261                         DBUS_TYPE_STRING, &device_addr,
 262                         DBUS_TYPE_UINT64, &size,
 263                         DBUS_TYPE_INT32, &transfer_id,
 264                         DBUS_TYPE_INT32, &server_type,
 265                         DBUS_TYPE_INVALID)) {
 266                         ERR("Unexpected parameters in signal");
 267                         return;
 268                 }
 269
 270                 memset(&transfer_info, 0x00,
 271                         sizeof(bt_share_server_transfer_info_t));
 272
 273                 transfer_info.device_name = g_strdup(device_name);
 274                 transfer_info.address = g_strdup(device_addr);
 275                 transfer_info.filename = g_strdup(file_name);
 276                 transfer_info.type = g_strdup(type);
 277                 transfer_info.file_size = size;
 278                 transfer_info.transfer_id = transfer_id;
 279                 transfer_info.percentage = 0;
 280
 281                 event_info.event = BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED;
 282                 event_info.param_data = &transfer_info;
 283                 event_info.result = result;
 284                 event_info.user_data = data;
 285
 286                 _bt_share_ui_event_handler(
 287                                 BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED,
 288                                 &event_info, event_info.user_data);
 289
 290                 g_free(transfer_info.device_name);
 291                 g_free(transfer_info.address);
 292                 g_free(transfer_info.filename);
 293                 g_free(transfer_info.type);
 294         } else if (strcasecmp(member, BT_TRANSFER_PROGRESS) == 0) {
 295                 char *file_name = NULL;
 296                 char *type = NULL;
 297                 char *device_name = NULL;
 298                 char *device_addr = NULL;
 299                 int transfer_id = 0;
 300                 int progress = 0;
 301                 int server_type = 0; /* bt_server_type_t */
 302                 guint64 size = 0;
 303                 bt_share_server_transfer_info_t transfer_info;
 304
 305                 if (!dbus_message_get_args(msg, NULL,
 306                         DBUS_TYPE_INT32, &result,
 307                         DBUS_TYPE_STRING, &file_name,
 308                         DBUS_TYPE_STRING, &type,
 309                         DBUS_TYPE_STRING, &device_name,
 310                         DBUS_TYPE_STRING, &device_addr,
 311                         DBUS_TYPE_UINT64, &size,
 312                         DBUS_TYPE_INT32, &transfer_id,
 313                         DBUS_TYPE_INT32, &progress,
 314                         DBUS_TYPE_INT32, &server_type,
 315                         DBUS_TYPE_INVALID)) {
 316                         ERR("Unexpected parameters in signal");
 317                         return;
 318                 }
 319
 320                 memset(&transfer_info, 0x00,
 321                         sizeof(bt_share_server_transfer_info_t));
 322
 323                 transfer_info.device_name = g_strdup(device_name);
 324                 transfer_info.address = g_strdup(device_addr);
 325                 transfer_info.filename = g_strdup(file_name);
 326                 transfer_info.type = g_strdup(type);
 327                 transfer_info.file_size = size;
 328                 transfer_info.transfer_id = transfer_id;
 329                 transfer_info.percentage = progress;
 330
 331                 event_info.event = BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_PROGRESS;
 332                 event_info.param_data = &transfer_info;
 333                 event_info.result = result;
 334                 event_info.user_data = data;
 335
 336                 _bt_share_ui_event_handler(
 337                                 BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
 338                                 &event_info, event_info.user_data);
 339
 340                 g_free(transfer_info.device_name);
 341                 g_free(transfer_info.address);
 342                 g_free(transfer_info.filename);
 343                 g_free(transfer_info.type);
 344         } else if (strcasecmp(member, BT_TRANSFER_COMPLETED) == 0) {
 345                 char *file_name = NULL;
 346                 char *device_name = NULL;
 347                 char *device_addr = NULL;
 348                 char *type = NULL;
 349                 char *file_path;
 350                 int transfer_id = 0;
 351                 int server_type = 0; /* bt_server_type_t */
 352                 guint64 size = 0;
 353                 bt_share_server_transfer_info_t transfer_info;
 354
 355                 if (!dbus_message_get_args(msg, NULL,
 356                         DBUS_TYPE_INT32, &result,
 357                         DBUS_TYPE_STRING, &file_name,
 358                         DBUS_TYPE_STRING, &type,
 359                         DBUS_TYPE_STRING, &device_name,
 360                         DBUS_TYPE_STRING, &file_path,
 361                         DBUS_TYPE_STRING, &device_addr,
 362                         DBUS_TYPE_UINT64, &size,
 363                         DBUS_TYPE_INT32, &transfer_id,
 364                         DBUS_TYPE_INT32, &server_type,
 365                         DBUS_TYPE_INVALID)) {
 366                         ERR("Unexpected parameters in signal");
 367                         return;
 368                 }
 369
 370                 memset(&transfer_info, 0x00,
 371                                 sizeof(bt_share_server_transfer_info_t));
 372
 373                 transfer_info.filename = g_strdup(file_name);
 374                 transfer_info.type = g_strdup(type);
 375                 transfer_info.device_name = g_strdup(device_name);
 376                 transfer_info.address = g_strdup(device_addr);
 377                 transfer_info.file_path = g_strdup(file_path);
 378                 transfer_info.file_size = size;
 379                 transfer_info.transfer_id = transfer_id;
 380
 381                 event_info.event = BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_COMPLETED;
 382                 event_info.param_data = &transfer_info;
 383                 event_info.result = result;
 384                 event_info.user_data = data;
 385
 386                 _bt_share_ui_event_handler(
 387                                 BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
 388                                 &event_info, event_info.user_data);
 389
 390                 g_free(transfer_info.filename);
 391                 g_free(transfer_info.type);
 392                 g_free(transfer_info.device_name);
 393                 g_free(transfer_info.address);
 394                 g_free(transfer_info.file_path);
 395         }
 396 }
 397
 398 static void __handle_update_view_signal(void *data, DBusMessage * msg)
 399 {
 400         bt_share_appdata_t *ad;
 401         char *db;
 402
 403         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 404         retm_if(msg == NULL, "Invalid argument: msg is NULL\n");
 405
 406         ad = (bt_share_appdata_t *)data;
 407
 408         DBG("+");
 409
 410         if (!dbus_message_get_args(msg, NULL,
 411                                 DBUS_TYPE_STRING, &db,
 412                                 DBUS_TYPE_INVALID)) {
 413                 ERR("Event handling failed");
 414                 return;
 415         }
 416
 417         _bt_share_ui_handle_update_view(ad, db);
 418 }
 419
 420 static void __handle_opp_disconnect_signal(void *data, DBusMessage * msg)
 421 {
 422         DBG("+");
 423         bt_share_event_param_t event_info = { 0, };
 424         bt_share_server_transfer_info_t transfer_info = { 0, };
 425         char *address = NULL;
 426         char *member = NULL;
 427         int result = BT_SHARE_UI_ERROR_NONE;
 428         int transfer_id = -1;
 429
 430         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 431         retm_if(msg == NULL, "Invalid argument: msg is NULL\n");
 432
 433         member = (char *)dbus_message_get_member(msg);
 434         retm_if(member == NULL, "Invalid argument: member is NULL\n");
 435
 436         if (strcasecmp(member, BT_OPP_CLIENT_DISCONNECTED) == 0) {
 437                 DBG("BT_OPP_CLIENT_DISCONNECTED");
 438                 event_info.event = BT_SHARE_UI_EVENT_OPC_DISCONNECTED;
 439         } else if (strcasecmp(member, BT_OPP_SERVER_DISCONNECTED) == 0) {
 440                 DBG("BT_OPP_SERVER_DISCONNECTED");
 441                 event_info.event = BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED;
 442         } else {
 443                 DBG("Unhandled Signal");
 444                 return;
 445         }
 446
 447         if (!dbus_message_get_args(msg, NULL,
 448                         DBUS_TYPE_INT32, &result,
 449                         DBUS_TYPE_STRING, &address,
 450                         DBUS_TYPE_INT32, &transfer_id,
 451                         DBUS_TYPE_INVALID)) {
 452                 ERR("get_args failed");
 453                 return;
 454         }
 455
 456         transfer_info.file_path = address;
 457         transfer_info.transfer_id = transfer_id;
 458
 459         event_info.result = result;
 460         event_info.user_data = data;
 461         event_info.param_data = &transfer_info;
 462
 463         _bt_share_ui_event_handler(event_info.event, &event_info,
 464                         event_info.user_data);
 465
 466         DBG("-");
 467 }
 468
 469 static void __handle_home_key_signal(void *data, DBusMessage *msg)
 470 {
 471         const char *member;
 472
 473         retm_if(data == NULL, "Invalid argument: data is NULL");
 474         retm_if(msg == NULL, "Invalid argument: msg is NULL");
 475
 476         member = dbus_message_get_member(msg);
 477         retm_if(member == NULL, "member value is NULL");
 478
 479         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 480                 return;
 481
 482         if (!dbus_message_has_interface(msg, DBUS_CORE_APPS_INTERFACE) ||
 483                 !dbus_message_has_path(msg, DBUS_CORE_APPS_PATH))
 484                 return;
 485
 486         DBG("Received signal : %s", member);
 487
 488         if (strcasecmp(member, DBUS_CORE_APPS_MEMBER) == 0)
 489                 _bt_terminate_app();
 490 }
 491
 492 static void __bt_add_tr_data_list(bt_share_appdata_t *ad, int transfer_type)
 493 {
 494         GSList *list = NULL;
 495         GSList *next = NULL;
 496         sqlite3 *db = NULL;
 497         bt_tr_data_t *info = NULL;
 498         bt_tr_data_t *tr_data = NULL;
 499         int success = 0;
 500         int failed = 0;
 501         int len = 0;
 502         int i;
 503         retm_if(!ad, "ad is NULL!");
 504
 505         GSList *tr_data_list = ad->tr_data_list;
 506         retm_if(!tr_data_list, "tr_data_list is NULL!");
 507
 508         Elm_Object_Item *git = elm_genlist_item_next_get(ad->file_title_item);
 509
 510         db = bt_share_open_db();
 511         if (!db)
 512                 return;
 513
 514         list = bt_share_get_all_tr_data_by_sid(db, transfer_type,
 515                         ad->transfer_info->device_address, ad->transfer_info->db_sid);
 516         bt_share_close_db(db);
 517         retm_if(!list, "fail to get tr list!");
 518
 519         /* Append new tr data to tr_data_list */
 520         len = g_slist_length(list);
 521         next = list;
 522         for (i = 0; i < len; i++) {
 523                 info = next->data;
 524
 525                 if (info == NULL) {
 526                         next = g_slist_next(next);
 527                         if (tr_data_list)
 528                                 tr_data_list = g_slist_next(tr_data_list);
 529                         if (git)
 530                                 git = elm_genlist_item_next_get(git);
 531
 532                         if (next == NULL)
 533                                 break;
 534                         else
 535                                 continue;
 536                 }
 537
 538                 if (info->tr_status == BT_TRANSFER_SUCCESS)
 539                         success++;
 540                 else if (info->tr_status == BT_TRANSFER_FAIL)
 541                         failed++;
 542
 543                 DBG_SECURE("ID :%d Status:%d Filename :%s", info->id,
 544                                 info->tr_status, info->file_path);
 545
 546
 547                 if (transfer_type == BT_TR_OUTBOUND &&
 548                                 info->id > ad->outbound_latest_id) {
 549                         tr_data = g_new0(bt_tr_data_t, 1);
 550                         tr_data->id = info->id;
 551                         tr_data->sid = info->sid;
 552                         tr_data->tr_status = info->tr_status;
 553                         tr_data->file_path = g_strdup(info->file_path);
 554                         tr_data->dev_name = g_strdup(info->dev_name);
 555                         tr_data->timestamp = info->timestamp;
 556                         tr_data->addr = g_strdup(info->addr);
 557                         tr_data->type = g_strdup(info->type);
 558                         tr_data->content = g_strdup(info->content);
 559                         tr_data->size = info->size;
 560                         ad->tr_data_list = g_slist_append(ad->tr_data_list, tr_data);
 561                 } else if (transfer_type == BT_TR_INBOUND &&
 562                                 info->id > ad->inbound_latest_id) {
 563                         tr_data = g_new0(bt_tr_data_t, 1);
 564                         tr_data->id = info->id;
 565                         tr_data->sid = info->sid;
 566                         tr_data->tr_status = info->tr_status;
 567                         tr_data->file_path = g_strdup(info->file_path);
 568                         tr_data->dev_name = g_strdup(info->dev_name);
 569                         tr_data->timestamp = info->timestamp;
 570                         tr_data->addr = g_strdup(info->addr);
 571                         tr_data->type = g_strdup(info->type);
 572                         tr_data->content = g_strdup(info->content);
 573                         tr_data->size = info->size;
 574                         ad->tr_data_list = g_slist_append(ad->tr_data_list, tr_data);
 575                 } else {
 576                         // Update data in list
 577                         bt_tr_data_t *list_info = NULL;
 578                         list_info = tr_data_list->data;
 579                         if (list_info->id == info->id) {
 580                                 list_info->timestamp = info->timestamp;
 581                                 list_info->tr_status = info->tr_status;
 582                                 list_info->size = info->size;
 583                                 if (list_info->type == NULL)
 584                                         list_info->type = g_strdup(info->type);
 585
 586                                 if (list_info->tr_status == BT_TRANSFER_ONGOING)
 587                                         ad->current_item = git;
 588                         }
 589                 }
 590
 591                 next = g_slist_next(next);
 592                 if (next == NULL)
 593                         break;
 594
 595                 if (tr_data_list)
 596                         tr_data_list = g_slist_next(tr_data_list);
 597                 if (git)
 598                         git = elm_genlist_item_next_get(git);
 599         }
 600
 601         ad->transfer_info->success = success;
 602         ad->transfer_info->failed = failed;
 603         DBG("SUCCESS:%d, FAILED:%d", success, failed);
 604         if (ad->status_item)
 605                 elm_genlist_item_fields_update(ad->status_item, "*",
 606                                 ELM_GENLIST_ITEM_FIELD_TEXT);
 607
 608         bt_share_release_tr_data_list(list);
 609 }
 610
 611 void _bt_signal_init(bt_share_appdata_t *ad)
 612 {
 613         E_DBus_Connection *conn = NULL;
 614         E_DBus_Signal_Handler *sh = NULL;
 615         e_dbus_init();
 616
 617         conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 618         retm_if(conn == NULL, "conn is NULL\n");
 619
 620         e_dbus_request_name(conn, BT_SHARE_UI_INTERFACE, 0, NULL, NULL);
 621
 622         sh = e_dbus_signal_handler_add(conn,
 623                                        NULL,
 624                                        BT_OPP_CLIENT_PATH,
 625                                        BT_EVENT_SERVICE,
 626                                        BT_OPP_CONNECTED,
 627                                        __handle_opp_client_signal, ad);
 628         retm_if(sh == NULL, "Connect Event register failed\n");
 629         ad->client_connected_sh = sh;
 630
 631         sh = e_dbus_signal_handler_add(conn,
 632                                        NULL,
 633                                        BT_OPP_CLIENT_PATH,
 634                                        BT_EVENT_SERVICE,
 635                                        BT_TRANSFER_STARTED,
 636                                        __handle_opp_client_signal, ad);
 637         retm_if(sh == NULL, "started Event register failed\n");
 638         ad->client_started_sh = sh;
 639
 640         sh = e_dbus_signal_handler_add(conn,
 641                                        NULL,
 642                                        BT_OPP_CLIENT_PATH,
 643                                        BT_EVENT_SERVICE,
 644                                        BT_TRANSFER_PROGRESS,
 645                                        __handle_opp_client_signal, ad);
 646         retm_if(sh == NULL, "progress Event register failed\n");
 647         ad->client_progress_sh = sh;
 648
 649         sh = e_dbus_signal_handler_add(conn,
 650                                        NULL,
 651                                        BT_OPP_CLIENT_PATH,
 652                                        BT_EVENT_SERVICE,
 653                                        BT_TRANSFER_COMPLETED,
 654                                        __handle_opp_client_signal, ad);
 655         retm_if(sh == NULL, "complete Event register failed\n");
 656         ad->client_completed_sh = sh;
 657
 658         sh = e_dbus_signal_handler_add(conn,
 659                                        NULL,
 660                                        BT_OPP_SERVER_PATH,
 661                                        BT_EVENT_SERVICE,
 662                                        BT_TRANSFER_STARTED,
 663                                        __handle_obex_server_signal, ad);
 664         retm_if(sh == NULL, "started Event register failed\n");
 665         ad->server_started_sh = sh;
 666
 667         sh = e_dbus_signal_handler_add(conn,
 668                                        NULL,
 669                                        BT_OPP_SERVER_PATH,
 670                                        BT_EVENT_SERVICE,
 671                                        BT_TRANSFER_PROGRESS,
 672                                        __handle_obex_server_signal, ad);
 673         retm_if(sh == NULL, "progress Event register failed\n");
 674         ad->server_progress_sh = sh;
 675
 676         sh = e_dbus_signal_handler_add(conn,
 677                                        NULL,
 678                                        BT_OPP_SERVER_PATH,
 679                                        BT_EVENT_SERVICE,
 680                                        BT_TRANSFER_COMPLETED,
 681                                        __handle_obex_server_signal, ad);
 682         retm_if(sh == NULL, "complete Event register failed\n");
 683         ad->server_completed_sh = sh;
 684
 685         sh = e_dbus_signal_handler_add(conn,
 686                                         NULL,
 687                                         BT_SHARE_ENG_OBJECT,
 688                                         BT_SHARE_ENG_INTERFACE,
 689                                         BT_SHARE_ENG_SIGNAL_UPDATE_VIEW,
 690                                         __handle_update_view_signal, ad);
 691
 692         retm_if(sh == NULL, "Progress Event register failed\n");
 693         ad->update_sh = sh;
 694
 695         sh = e_dbus_signal_handler_add(conn,
 696                                            NULL,
 697                                            BT_SHARE_ENG_OBJECT,
 698                                            BT_SHARE_ENG_INTERFACE,
 699                                            BT_OPP_CLIENT_DISCONNECTED,
 700                                            __handle_opp_disconnect_signal, ad);
 701         retm_if(sh == NULL, "Disconnected Event register failed\n");
 702         ad->client_disconnected_sh = sh;
 703
 704         sh = e_dbus_signal_handler_add(conn,
 705                                            NULL,
 706                                            BT_SHARE_ENG_OBJECT,
 707                                            BT_SHARE_ENG_INTERFACE,
 708                                            BT_OPP_SERVER_DISCONNECTED,
 709                                            __handle_opp_disconnect_signal, ad);
 710         retm_if(sh == NULL, "Disconnected Event register failed\n");
 711         ad->server_disconnected_sh = sh;
 712
 713         sh = e_dbus_signal_handler_add(conn,
 714                                         NULL,
 715                                         DBUS_CORE_APPS_PATH,
 716                                         DBUS_CORE_APPS_INTERFACE,
 717                                         DBUS_CORE_APPS_MEMBER,
 718                                         __handle_home_key_signal, ad);
 719         retm_if(sh == NULL, "Connect Event register failed");
 720         ad->app_core_sh = sh;
 721
 722         ad->dbus_conn = conn;
 723
 724         return;
 725 }
 726
 727 void _bt_signal_deinit(bt_share_appdata_t *ad)
 728 {
 729         ret_if(ad == NULL);
 730
 731         if (ad->client_connected_sh) {
 732                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_connected_sh);
 733                 ad->client_connected_sh = NULL;
 734         }
 735         if (ad->client_started_sh) {
 736                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_started_sh);
 737                 ad->client_started_sh = NULL;
 738         }
 739         if (ad->client_progress_sh) {
 740                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_progress_sh);
 741                 ad->client_progress_sh = NULL;
 742         }
 743         if (ad->client_completed_sh) {
 744                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_completed_sh);
 745                 ad->client_completed_sh = NULL;
 746         }
 747         if (ad->server_started_sh) {
 748                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_started_sh);
 749                 ad->server_started_sh = NULL;
 750         }
 751         if (ad->server_progress_sh) {
 752                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_progress_sh);
 753                 ad->server_progress_sh = NULL;
 754         }
 755         if (ad->server_completed_sh) {
 756                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_completed_sh);
 757                 ad->server_completed_sh = NULL;
 758         }
 759         if (ad->client_disconnected_sh) {
 760                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_disconnected_sh);
 761                 ad->client_disconnected_sh = NULL;
 762         }
 763         if (ad->server_disconnected_sh) {
 764                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_disconnected_sh);
 765                 ad->server_disconnected_sh = NULL;
 766         }
 767         if (ad->update_sh) {
 768                 e_dbus_signal_handler_del(ad->dbus_conn, ad->update_sh);
 769                 ad->update_sh = NULL;
 770         }
 771         if (ad->app_core_sh) {
 772                 e_dbus_signal_handler_del(ad->dbus_conn, ad->app_core_sh);
 773                 ad->app_core_sh = NULL;
 774         }
 775         return;
 776 }
 777
 778 int _bt_abort_signal_send(bt_share_appdata_t *ad,
 779                 bt_share_abort_data_t *abort_data)
 780 {
 781         DBG("+");
 782         DBusMessage *msg = NULL;
 783
 784         retvm_if(abort_data == NULL, -1,
 785                  "progressbar data is NULL\n");
 786         retvm_if(ad->dbus_conn == NULL, -1,
 787                  "Invalid argument: ad->dbus_conn is NULL\n");
 788
 789         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 790                         BT_SHARE_UI_INTERFACE,
 791                         BT_SHARE_UI_SIGNAL_OPPABORT);
 792
 793         retvm_if(msg == NULL, -1, "msg is NULL\n");
 794
 795         if (!dbus_message_append_args(msg,
 796                         DBUS_TYPE_STRING, &abort_data->transfer_type,
 797                         DBUS_TYPE_INT32, &abort_data->transfer_id,
 798                         DBUS_TYPE_INVALID)) {
 799                 ERR("Abort sending failed");
 800                 dbus_message_unref(msg);
 801                 return -1;
 802         }
 803
 804         ad->opp_transfer_abort = TRUE; /* Transfer aborted by user */
 805
 806         INFO("abort_data->transfer_type = %s", abort_data->transfer_type);
 807         INFO("abort_data->transfer_id = %d", abort_data->transfer_id);
 808
 809         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
 810         dbus_message_unref(msg);
 811         DBG("-");
 812         return 0;
 813 }
 814
 815 static void __bt_conv_addr_string_to_addr_type(char *addr,
 816                                                   const char *address)
 817 {
 818         int i;
 819         char *ptr = NULL;
 820
 821         if (!address || !addr)
 822                 return;
 823
 824         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 825                 addr[i] = strtol(address, &ptr, 16);
 826                 if (ptr != NULL) {
 827                         if (ptr[0] != ':')
 828                                 return;
 829
 830                         address = ptr + 1;
 831                 }
 832         }
 833 }
 834
 835 int _bt_share_ui_retry_failed(bt_share_appdata_t *ad)
 836 {
 837         DBG("+");
 838         DBusMessage *msg = NULL;
 839         DBusMessageIter iter;
 840         DBusMessageIter array_iter;
 841         DBusMessageIter file_iter;
 842         DBusMessageIter filepath_iter;
 843         char *bd_addr = NULL;
 844         char **file_path = NULL;
 845         int i;
 846         int count;
 847         bt_tr_data_t *info = NULL;
 848         int files_count;
 849         int valid_files_count;
 850         GSList *current = NULL;
 851         GSList *failed = NULL;
 852
 853         DBG_SECURE("Device:%s SID:%s", ad->transfer_info->device_address,
 854                         ad->transfer_info->db_sid);
 855
 856         failed = ad->tr_data_list;
 857
 858         retvm_if(failed == NULL, -1, "Invalid argument: info is NULL\n");
 859
 860         retvm_if(ad->dbus_conn == NULL, -1,
 861                         "Invalid argument: ad->dbus_conn is NULL\n");
 862
 863         files_count = g_slist_length(failed);
 864         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 865                                                 BT_SHARE_UI_INTERFACE,
 866                                                 BT_SHARE_UI_SIGNAL_SEND_FILE);
 867
 868         if (msg == NULL) {
 869                 ERR("msg is NULL");
 870                 return -1;
 871         }
 872
 873         bd_addr = g_new0(char, BT_ADDRESS_LENGTH_MAX);
 874         __bt_conv_addr_string_to_addr_type((char *)bd_addr,
 875                         ad->transfer_info->device_address);
 876
 877         file_path = g_new0(char *, files_count);
 878         current = failed;
 879         count = 0;
 880         DBG("Total files: %d", files_count);
 881
 882         while (current && (count < files_count)) {
 883                 info = current->data;
 884
 885                 if (info->tr_status != BT_TRANSFER_FAIL) {
 886                         current = g_slist_next(current);
 887                         continue;
 888                 }
 889
 890                 /* check for valid utf8 file*/
 891                 if (!g_utf8_validate(info->file_path, -1, NULL)) {
 892                         ERR_SECURE("Invalid filepath: %s", info->file_path);
 893                         notification_status_message_post(BT_STR_UNABLE_TO_SEND);
 894                         goto done;
 895                 }
 896
 897                 /* file validation check begin*/
 898                 if (access(info->file_path, F_OK) != 0) {
 899                         ERR_SECURE("access failed for %s. May be file is deleted from the Device", info->file_path);
 900                         notification_status_message_post(BT_STR_FILE_NOT_EXIST);
 901                         goto done;
 902                 }
 903                 /* file validation check end*/
 904
 905                 file_path[count] = g_strdup(info->content);
 906
 907                 current = g_slist_next(current);
 908                 count++;
 909         }
 910
 911         dbus_message_iter_init_append(msg, &iter);
 912
 913         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 914                                 DBUS_TYPE_BYTE_AS_STRING, &array_iter);
 915
 916         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 917                 dbus_message_iter_append_basic(&array_iter,
 918                                 DBUS_TYPE_BYTE, &bd_addr[i]);
 919         }
 920         dbus_message_iter_close_container(&iter, &array_iter);
 921
 922         if (info) {
 923                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 924                                                         &info->dev_name);
 925                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 926                                                         &info->type);
 927         }
 928
 929         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 930                                 DBUS_TYPE_ARRAY_AS_STRING
 931                                 DBUS_TYPE_BYTE_AS_STRING, &file_iter);
 932
 933         if (file_path) {
 934                 valid_files_count = count;
 935                 for (count = 0; count < valid_files_count; count++) {
 936                         int file_length;
 937                         dbus_message_iter_open_container(&file_iter, DBUS_TYPE_ARRAY,
 938                                         DBUS_TYPE_BYTE_AS_STRING, &filepath_iter);
 939                         file_length = strlen(file_path[count]);
 940                         for (i = 0; i < file_length; i++) {
 941                                 dbus_message_iter_append_basic(&filepath_iter, DBUS_TYPE_BYTE,
 942                                                 &file_path[count][i]);
 943                         }
 944                         dbus_message_iter_close_container(&file_iter, &filepath_iter);
 945                 }
 946         }
 947         dbus_message_iter_close_container(&iter, &file_iter);
 948
 949         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
 950
 951 done:
 952         dbus_message_unref(msg);
 953         g_free(bd_addr);
 954         if (file_path) {
 955                 for (count = 0; count < files_count; count++)
 956                         g_free(file_path[count]);
 957                 g_free(file_path);
 958         }
 959
 960         DBG("-");
 961         return 0;
 962 }
 963
 964 int _bt_share_ui_ipc_info_update(bt_share_appdata_t *ad, int uid)
 965 {
 966         DBG("+");
 967         retv_if(ad == NULL, -1);
 968
 969         DBusMessage *msg = NULL;
 970         int info_uid = 0;
 971         int info_type = 0;
 972
 973         info_uid = uid;
 974         info_type = ad->tr_type;
 975
 976         INFO("info_uid = %d", info_uid);
 977         INFO("info_type = %d", info_type);
 978
 979         retvm_if(ad->dbus_conn == NULL, -1,
 980                         "Invalid argument: ad->dbus_conn is NULL\n");
 981
 982         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 983                                       BT_SHARE_UI_INTERFACE,
 984                                       BT_SHARE_UI_SIGNAL_INFO_UPDATE);
 985
 986         retvm_if(msg == NULL, -1, "msg is NULL\n");
 987
 988         if (!dbus_message_append_args(msg,
 989                                       DBUS_TYPE_INT32, &info_uid,
 990                                       DBUS_TYPE_INT32, &info_type,
 991                                       DBUS_TYPE_INVALID)) {
 992                 ERR("Connect sending failed");
 993                 dbus_message_unref(msg);
 994                 return -1;
 995         }
 996
 997         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
 998         dbus_message_unref(msg);
 999
1000         DBG("-");
1001         return 0;
1002 }
1003
1004 void _bt_share_ui_handle_update_view(bt_share_appdata_t *ad,
1005                                                 char *table)
1006 {
1007         GSList *list_iter = NULL;
1008         bt_tr_data_t *info = NULL;
1009         int transfer_type;
1010         Elm_Object_Item *git;
1011         DBG("+");
1012
1013         if (g_strcmp0(table, BT_INBOUND_TABLE) == 0)
1014                 transfer_type = BT_TR_INBOUND;
1015         else if (g_strcmp0(table, BT_OUTBOUND_TABLE) == 0)
1016                 transfer_type = BT_TR_OUTBOUND;
1017         else
1018                 return;
1019
1020         __bt_add_tr_data_list(ad, transfer_type);
1021
1022         /* Insert new transfer result to first genlist item  */
1023         list_iter = ad->tr_data_list;
1024         if (transfer_type == BT_TR_INBOUND && ad->tr_type == BT_TR_INBOUND) {
1025                 while (NULL != list_iter) {
1026                         info = list_iter->data;
1027                         if (info->id > ad->inbound_latest_id) {
1028                                 _bt_genlist_append_tr_data_item
1029                                                 (ad, info, transfer_type);
1030                         }
1031
1032                         list_iter = g_slist_next(list_iter);
1033                 }
1034         } else if (transfer_type == BT_TR_OUTBOUND &&
1035                 ad->tr_type == BT_TR_OUTBOUND) {
1036                 while (NULL != list_iter) {
1037                         info = list_iter->data;
1038                         if (info->id > ad->outbound_latest_id) {
1039                                 _bt_genlist_append_tr_data_item
1040                                                 (ad, info, transfer_type);
1041                         }
1042                         list_iter = g_slist_next(list_iter);
1043                 }
1044         }
1045
1046         /* Update Finished and Processing Items */
1047         if (ad->current_item) {
1048                 _bt_share_genlist_item_content_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_ICON);
1049                 _bt_share_genlist_item_text_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_TEXT);
1050                 _bt_share_genlist_item_text_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_SIZE);
1051
1052                 git = elm_genlist_item_prev_get(ad->current_item);
1053                 _bt_share_genlist_item_content_update(git, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_ICON);
1054                 _bt_share_genlist_item_text_update(git, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_TEXT);
1055                 _bt_share_genlist_item_text_update(git, BT_SHARE_ITEM_PART_FILE_SIZE);
1056         }
1057
1058         evas_object_show(ad->tr_genlist);
1059         DBG("-");
1060 }
1061
1062 static void __bt_share_ui_handle_progress(bt_share_appdata_t *ad,
1063                                         int transfer_id, char *name, int percentage,
1064                                         gboolean completed, int error_type)
1065 {
1066
1067         if (completed == FALSE)
1068                 _bt_update_progressbar(ad, transfer_id, name, percentage);
1069 }
1070 static void __bt_share_ui_handle_error(bt_share_appdata_t *ad, int error_type,
1071                                                 bt_share_tr_type_e trans_type)
1072 {
1073         DBG("Error type : %d", error_type);
1074
1075         switch (error_type) {
1076         case BT_SHARE_UI_ERROR_NOT_CONNECTED:
1077                 _bt_create_info_popup(ad, BT_STR_UNABLE_TO_SEND);
1078                 break;
1079         case BT_SHARE_UI_ERROR_CANCEL:
1080                 DBG("opp_transfer_abort by user:%d, trans_type = %d",
1081                         ad->opp_transfer_abort, ad->tr_type);
1082                 if ((trans_type == BT_TR_INBOUND) &&
1083                         !ad->opp_transfer_abort)
1084                         _bt_create_info_popup(ad, BT_STR_UNABLE_TO_RECEIVE);
1085                 else if (!ad->opp_transfer_abort &&
1086                                         (trans_type == BT_TR_OUTBOUND))
1087                         _bt_create_info_popup(ad, BT_STR_UNABLE_TO_SEND);
1088                 ad->opp_transfer_abort = FALSE;
1089                 break;
1090         default:
1091                 break;
1092         }
1093 }
1094
1095 void _bt_share_ui_event_handler(int event, bt_share_event_param_t *param,
1096                                void *user_data){
1097
1098         FN_START;
1099         bt_share_server_transfer_info_t *transfer_info = NULL;
1100         bt_share_transfer_info_t *client_info = NULL;
1101         char *name = NULL;
1102         int percentage = 0;
1103         bt_share_appdata_t *ad = (bt_share_appdata_t *)user_data;
1104
1105         switch (event) {
1106         case BT_SHARE_UI_EVENT_OPC_CONNECTED:
1107                 INFO("BT_SHARE_UI_EVENT_OPC_CONNECTED");
1108                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1109                         __bt_share_ui_handle_error(ad, param->result,
1110                                         BT_TR_OUTBOUND);
1111                         _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1112                 }
1113
1114                 /* Set to false when new Outbound OPP session is started*/
1115                 opc_launched_session = FALSE;
1116                 break;
1117
1118         case BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED:
1119                 if (opc_launched_session == FALSE) {
1120                         /* Do not process events for new OPP Session */
1121                         INFO("TRANSFER_STARTED: Different Obex Session");
1122                         return;
1123                 }
1124
1125                 INFO("BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED");
1126                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1127                         client_info = (bt_share_transfer_info_t *)param->param_data;
1128                         if (client_info) {
1129                                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1130                                 _bt_share_ui_handle_transfer_started(ad,
1131                                         client_info->device_addr, client_info->filename,
1132                                         client_info->size, 0, BT_TR_OUTBOUND);
1133                         }
1134                 }
1135                 break;
1136
1137         case BT_SHARE_UI_EVENT_OPC_TRANSFER_PROGRESS:
1138                 if (opc_launched_session == FALSE) {
1139                         /* Do not process events for new OPP Session */
1140                         return;
1141                 }
1142
1143                 client_info = (bt_share_transfer_info_t *)param->param_data;
1144
1145                 name =  strrchr(client_info->filename, '/');
1146                 if (name)
1147                         name++;
1148                 else
1149                         name = client_info->filename;
1150
1151                 percentage = client_info->percentage;
1152                 __bt_share_ui_handle_progress(ad, 0, name, percentage,
1153                                         FALSE, BT_SHARE_UI_ERROR_NONE);
1154                 break;
1155
1156         case BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE:
1157                 if (opc_launched_session == FALSE) {
1158                         /* Do not process events for new OPP Session */
1159                         INFO("TRANSFER_COMPLETE: Different Obex Session");
1160                         return;
1161                 }
1162
1163                 INFO("BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE ");
1164                 client_info = (bt_share_transfer_info_t *)param->param_data;
1165
1166                 if (g_strcmp0(ad->transfer_info->device_address, client_info->device_addr))
1167                         return;
1168
1169                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1170                         __bt_share_ui_handle_error(ad, param->result,
1171                                         BT_TR_OUTBOUND);
1172                         if (ad->tr_view)
1173                                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1174                         else if (ad->info_popup == NULL)
1175                                 _bt_terminate_app();
1176
1177                         _bt_share_ui_handle_transfer_complete(ad, client_info->device_addr,
1178                                         BT_TR_OUTBOUND);
1179
1180                         return;
1181                 }
1182
1183                 INFO_SECURE("client_info->filename = [%s]",
1184                                 client_info->filename);
1185
1186                 name =  strrchr(client_info->filename, '/');
1187                 if (name)
1188                         name++;
1189                 else
1190                         name = client_info->filename;
1191
1192                 INFO("name address = [%x]", name);
1193                 __bt_share_ui_handle_progress(ad, 0, name, 100, TRUE,
1194                                 param->result);
1195
1196                 if (ad->tr_view == NULL)
1197                         _bt_terminate_app();
1198                 else
1199                         _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1200
1201                 _bt_share_ui_handle_transfer_complete(ad, client_info->device_addr,
1202                                 BT_TR_OUTBOUND);
1203
1204                 break;
1205         case BT_SHARE_UI_EVENT_OPC_DISCONNECTED: {
1206                 GSList *failed = NULL;
1207                 sqlite3 *db = NULL;
1208
1209                 INFO("BT_SHARE_UI_EVENT_OPC_DISCONNECTED");
1210
1211                 db = bt_share_open_db();
1212                 retm_if(!db, "fail to open db!");
1213
1214                 failed = bt_share_get_failed_tr_data_by_sid(db,
1215                                 ad->tr_type, ad->transfer_info->device_address,
1216                                 ad->transfer_info->db_sid);
1217                 bt_share_close_db(db);
1218
1219                 if (failed) {
1220                         /* Some failed items are there */
1221                         elm_object_text_set(ad->toolbar_button,
1222                                                 BT_STR_RESEND_FAILED_FILES);
1223                         elm_object_disabled_set(ad->toolbar_button, FALSE);
1224                         /*free list*/
1225                         bt_share_release_tr_data_list(failed);
1226                 } else
1227                         _bt_share_delete_toolbar_button(ad);
1228                 ad->launch_mode = BT_LAUNCH_TRANSFER_LIST;
1229
1230                 _bt_share_ui_handle_transfer_disconnected(ad, BT_TR_OUTBOUND);
1231                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1232
1233                 elm_genlist_realized_items_update(ad->tr_genlist);
1234
1235                 break;
1236         }
1237         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1238                 INFO("BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1239                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1240                         transfer_info = param->param_data;
1241
1242                         if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1243                                 /* Different session */
1244                                 INFO("TRANSFER_STARTED: Different Session");
1245                                 return;
1246                         }
1247
1248                         _bt_share_ui_handle_transfer_started(ad, transfer_info->address,
1249                                         transfer_info->filename, transfer_info->file_size, transfer_info->transfer_id,
1250                                         BT_TR_INBOUND);
1251                 }
1252                 break;
1253         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1254                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1255                         transfer_info = param->param_data;
1256
1257                         if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1258                                 /* Different session */
1259                                 return;
1260                         }
1261                         __bt_share_ui_handle_progress(ad,
1262                                         transfer_info->transfer_id,
1263                                         transfer_info->filename,
1264                                         transfer_info->percentage,
1265                                         FALSE, BT_SHARE_UI_ERROR_NONE);
1266                 }
1267                 break;
1268
1269         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1270                 INFO("BT_SHARE_UI_EVENT_OBEX_TRANSFER_COMPLETED ");
1271
1272                 transfer_info = param->param_data;
1273                 if (g_strcmp0(ad->transfer_info->device_address, transfer_info->address))
1274                         return;
1275
1276                 if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1277                         /* Different session */
1278                         INFO("TRANSFER_STARTED: Different Session");
1279                         return;
1280                 }
1281
1282                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1283                         __bt_share_ui_handle_error(ad, param->result,
1284                                         BT_TR_INBOUND);
1285                         if (ad->tr_view)
1286                                 _bt_share_ui_handle_update_view(ad,
1287                                                 BT_INBOUND_TABLE);
1288
1289                         _bt_share_ui_handle_transfer_complete(ad, transfer_info->address,
1290                                         BT_TR_INBOUND);
1291                         return;
1292                 }
1293
1294                 if (ad->tr_view == NULL)
1295                         _bt_terminate_app();
1296                 else
1297                         _bt_share_ui_handle_update_view(ad, BT_INBOUND_TABLE);
1298
1299                 _bt_share_ui_handle_transfer_complete(ad, transfer_info->address,
1300                                 BT_TR_INBOUND);
1301                 break;
1302
1303         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED: {
1304                 DBG("BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED");
1305                 transfer_info = param->param_data;
1306                 INFO("transfer_info->transfer_id: [%d]", transfer_info->transfer_id);
1307                 INFO("ad->transfer_info->transfer_id: [%d]", ad->transfer_info->transfer_id);
1308                 if (transfer_info->transfer_id == ad->transfer_info->transfer_id) {
1309                         DBG("Same session");
1310                         _bt_share_delete_toolbar_button(ad);
1311                         _bt_share_ui_handle_transfer_disconnected(ad, BT_TR_INBOUND);
1312
1313                         _bt_share_ui_handle_update_view(ad, BT_INBOUND_TABLE);
1314                         elm_genlist_realized_items_update(ad->tr_genlist);
1315                 }
1316         }
1317         break;
1318
1319         default:
1320                 DBG("Unhandled event %x", event);
1321                 break;
1322         }
1323         FN_END;
1324
1325 }