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 <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                         tr_data_list = g_slist_next(tr_data_list);
 528                         if (tr_data_list == NULL)
 529                                 break;
 530
 531                         if (git)
 532                                 git = elm_genlist_item_next_get(git);
 533
 534                         if (next == NULL)
 535                                 break;
 536                         else
 537                                 continue;
 538                 }
 539
 540                 if (info->tr_status == BT_TRANSFER_SUCCESS)
 541                         success++;
 542                 else if (info->tr_status == BT_TRANSFER_FAIL)
 543                         failed++;
 544
 545                 DBG_SECURE("ID :%d Status:%d Filename :%s", info->id,
 546                                 info->tr_status, info->file_path);
 547
 548
 549                 if (transfer_type == BT_TR_OUTBOUND &&
 550                                 info->id > ad->outbound_latest_id) {
 551                         tr_data = g_new0(bt_tr_data_t, 1);
 552                         tr_data->id = info->id;
 553                         tr_data->sid = info->sid;
 554                         tr_data->tr_status = info->tr_status;
 555                         tr_data->file_path = g_strdup(info->file_path);
 556                         tr_data->dev_name = g_strdup(info->dev_name);
 557                         tr_data->timestamp = info->timestamp;
 558                         tr_data->addr = g_strdup(info->addr);
 559                         tr_data->type = g_strdup(info->type);
 560                         tr_data->content = g_strdup(info->content);
 561                         tr_data->size = info->size;
 562                         ad->tr_data_list = g_slist_append(ad->tr_data_list, tr_data);
 563                 } else if (transfer_type == BT_TR_INBOUND &&
 564                                 info->id > ad->inbound_latest_id) {
 565                         tr_data = g_new0(bt_tr_data_t, 1);
 566                         tr_data->id = info->id;
 567                         tr_data->sid = info->sid;
 568                         tr_data->tr_status = info->tr_status;
 569                         tr_data->file_path = g_strdup(info->file_path);
 570                         tr_data->dev_name = g_strdup(info->dev_name);
 571                         tr_data->timestamp = info->timestamp;
 572                         tr_data->addr = g_strdup(info->addr);
 573                         tr_data->type = g_strdup(info->type);
 574                         tr_data->content = g_strdup(info->content);
 575                         tr_data->size = info->size;
 576                         ad->tr_data_list = g_slist_append(ad->tr_data_list, tr_data);
 577                 } else {
 578                         // Update data in list
 579                         bt_tr_data_t *list_info = NULL;
 580                         list_info = tr_data_list->data;
 581
 582                         if (list_info) {
 583                                 if (list_info->id == info->id) {
 584                                         list_info->timestamp = info->timestamp;
 585                                         list_info->tr_status = info->tr_status;
 586                                         list_info->size = info->size;
 587                                         if (list_info->type == NULL)
 588                                                 list_info->type = g_strdup(info->type);
 589
 590                                         if (list_info->tr_status == BT_TRANSFER_ONGOING)
 591                                                 ad->current_item = git;
 592                                 }
 593                         }
 594                 }
 595
 596                 next = g_slist_next(next);
 597                 if (next == NULL)
 598                         break;
 599
 600                 tr_data_list = g_slist_next(tr_data_list);
 601
 602                 if (git)
 603                         git = elm_genlist_item_next_get(git);
 604         }
 605
 606         ad->transfer_info->success = success;
 607         ad->transfer_info->failed = failed;
 608         DBG("SUCCESS:%d, FAILED:%d", success, failed);
 609         if (ad->status_item)
 610                 elm_genlist_item_fields_update(ad->status_item, "*",
 611                                 ELM_GENLIST_ITEM_FIELD_TEXT);
 612
 613         bt_share_release_tr_data_list(list);
 614 }
 615
 616 void _bt_signal_init(bt_share_appdata_t *ad)
 617 {
 618         E_DBus_Connection *conn = NULL;
 619         E_DBus_Signal_Handler *sh = NULL;
 620         e_dbus_init();
 621
 622         conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 623         retm_if(conn == NULL, "conn is NULL\n");
 624
 625         e_dbus_request_name(conn, BT_SHARE_UI_INTERFACE, 0, NULL, NULL);
 626
 627         sh = e_dbus_signal_handler_add(conn,
 628                                        NULL,
 629                                        BT_OPP_CLIENT_PATH,
 630                                        BT_EVENT_SERVICE,
 631                                        BT_OPP_CONNECTED,
 632                                        __handle_opp_client_signal, ad);
 633         retm_if(sh == NULL, "Connect Event register failed\n");
 634         ad->client_connected_sh = sh;
 635
 636         sh = e_dbus_signal_handler_add(conn,
 637                                        NULL,
 638                                        BT_OPP_CLIENT_PATH,
 639                                        BT_EVENT_SERVICE,
 640                                        BT_TRANSFER_STARTED,
 641                                        __handle_opp_client_signal, ad);
 642         retm_if(sh == NULL, "started Event register failed\n");
 643         ad->client_started_sh = sh;
 644
 645         sh = e_dbus_signal_handler_add(conn,
 646                                        NULL,
 647                                        BT_OPP_CLIENT_PATH,
 648                                        BT_EVENT_SERVICE,
 649                                        BT_TRANSFER_PROGRESS,
 650                                        __handle_opp_client_signal, ad);
 651         retm_if(sh == NULL, "progress Event register failed\n");
 652         ad->client_progress_sh = sh;
 653
 654         sh = e_dbus_signal_handler_add(conn,
 655                                        NULL,
 656                                        BT_OPP_CLIENT_PATH,
 657                                        BT_EVENT_SERVICE,
 658                                        BT_TRANSFER_COMPLETED,
 659                                        __handle_opp_client_signal, ad);
 660         retm_if(sh == NULL, "complete Event register failed\n");
 661         ad->client_completed_sh = sh;
 662
 663         sh = e_dbus_signal_handler_add(conn,
 664                                        NULL,
 665                                        BT_OPP_SERVER_PATH,
 666                                        BT_EVENT_SERVICE,
 667                                        BT_TRANSFER_STARTED,
 668                                        __handle_obex_server_signal, ad);
 669         retm_if(sh == NULL, "started Event register failed\n");
 670         ad->server_started_sh = sh;
 671
 672         sh = e_dbus_signal_handler_add(conn,
 673                                        NULL,
 674                                        BT_OPP_SERVER_PATH,
 675                                        BT_EVENT_SERVICE,
 676                                        BT_TRANSFER_PROGRESS,
 677                                        __handle_obex_server_signal, ad);
 678         retm_if(sh == NULL, "progress Event register failed\n");
 679         ad->server_progress_sh = sh;
 680
 681         sh = e_dbus_signal_handler_add(conn,
 682                                        NULL,
 683                                        BT_OPP_SERVER_PATH,
 684                                        BT_EVENT_SERVICE,
 685                                        BT_TRANSFER_COMPLETED,
 686                                        __handle_obex_server_signal, ad);
 687         retm_if(sh == NULL, "complete Event register failed\n");
 688         ad->server_completed_sh = sh;
 689
 690         sh = e_dbus_signal_handler_add(conn,
 691                                         NULL,
 692                                         BT_SHARE_ENG_OBJECT,
 693                                         BT_SHARE_ENG_INTERFACE,
 694                                         BT_SHARE_ENG_SIGNAL_UPDATE_VIEW,
 695                                         __handle_update_view_signal, ad);
 696
 697         retm_if(sh == NULL, "Progress Event register failed\n");
 698         ad->update_sh = sh;
 699
 700         sh = e_dbus_signal_handler_add(conn,
 701                                            NULL,
 702                                            BT_SHARE_ENG_OBJECT,
 703                                            BT_SHARE_ENG_INTERFACE,
 704                                            BT_OPP_CLIENT_DISCONNECTED,
 705                                            __handle_opp_disconnect_signal, ad);
 706         retm_if(sh == NULL, "Disconnected Event register failed\n");
 707         ad->client_disconnected_sh = sh;
 708
 709         sh = e_dbus_signal_handler_add(conn,
 710                                            NULL,
 711                                            BT_SHARE_ENG_OBJECT,
 712                                            BT_SHARE_ENG_INTERFACE,
 713                                            BT_OPP_SERVER_DISCONNECTED,
 714                                            __handle_opp_disconnect_signal, ad);
 715         retm_if(sh == NULL, "Disconnected Event register failed\n");
 716         ad->server_disconnected_sh = sh;
 717
 718         sh = e_dbus_signal_handler_add(conn,
 719                                         NULL,
 720                                         DBUS_CORE_APPS_PATH,
 721                                         DBUS_CORE_APPS_INTERFACE,
 722                                         DBUS_CORE_APPS_MEMBER,
 723                                         __handle_home_key_signal, ad);
 724         retm_if(sh == NULL, "Connect Event register failed");
 725         ad->app_core_sh = sh;
 726
 727         ad->dbus_conn = conn;
 728
 729         return;
 730 }
 731
 732 void _bt_signal_deinit(bt_share_appdata_t *ad)
 733 {
 734         ret_if(ad == NULL);
 735
 736         if (ad->client_connected_sh) {
 737                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_connected_sh);
 738                 ad->client_connected_sh = NULL;
 739         }
 740         if (ad->client_started_sh) {
 741                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_started_sh);
 742                 ad->client_started_sh = NULL;
 743         }
 744         if (ad->client_progress_sh) {
 745                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_progress_sh);
 746                 ad->client_progress_sh = NULL;
 747         }
 748         if (ad->client_completed_sh) {
 749                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_completed_sh);
 750                 ad->client_completed_sh = NULL;
 751         }
 752         if (ad->server_started_sh) {
 753                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_started_sh);
 754                 ad->server_started_sh = NULL;
 755         }
 756         if (ad->server_progress_sh) {
 757                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_progress_sh);
 758                 ad->server_progress_sh = NULL;
 759         }
 760         if (ad->server_completed_sh) {
 761                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_completed_sh);
 762                 ad->server_completed_sh = NULL;
 763         }
 764         if (ad->client_disconnected_sh) {
 765                 e_dbus_signal_handler_del(ad->dbus_conn, ad->client_disconnected_sh);
 766                 ad->client_disconnected_sh = NULL;
 767         }
 768         if (ad->server_disconnected_sh) {
 769                 e_dbus_signal_handler_del(ad->dbus_conn, ad->server_disconnected_sh);
 770                 ad->server_disconnected_sh = NULL;
 771         }
 772         if (ad->update_sh) {
 773                 e_dbus_signal_handler_del(ad->dbus_conn, ad->update_sh);
 774                 ad->update_sh = NULL;
 775         }
 776         if (ad->app_core_sh) {
 777                 e_dbus_signal_handler_del(ad->dbus_conn, ad->app_core_sh);
 778                 ad->app_core_sh = NULL;
 779         }
 780         return;
 781 }
 782
 783 int _bt_abort_signal_send(bt_share_appdata_t *ad,
 784                 bt_share_abort_data_t *abort_data)
 785 {
 786         DBG("+");
 787         DBusMessage *msg = NULL;
 788
 789         retvm_if(abort_data == NULL, -1,
 790                  "progressbar data is NULL\n");
 791         retvm_if(ad->dbus_conn == NULL, -1,
 792                  "Invalid argument: ad->dbus_conn is NULL\n");
 793
 794         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 795                         BT_SHARE_UI_INTERFACE,
 796                         BT_SHARE_UI_SIGNAL_OPPABORT);
 797
 798         retvm_if(msg == NULL, -1, "msg is NULL\n");
 799
 800         if (!dbus_message_append_args(msg,
 801                         DBUS_TYPE_STRING, &abort_data->transfer_type,
 802                         DBUS_TYPE_INT32, &abort_data->transfer_id,
 803                         DBUS_TYPE_INVALID)) {
 804                 ERR("Abort sending failed");
 805                 dbus_message_unref(msg);
 806                 return -1;
 807         }
 808
 809         ad->opp_transfer_abort = TRUE; /* Transfer aborted by user */
 810
 811         INFO("abort_data->transfer_type = %s", abort_data->transfer_type);
 812         INFO("abort_data->transfer_id = %d", abort_data->transfer_id);
 813
 814         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
 815         dbus_message_unref(msg);
 816         DBG("-");
 817         return 0;
 818 }
 819
 820 static void __bt_conv_addr_string_to_addr_type(char *addr,
 821                                                   const char *address)
 822 {
 823         int i;
 824         char *ptr = NULL;
 825
 826         if (!address || !addr)
 827                 return;
 828
 829         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 830                 addr[i] = strtol(address, &ptr, 16);
 831                 if (ptr != NULL) {
 832                         if (ptr[0] != ':')
 833                                 return;
 834
 835                         address = ptr + 1;
 836                 }
 837         }
 838 }
 839
 840 int _bt_share_ui_retry_failed(bt_share_appdata_t *ad)
 841 {
 842         DBG("+");
 843         DBusMessage *msg = NULL;
 844         DBusMessageIter iter;
 845         DBusMessageIter array_iter;
 846         DBusMessageIter file_iter;
 847         DBusMessageIter filepath_iter;
 848         char *bd_addr = NULL;
 849         char **file_path = NULL;
 850         int i;
 851         int count;
 852         bt_tr_data_t *info = NULL;
 853         int files_count;
 854         int valid_files_count;
 855         GSList *current = NULL;
 856         GSList *failed = NULL;
 857
 858         DBG_SECURE("Device:%s SID:%s", ad->transfer_info->device_address,
 859                         ad->transfer_info->db_sid);
 860
 861         failed = ad->tr_data_list;
 862
 863         retvm_if(failed == NULL, -1, "Invalid argument: info is NULL\n");
 864
 865         retvm_if(ad->dbus_conn == NULL, -1,
 866                         "Invalid argument: ad->dbus_conn is NULL\n");
 867
 868         files_count = g_slist_length(failed);
 869         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 870                                                 BT_SHARE_UI_INTERFACE,
 871                                                 BT_SHARE_UI_SIGNAL_SEND_FILE);
 872
 873         if (msg == NULL) {
 874                 ERR("msg is NULL");
 875                 return -1;
 876         }
 877
 878         bd_addr = g_new0(char, BT_ADDRESS_LENGTH_MAX);
 879         __bt_conv_addr_string_to_addr_type((char *)bd_addr,
 880                         ad->transfer_info->device_address);
 881
 882         file_path = g_new0(char *, files_count);
 883         current = failed;
 884         count = 0;
 885         DBG("Total files: %d", files_count);
 886
 887         while (current && (count < files_count)) {
 888                 info = current->data;
 889
 890                 if (info->tr_status != BT_TRANSFER_FAIL) {
 891                         current = g_slist_next(current);
 892                         continue;
 893                 }
 894
 895                 /* check for valid utf8 file*/
 896                 if (!g_utf8_validate(info->file_path, -1, NULL)) {
 897                         ERR_SECURE("Invalid filepath: %s", info->file_path);
 898                         notification_status_message_post(BT_STR_UNABLE_TO_SEND);
 899                         goto done;
 900                 }
 901
 902                 /* file validation check begin*/
 903                 if (access(info->file_path, F_OK) != 0) {
 904                         ERR_SECURE("access failed for %s. May be file is deleted from the Device", info->file_path);
 905                         notification_status_message_post(BT_STR_FILE_NOT_EXIST);
 906                         goto done;
 907                 }
 908                 /* file validation check end*/
 909
 910                 file_path[count] = g_strdup(info->content);
 911
 912                 current = g_slist_next(current);
 913                 count++;
 914         }
 915
 916         dbus_message_iter_init_append(msg, &iter);
 917
 918         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 919                                 DBUS_TYPE_BYTE_AS_STRING, &array_iter);
 920
 921         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 922                 dbus_message_iter_append_basic(&array_iter,
 923                                 DBUS_TYPE_BYTE, &bd_addr[i]);
 924         }
 925         dbus_message_iter_close_container(&iter, &array_iter);
 926
 927         if (info) {
 928                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 929                                                         &info->dev_name);
 930                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 931                                                         &info->type);
 932         }
 933
 934         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 935                                 DBUS_TYPE_ARRAY_AS_STRING
 936                                 DBUS_TYPE_BYTE_AS_STRING, &file_iter);
 937
 938         if (file_path) {
 939                 valid_files_count = count;
 940                 for (count = 0; count < valid_files_count; count++) {
 941                         int file_length;
 942                         dbus_message_iter_open_container(&file_iter, DBUS_TYPE_ARRAY,
 943                                         DBUS_TYPE_BYTE_AS_STRING, &filepath_iter);
 944                         file_length = strlen(file_path[count]);
 945                         for (i = 0; i < file_length; i++) {
 946                                 dbus_message_iter_append_basic(&filepath_iter, DBUS_TYPE_BYTE,
 947                                                 &file_path[count][i]);
 948                         }
 949                         dbus_message_iter_close_container(&file_iter, &filepath_iter);
 950                 }
 951         }
 952         dbus_message_iter_close_container(&iter, &file_iter);
 953
 954         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
 955
 956 done:
 957         dbus_message_unref(msg);
 958         g_free(bd_addr);
 959         if (file_path) {
 960                 for (count = 0; count < files_count; count++)
 961                         g_free(file_path[count]);
 962                 g_free(file_path);
 963         }
 964
 965         DBG("-");
 966         return 0;
 967 }
 968
 969 int _bt_share_ui_ipc_info_update(bt_share_appdata_t *ad, int uid)
 970 {
 971         DBG("+");
 972         retv_if(ad == NULL, -1);
 973
 974         DBusMessage *msg = NULL;
 975         int info_uid = 0;
 976         int info_type = 0;
 977
 978         info_uid = uid;
 979         info_type = ad->tr_type;
 980
 981         INFO("info_uid = %d", info_uid);
 982         INFO("info_type = %d", info_type);
 983
 984         retvm_if(ad->dbus_conn == NULL, -1,
 985                         "Invalid argument: ad->dbus_conn is NULL\n");
 986
 987         msg = dbus_message_new_signal(BT_SHARE_ENG_OBJECT,
 988                                       BT_SHARE_UI_INTERFACE,
 989                                       BT_SHARE_UI_SIGNAL_INFO_UPDATE);
 990
 991         retvm_if(msg == NULL, -1, "msg is NULL\n");
 992
 993         if (!dbus_message_append_args(msg,
 994                                       DBUS_TYPE_INT32, &info_uid,
 995                                       DBUS_TYPE_INT32, &info_type,
 996                                       DBUS_TYPE_INVALID)) {
 997                 ERR("Connect sending failed");
 998                 dbus_message_unref(msg);
 999                 return -1;
1000         }
1001
1002         e_dbus_message_send(ad->dbus_conn, msg, NULL, -1, NULL);
1003         dbus_message_unref(msg);
1004
1005         DBG("-");
1006         return 0;
1007 }
1008
1009 void _bt_share_ui_handle_update_view(bt_share_appdata_t *ad,
1010                                                 char *table)
1011 {
1012         GSList *list_iter = NULL;
1013         bt_tr_data_t *info = NULL;
1014         int transfer_type;
1015         Elm_Object_Item *git;
1016         DBG("+");
1017
1018         if (g_strcmp0(table, BT_INBOUND_TABLE) == 0)
1019                 transfer_type = BT_TR_INBOUND;
1020         else if (g_strcmp0(table, BT_OUTBOUND_TABLE) == 0)
1021                 transfer_type = BT_TR_OUTBOUND;
1022         else
1023                 return;
1024
1025         __bt_add_tr_data_list(ad, transfer_type);
1026
1027         /* Insert new transfer result to first genlist item  */
1028         list_iter = ad->tr_data_list;
1029         if (transfer_type == BT_TR_INBOUND && ad->tr_type == BT_TR_INBOUND) {
1030                 while (NULL != list_iter) {
1031                         info = list_iter->data;
1032                         if (info->id > ad->inbound_latest_id) {
1033                                 _bt_genlist_append_tr_data_item
1034                                                 (ad, info, transfer_type);
1035                         }
1036
1037                         list_iter = g_slist_next(list_iter);
1038                 }
1039         } else if (transfer_type == BT_TR_OUTBOUND &&
1040                 ad->tr_type == BT_TR_OUTBOUND) {
1041                 while (NULL != list_iter) {
1042                         info = list_iter->data;
1043                         if (info->id > ad->outbound_latest_id) {
1044                                 _bt_genlist_append_tr_data_item
1045                                                 (ad, info, transfer_type);
1046                         }
1047                         list_iter = g_slist_next(list_iter);
1048                 }
1049         }
1050
1051         /* Update Finished and Processing Items */
1052         if (ad->current_item) {
1053                 _bt_share_genlist_item_content_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_ICON);
1054                 _bt_share_genlist_item_text_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_TEXT);
1055                 _bt_share_genlist_item_text_update(ad->current_item, BT_SHARE_ITEM_PART_FILE_SIZE);
1056
1057                 git = elm_genlist_item_prev_get(ad->current_item);
1058                 _bt_share_genlist_item_content_update(git, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_ICON);
1059                 _bt_share_genlist_item_text_update(git, BT_SHARE_ITEM_PART_FILE_TRANSFER_STATUS_TEXT);
1060                 _bt_share_genlist_item_text_update(git, BT_SHARE_ITEM_PART_FILE_SIZE);
1061         }
1062
1063         evas_object_show(ad->tr_genlist);
1064         DBG("-");
1065 }
1066
1067 static void __bt_share_ui_handle_progress(bt_share_appdata_t *ad,
1068                                         int transfer_id, char *name, int percentage,
1069                                         gboolean completed, int error_type)
1070 {
1071
1072         if (completed == FALSE)
1073                 _bt_update_progressbar(ad, transfer_id, name, percentage);
1074 }
1075 static void __bt_share_ui_handle_error(bt_share_appdata_t *ad, int error_type,
1076                                                 bt_share_tr_type_e trans_type)
1077 {
1078         DBG("Error type : %d", error_type);
1079
1080         switch (error_type) {
1081         case BT_SHARE_UI_ERROR_NOT_CONNECTED:
1082                 _bt_create_info_popup(ad, BT_STR_UNABLE_TO_SEND);
1083                 break;
1084         case BT_SHARE_UI_ERROR_CANCEL:
1085                 DBG("opp_transfer_abort by user:%d, trans_type = %d",
1086                         ad->opp_transfer_abort, ad->tr_type);
1087                 if ((trans_type == BT_TR_INBOUND) &&
1088                         !ad->opp_transfer_abort)
1089                         _bt_create_info_popup(ad, BT_STR_UNABLE_TO_RECEIVE);
1090                 else if (!ad->opp_transfer_abort &&
1091                                         (trans_type == BT_TR_OUTBOUND))
1092                         _bt_create_info_popup(ad, BT_STR_UNABLE_TO_SEND);
1093                 ad->opp_transfer_abort = FALSE;
1094                 break;
1095         default:
1096                 break;
1097         }
1098 }
1099
1100 void _bt_share_ui_event_handler(int event, bt_share_event_param_t *param,
1101                                void *user_data){
1102
1103         FN_START;
1104         bt_share_server_transfer_info_t *transfer_info = NULL;
1105         bt_share_transfer_info_t *client_info = NULL;
1106         char *name = NULL;
1107         int percentage = 0;
1108         bt_share_appdata_t *ad = (bt_share_appdata_t *)user_data;
1109
1110         switch (event) {
1111         case BT_SHARE_UI_EVENT_OPC_CONNECTED:
1112                 INFO("BT_SHARE_UI_EVENT_OPC_CONNECTED");
1113                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1114                         __bt_share_ui_handle_error(ad, param->result,
1115                                         BT_TR_OUTBOUND);
1116                         _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1117                 }
1118
1119                 /* Set to false when new Outbound OPP session is started*/
1120                 opc_launched_session = FALSE;
1121                 break;
1122
1123         case BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED:
1124                 if (opc_launched_session == FALSE) {
1125                         /* Do not process events for new OPP Session */
1126                         INFO("TRANSFER_STARTED: Different Obex Session");
1127                         return;
1128                 }
1129
1130                 INFO("BT_SHARE_UI_EVENT_OPC_TRANSFER_STARTED");
1131                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1132                         client_info = (bt_share_transfer_info_t *)param->param_data;
1133                         if (client_info) {
1134                                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1135                                 _bt_share_ui_handle_transfer_started(ad,
1136                                         client_info->device_addr, client_info->filename,
1137                                         client_info->size, 0, BT_TR_OUTBOUND);
1138                         }
1139                 }
1140                 break;
1141
1142         case BT_SHARE_UI_EVENT_OPC_TRANSFER_PROGRESS:
1143                 if (opc_launched_session == FALSE) {
1144                         /* Do not process events for new OPP Session */
1145                         return;
1146                 }
1147
1148                 client_info = (bt_share_transfer_info_t *)param->param_data;
1149
1150                 name =  strrchr(client_info->filename, '/');
1151                 if (name)
1152                         name++;
1153                 else
1154                         name = client_info->filename;
1155
1156                 percentage = client_info->percentage;
1157                 __bt_share_ui_handle_progress(ad, 0, name, percentage,
1158                                         FALSE, BT_SHARE_UI_ERROR_NONE);
1159                 break;
1160
1161         case BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE:
1162                 if (opc_launched_session == FALSE) {
1163                         /* Do not process events for new OPP Session */
1164                         INFO("TRANSFER_COMPLETE: Different Obex Session");
1165                         return;
1166                 }
1167
1168                 INFO("BT_SHARE_UI_EVENT_OPC_TRANSFER_COMPLETE ");
1169                 client_info = (bt_share_transfer_info_t *)param->param_data;
1170
1171                 if (g_strcmp0(ad->transfer_info->device_address, client_info->device_addr))
1172                         return;
1173
1174                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1175                         __bt_share_ui_handle_error(ad, param->result,
1176                                         BT_TR_OUTBOUND);
1177                         if (ad->tr_view)
1178                                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1179                         else if (ad->info_popup == NULL)
1180                                 _bt_terminate_app();
1181
1182                         _bt_share_ui_handle_transfer_complete(ad, client_info->device_addr,
1183                                         BT_TR_OUTBOUND);
1184
1185                         return;
1186                 }
1187
1188                 INFO_SECURE("client_info->filename = [%s]",
1189                                 client_info->filename);
1190
1191                 name =  strrchr(client_info->filename, '/');
1192                 if (name)
1193                         name++;
1194                 else
1195                         name = client_info->filename;
1196
1197                 INFO("name address = [%x]", name);
1198                 __bt_share_ui_handle_progress(ad, 0, name, 100, TRUE,
1199                                 param->result);
1200
1201                 if (ad->tr_view == NULL)
1202                         _bt_terminate_app();
1203                 else
1204                         _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1205
1206                 _bt_share_ui_handle_transfer_complete(ad, client_info->device_addr,
1207                                 BT_TR_OUTBOUND);
1208
1209                 break;
1210         case BT_SHARE_UI_EVENT_OPC_DISCONNECTED: {
1211                 GSList *failed = NULL;
1212                 sqlite3 *db = NULL;
1213
1214                 INFO("BT_SHARE_UI_EVENT_OPC_DISCONNECTED");
1215
1216                 db = bt_share_open_db();
1217                 retm_if(!db, "fail to open db!");
1218
1219                 failed = bt_share_get_failed_tr_data_by_sid(db,
1220                                 ad->tr_type, ad->transfer_info->device_address,
1221                                 ad->transfer_info->db_sid);
1222                 bt_share_close_db(db);
1223
1224                 if (failed) {
1225                         /* Some failed items are there */
1226                         elm_object_text_set(ad->toolbar_button,
1227                                                 BT_STR_RESEND_FAILED_FILES);
1228                         elm_object_disabled_set(ad->toolbar_button, FALSE);
1229                         /*free list*/
1230                         bt_share_release_tr_data_list(failed);
1231                 } else
1232                         _bt_share_delete_toolbar_button(ad);
1233                 ad->launch_mode = BT_LAUNCH_TRANSFER_LIST;
1234
1235                 _bt_share_ui_handle_transfer_disconnected(ad, BT_TR_OUTBOUND);
1236                 _bt_share_ui_handle_update_view(ad, BT_OUTBOUND_TABLE);
1237
1238                 elm_genlist_realized_items_update(ad->tr_genlist);
1239
1240                 break;
1241         }
1242         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1243                 INFO("BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1244                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1245                         transfer_info = param->param_data;
1246
1247                         if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1248                                 /* Different session */
1249                                 INFO("TRANSFER_STARTED: Different Session");
1250                                 return;
1251                         }
1252
1253                         _bt_share_ui_handle_transfer_started(ad, transfer_info->address,
1254                                         transfer_info->filename, transfer_info->file_size, transfer_info->transfer_id,
1255                                         BT_TR_INBOUND);
1256                 }
1257                 break;
1258         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1259                 if (param->result == BT_SHARE_UI_ERROR_NONE) {
1260                         transfer_info = param->param_data;
1261
1262                         if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1263                                 /* Different session */
1264                                 return;
1265                         }
1266                         __bt_share_ui_handle_progress(ad,
1267                                         transfer_info->transfer_id,
1268                                         transfer_info->filename,
1269                                         transfer_info->percentage,
1270                                         FALSE, BT_SHARE_UI_ERROR_NONE);
1271                 }
1272                 break;
1273
1274         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1275                 INFO("BT_SHARE_UI_EVENT_OBEX_TRANSFER_COMPLETED ");
1276
1277                 transfer_info = param->param_data;
1278                 if (g_strcmp0(ad->transfer_info->device_address, transfer_info->address))
1279                         return;
1280
1281                 if (transfer_info->transfer_id != ad->transfer_info->transfer_id) {
1282                         /* Different session */
1283                         INFO("TRANSFER_STARTED: Different Session");
1284                         return;
1285                 }
1286
1287                 if (param->result != BT_SHARE_UI_ERROR_NONE) {
1288                         __bt_share_ui_handle_error(ad, param->result,
1289                                         BT_TR_INBOUND);
1290                         if (ad->tr_view)
1291                                 _bt_share_ui_handle_update_view(ad,
1292                                                 BT_INBOUND_TABLE);
1293
1294                         _bt_share_ui_handle_transfer_complete(ad, transfer_info->address,
1295                                         BT_TR_INBOUND);
1296                         return;
1297                 }
1298
1299                 if (ad->tr_view == NULL)
1300                         _bt_terminate_app();
1301                 else
1302                         _bt_share_ui_handle_update_view(ad, BT_INBOUND_TABLE);
1303
1304                 _bt_share_ui_handle_transfer_complete(ad, transfer_info->address,
1305                                 BT_TR_INBOUND);
1306                 break;
1307
1308         case BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED: {
1309                 DBG("BT_SHARE_UI_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED");
1310                 transfer_info = param->param_data;
1311                 INFO("transfer_info->transfer_id: [%d]", transfer_info->transfer_id);
1312                 INFO("ad->transfer_info->transfer_id: [%d]", ad->transfer_info->transfer_id);
1313                 if (transfer_info->transfer_id == ad->transfer_info->transfer_id) {
1314                         DBG("Same session");
1315                         _bt_share_delete_toolbar_button(ad);
1316                         _bt_share_ui_handle_transfer_disconnected(ad, BT_TR_INBOUND);
1317
1318                         _bt_share_ui_handle_update_view(ad, BT_INBOUND_TABLE);
1319                         elm_genlist_realized_items_update(ad->tr_genlist);
1320                 }
1321         }
1322         break;
1323
1324         default:
1325                 DBG("Unhandled event %x", event);
1326                 break;
1327         }
1328         FN_END;
1329
1330 }