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