ug-wifidirect/src/wfd_ug_main_view.c

   1 /*
   2 *  WiFi-Direct UG
   3 *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9
  10 * http://www.tizenopensource.org/license
  11
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17 *
  18 */
  19
  20
  21 #include <libintl.h>
  22 #include <glib.h>
  23
  24 #include <Elementary.h>
  25 #include <vconf.h>
  26 #include <ui-gadget-module.h>
  27 #include <app_control.h>
  28 #include <wifi-direct.h>
  29 #include <efl_extension.h>
  30
  31 #include "wfd_ug.h"
  32 #include "wfd_ug_view.h"
  33 #include "wfd_client.h"
  34
  35 void scan_button_create(struct ug_data *ugd)
  36 {
  37         __FUNC_ENTER__;
  38
  39         Evas_Object *btn;
  40         btn = elm_button_add(ugd->layout);
  41         /* Use "bottom" style button */
  42         elm_object_style_set(btn, "bottom");
  43         elm_object_domain_translatable_text_set(btn, PACKAGE, "IDS_WIFI_SK4_SCAN");
  44         ugd->scan_toolbar = btn;
  45         if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) {
  46                 wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN",
  47                         FALSE);
  48         }
  49         evas_object_smart_callback_add(btn, "clicked",_scan_btn_cb, (void *)ugd);
  50         /* Set button into "toolbar" swallow part */
  51         elm_object_part_content_set(ugd->layout, "button.big", btn);
  52         evas_object_show(ugd->scan_toolbar);
  53
  54         __FUNC_EXIT__;
  55 }
  56
  57 /**
  58  *      This function let the ug call it when click 'back' button
  59  *      @return   void
  60  *      @param[in] data the pointer to the main data structure
  61  *      @param[in] obj the pointer to the evas object
  62  *      @param[in] event_info the pointer to the event information
  63  */
  64 Eina_Bool _back_btn_cb(void *data, Elm_Object_Item *it)
  65 {
  66         __FUNC_ENTER__;
  67         struct ug_data *ugd = (struct ug_data *) data;
  68         WFD_RETV_IF(ugd == NULL, FALSE, "The param is NULL\n");
  69         int ret = -1;
  70         bool owner = FALSE;
  71         app_control_h control = NULL;
  72
  73 #ifdef WFD_DBUS_LAUNCH
  74         if (ugd->dbus_cancellable != NULL) {
  75                 g_cancellable_cancel(ugd->dbus_cancellable);
  76                 g_object_unref(ugd->dbus_cancellable);
  77                 ugd->dbus_cancellable = NULL;
  78                 if (ugd->conn) {
  79                         g_object_unref(ugd->conn);
  80                         ugd->conn = NULL;
  81                 }
  82                 DBG(LOG_INFO, "Cancel dbus call");
  83         }
  84 #endif
  85
  86         wfd_refresh_wifi_direct_state(ugd);
  87         if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) {
  88                 DBG(LOG_INFO, "WiFi direct is already deactivated\n");
  89                 goto cleanup;
  90         }
  91
  92         if (NULL != ugd->mac_addr_connecting) {
  93                 if (ugd->is_conn_incoming) {
  94                         DBG(LOG_INFO, "Reject the incoming connection before client deregister \n");
  95                         ret = wifi_direct_reject_connection(ugd->mac_addr_connecting);
  96                         if (ret != WIFI_DIRECT_ERROR_NONE) {
  97                                 DBG(LOG_ERROR, "Failed to send reject request [%d]\n", ret);
  98                         }
  99                 } else {
 100                         DBG(LOG_INFO, "Cancel the outgoing connection before client deregister \n");
 101                         ret = wifi_direct_cancel_connection(ugd->mac_addr_connecting);
 102                         if (ret != WIFI_DIRECT_ERROR_NONE) {
 103                                 DBG(LOG_ERROR, "Failed to send cancel request [%d]\n", ret);
 104                         }
 105                 }
 106                 ugd->mac_addr_connecting = NULL;
 107         }
 108
 109         if (ugd->raw_connected_peer_cnt == 0) {
 110                 ret = wifi_direct_is_group_owner(&owner);
 111                 if (ret == WIFI_DIRECT_ERROR_NONE) {
 112                         if (owner) {
 113                                 wifi_direct_destroy_group();
 114                         }
 115                 }
 116         }
 117
 118 cleanup:
 119         wfd_ug_view_free_peers(ugd);
 120         ret = app_control_create(&control);
 121         if (ret) {
 122                 DBG(LOG_ERROR, "Failed to create control");
 123         } else {
 124                 if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING) {
 125                         app_control_add_extra_data(control, "Connection", "TRUE");
 126                 } else {
 127                         app_control_add_extra_data(control, "Connection", "FALSE");
 128                 }
 129
 130                 ug_send_result(ugd->ug, control);
 131                 app_control_destroy(control);
 132         }
 133
 134         ug_destroy_me(ugd->ug);
 135         __FUNC_EXIT__;
 136         return FALSE;
 137 }
 138
 139 void wfd_cancel_progressbar_stop_timer(struct ug_data *ugd)
 140 {
 141         __FUNC_ENTER__;
 142
 143         if(ugd->timer_stop_progress_bar > 0) {
 144                 g_source_remove(ugd->timer_stop_progress_bar);
 145         }
 146         ugd->timer_stop_progress_bar = 0;
 147
 148         __FUNC_EXIT__;
 149 }
 150
 151 void wfd_cancel_not_alive_delete_timer(struct ug_data *ugd)
 152 {
 153         __FUNC_ENTER__;
 154
 155         if(ugd->timer_delete_not_alive_peer > 0) {
 156                 g_source_remove(ugd->timer_delete_not_alive_peer);
 157         }
 158         ugd->timer_delete_not_alive_peer = 0;
 159
 160         __FUNC_EXIT__;
 161 }
 162
 163 /**
 164  *      This function let the ug call it when click failed devices item
 165  *      @return   void
 166  *      @param[in] data the pointer to the main data structure
 167  *      @param[in] obj the pointer to the evas object
 168  *      @param[in] event_info the pointer to the event information
 169  */
 170 void _gl_failed_peer_cb(void *data, Evas_Object *obj, void *event_info)
 171 {
 172         __FUNC_ENTER__;
 173
 174         struct ug_data *ugd = wfd_get_ug_data();
 175         int ret = -1;
 176
 177         if (NULL == ugd) {
 178                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 179                 return;
 180         }
 181
 182         if (ugd->display_timer != NULL) {
 183                 ecore_timer_del(ugd->display_timer);
 184                 ugd->display_timer = NULL;
 185         }
 186
 187         wfd_refresh_wifi_direct_state(ugd);
 188         DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status);
 189
 190         /* if connected, show the popup*/
 191         if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) {
 192                 wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN);
 193         } else {
 194                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 195                 ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 196                 if (ret != WIFI_DIRECT_ERROR_NONE) {
 197                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 198                         DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 199                         wifi_direct_cancel_discovery();
 200                 }
 201         }
 202
 203         __FUNC_EXIT__;
 204         return;
 205 }
 206
 207 /**
 208  *      This function let the ug call it when click 'scan' button
 209  *      @return   void
 210  *      @param[in] data the pointer to the main data structure
 211  *      @param[in] obj the pointer to the evas object
 212  *      @param[in] event_info the pointer to the event information
 213  */
 214 void _scan_btn_cb(void *data, Evas_Object *obj, void *event_info)
 215 {
 216         __FUNC_ENTER__;
 217
 218         struct ug_data *ugd = (struct ug_data *) data;
 219         if (NULL == ugd) {
 220                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 221                 return;
 222         }
 223         int ret = -1;
 224         const char *btn_text = NULL;
 225         btn_text = elm_object_part_text_get(ugd->scan_toolbar, "default");
 226         DBG(LOG_INFO, "Button text=%s",btn_text);
 227
 228         if (!g_strcmp0(elm_object_text_get(obj), _("IDS_WIFI_SK4_SCAN"))) {
 229                 wfd_refresh_wifi_direct_state(ugd);
 230                 DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status);
 231                 /* if connected, show the popup*/
 232                 if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED || ugd->raw_connected_peer_cnt > 0) {
 233                         wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN);
 234                 } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) {
 235                         wfd_client_switch_on(ugd);
 236                         __FUNC_EXIT__;
 237                         return;
 238                 } else {
 239                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 240                         ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 241                         if (ret != WIFI_DIRECT_ERROR_NONE) {
 242                                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 243                                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 244                                 wifi_direct_cancel_discovery();
 245                         }
 246                 }
 247         } else if (!g_strcmp0(elm_object_text_get(obj), _("IDS_WIFI_SK_STOP"))) {
 248                 DBG(LOG_INFO, "Stop pressed.\n");
 249                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 250                 wfd_cancel_progressbar_stop_timer(ugd);
 251                 wfd_delete_progressbar_cb(ugd);
 252                 wfd_cancel_not_alive_delete_timer(ugd);
 253         } else if (0 == strcmp(_("IDS_WIFI_SK2_CANCEL_CONNECTION"), btn_text)) {
 254                 DBG(LOG_INFO, "Cancel Connection");
 255                 wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_THIS_WI_FI_DIRECT_CONNECTION_WILL_BE_CANCELLED"), POP_TYPE_CANCEL_CONNECT);
 256         } else {
 257                 DBG(LOG_INFO, "Invalid Case\n");
 258         }
 259         __FUNC_EXIT__;
 260         return;
 261 }
 262
 263 void wfd_check_gl_busy_peers(struct ug_data *ugd)
 264 {
 265         __FUNC_ENTER__;
 266         if (ugd->gl_busy_peer_cnt == 0) {
 267                 WFD_IF_DEL_ITEM(ugd->busy_wfd_item);
 268         }
 269         __FUNC_EXIT__;
 270 }
 271
 272 void wfd_check_gl_available_peers(struct ug_data *ugd)
 273 {
 274         __FUNC_ENTER__;
 275         if (ugd->gl_available_peer_cnt == 0 && ugd->avlbl_wfd_item != NULL) {
 276                 WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item);
 277         }
 278         __FUNC_EXIT__;
 279 }
 280
 281 /**
 282  *      This function let the ug free some peer in genlist
 283  *      @return  void
 284  *      @param[in] start_pos the start position of peers list
 285  *      @param[in] mac_addr the mac_addr of peer for free
 286  *      @param[in] cnt the count of gl peers in list
 287  */
 288 void free_gl_peer(device_type_s **start_pos, const char *mac_addr, int *cnt)
 289 {
 290         __FUNC_ENTER__;
 291         device_type_s *peer = *start_pos;
 292         device_type_s *peer_tmp = peer;
 293
 294         if (peer == NULL) {
 295                 DBG(LOG_INFO, "no peer in genlist");
 296                 return;
 297         }
 298
 299         while (peer) {
 300                 if(strcmp(peer->mac_addr, mac_addr)) {
 301                         peer_tmp = peer;
 302                         peer = peer->next;
 303                 } else {
 304                         if(peer->next != NULL) {
 305                                 peer_tmp->next = peer->next;
 306                                 break;
 307                         } else {
 308                                 peer_tmp->next = NULL;
 309                                 break;
 310                         }
 311                 }
 312         }
 313
 314         if (peer == *start_pos) {
 315                 DBG(LOG_INFO, "the head is free");
 316                 *start_pos = peer->next;
 317         }
 318
 319         (*cnt)--;
 320         if (peer) {
 321                 WFD_IF_DEL_ITEM(peer->gl_item);
 322                 peer->next = NULL;
 323                 free(peer);
 324         }
 325         __FUNC_EXIT__;
 326 }
 327
 328 /**
 329  *      This function let the ug call it when click avaliable peer to connect
 330  *      @return   void
 331  *      @param[in] data the pointer to the main data structure
 332  *      @param[in] obj the pointer to the evas object
 333  *      @param[in] event_info the pointer to the event information
 334  */
 335 static void _gl_peer_sel(void *data, Evas_Object *obj, void *event_info)
 336 {
 337         __FUNC_ENTER__;
 338
 339         int res = -1;
 340         char txt[MAX_POPUP_TEXT_SIZE] = {0,};
 341         char popup_text[MAX_POPUP_TEXT_SIZE] = {0, };
 342         bool is_peer_alive = false;
 343         struct ug_data *ugd = wfd_get_ug_data();
 344         device_type_s *peer = (device_type_s *)data;
 345         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 346
 347         if (!ugd || !peer) {
 348                 DBG(LOG_ERROR, "NULL parameters.\n");
 349                 return;
 350         }
 351
 352         wfd_ug_get_connected_peers(ugd);
 353         DBG(LOG_INFO, "No of connected peers= %d",ugd->raw_connected_peer_cnt);
 354
 355         if (ugd->raw_connected_peer_cnt >= MAX_CONNECTED_PEER_NUM) {
 356                 snprintf(popup_text, MAX_POPUP_TEXT_SIZE, _("IDS_ST_POP_YOU_CAN_CONNECT_UP_TO_PD_DEVICES_AT_THE_SAME_TIME"), MAX_CONNECTED_PEER_NUM);
 357                 wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP);
 358                 if (item) {
 359                         elm_genlist_item_selected_set(item, EINA_FALSE);
 360                 }
 361                 return;
 362         }
 363
 364         if (ugd->disconnect_btn) {
 365                 Evas_Object *content;
 366                 content = elm_object_part_content_unset(ugd->layout, "button.next");
 367                 WFD_IF_DEL_OBJ(content);
 368                 ugd->disconnect_btn = NULL;
 369                 elm_object_part_content_set(ugd->layout, "button.big",
 370                         ugd->scan_toolbar);
 371         }
 372
 373         if (item) {
 374                 elm_genlist_item_selected_set(item, EINA_FALSE);
 375         }
 376
 377         GList *iterator = NULL;
 378
 379         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 380                 if (!strncmp(peer->mac_addr, (const char *)((device_type_s *)iterator->data)->mac_addr, MAC_LENGTH)) {
 381                         /* peer is found in last discovery */
 382                         is_peer_alive = true;
 383                         break;
 384                 }
 385         }
 386
 387         if (!is_peer_alive) {
 388                 /* peer exists only in genlist, waiting to be deleted */
 389                 device_type_s *peer_start = ugd->gl_avlb_peers_start;
 390                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 391                         if(!strncmp(peer_start->mac_addr, peer->mac_addr, MAC_LENGTH)) {
 392                                 DBG(LOG_INFO, "Device [%s] found in genlist, but it is already lost", ((device_type_s *)iterator->data)->ssid);
 393                                 sprintf(txt, "Cannot find device %s", ((device_type_s *)iterator->data)->ssid);
 394                                 free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr, &ugd->gl_available_peer_cnt);
 395                                 wfd_check_gl_available_peers(ugd);
 396                                 wfd_ug_warn_popup(ugd, txt, POPUP_TYPE_INFO);
 397                                 return;
 398                         }
 399                 }
 400         }
 401
 402         wfd_cancel_not_alive_delete_timer(ugd);
 403
 404         /* get WFD status */
 405         wfd_refresh_wifi_direct_state(ugd);
 406
 407         if (PEER_CONN_STATUS_DISCONNECTED == peer->conn_status ||
 408                 peer->is_group_owner == TRUE) {
 409                 DBG_SECURE(LOG_DEBUG, "Connect with peer ["MACSECSTR"]\n",
 410                         MAC2SECSTR(peer->mac_addr));
 411
 412                 if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status) {
 413                         DBG(LOG_DEBUG, "It's in connecting status now.\n");
 414                         return;
 415                 }
 416
 417                 ugd->mac_addr_connecting = peer->mac_addr;
 418                 res = wfd_client_connect((const char *)peer->mac_addr);
 419                 if (res != 0) {
 420                         DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res);
 421                         return;
 422                 }
 423         }
 424
 425         __FUNC_EXIT__;
 426         return;
 427 }
 428
 429 /**
 430  *      This function let the ug call it when click busy peer
 431  *      @return   void
 432  *      @param[in] data the pointer to the main data structure
 433  *      @param[in] obj the pointer to the evas object
 434  *      @param[in] event_info the pointer to the event information
 435  */
 436 static void _gl_busy_peer_sel(void *data, Evas_Object *obj, void *event_info)
 437 {
 438         __FUNC_ENTER__;
 439         struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data();
 440         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 441
 442         if (item) {
 443                 elm_genlist_item_selected_set(item, EINA_FALSE);
 444         }
 445
 446         if (NULL == ugd) {
 447                 DBG(LOG_ERROR, "Data is NULL\n");
 448                 return;
 449         }
 450
 451         wfd_ug_warn_popup(ugd, _("IDS_ST_POP_DEVICE_CONNECTED_TO_ANOTHER_DEVICE"), POP_TYPE_BUSY_DEVICE_POPUP);
 452
 453         __FUNC_EXIT__;
 454 }
 455
 456 void ctxpopup_dismissed_cb(void *data, Evas_Object *obj, void *event_info)
 457 {
 458         struct ug_data *ugd = (struct ug_data *) data;
 459
 460         if (!ugd) {
 461                 DBG(LOG_ERROR, "The param is NULL\n");
 462                 return;
 463         }
 464
 465         if (ugd->ctxpopup) {
 466                 evas_object_del(ugd->ctxpopup);
 467                 ugd->ctxpopup = NULL;
 468         }
 469 }
 470
 471 void _ctxpopup_move()
 472 {
 473         __FUNC_ENTER__;
 474
 475         int win_w = 0, win_h = 0;
 476         int move_x = 0, move_y = 0;
 477         int changed_ang = 0;
 478         struct ug_data *ugd = wfd_get_ug_data();
 479
 480         if (!ugd || !ugd->win) {
 481                 DBG(LOG_ERROR, "NULL parameters.\n");
 482                 return;
 483         }
 484
 485         if (!ugd->ctxpopup) {
 486                 DBG(LOG_INFO, "NULL parameters.\n");
 487                 return;
 488         }
 489
 490         elm_win_screen_size_get(ugd->win, NULL, NULL, &win_w, &win_h);
 491         changed_ang = elm_win_rotation_get(ugd->win);
 492
 493         switch (changed_ang) {
 494                 case 0:
 495                 case 180:
 496                         move_x = win_w/2;
 497                         move_y = win_h;
 498                         break;
 499
 500                 case 90:
 501                         move_x = win_h/2;
 502                         move_y = win_w;
 503                         break;
 504
 505                 case 270:
 506                         move_x = win_h/2;
 507                         move_y = win_w;
 508                         break;
 509
 510                 default:
 511                         move_x = 0;
 512                         move_y = 0;
 513                         break;
 514         }
 515
 516         evas_object_move(ugd->ctxpopup, move_x, move_y);
 517
 518         __FUNC_EXIT__;
 519 }
 520
 521 void _create_mluti_connect_view(void *data, Evas_Object *obj, void *event_info)
 522 {
 523         __FUNC_ENTER__;
 524         struct ug_data *ugd = (struct ug_data *) data;
 525         WFD_RET_IF(ugd == NULL, "The param is NULL\n");
 526         WFD_IF_DEL_OBJ(ugd->ctxpopup);
 527         int ret = 0;
 528
 529         wfd_client_free_raw_discovered_peers(ugd);
 530         ugd->raw_discovered_peer_cnt = 0;
 531         wfd_create_multiconnect_view(ugd);
 532         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 533         ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 534         if (ret != WIFI_DIRECT_ERROR_NONE) {
 535                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 536                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 537                 wifi_direct_cancel_discovery();
 538         }
 539
 540         __FUNC_EXIT__;
 541 }
 542
 543 void _more_button_cb(void *data, Evas_Object *obj, void *event_info)
 544 {
 545         __FUNC_ENTER__;
 546
 547         Evas_Object *naviframe = (Evas_Object *)data;
 548         Elm_Object_Item *multi_connect_item = NULL;
 549         Elm_Object_Item *rename_item = NULL;
 550         struct ug_data *ugd = wfd_get_ug_data();
 551
 552         if (!naviframe || !ugd) {
 553                 DBG(LOG_ERROR, "NULL parameters.\n");
 554                 return;
 555         }
 556
 557         ugd->more_btn_multiconnect_item = NULL;
 558
 559         if (ugd->ctxpopup) {
 560                 evas_object_del(ugd->ctxpopup);
 561         }
 562
 563         ugd->ctxpopup = elm_ctxpopup_add(naviframe);
 564         elm_object_style_set(ugd->ctxpopup, "more/default");
 565         eext_object_event_callback_add(ugd->ctxpopup, EA_CALLBACK_BACK, eext_ctxpopup_back_cb, NULL);
 566         eext_object_event_callback_add(ugd->ctxpopup, EA_CALLBACK_MORE, eext_ctxpopup_back_cb, NULL);
 567         evas_object_smart_callback_add(ugd->ctxpopup, "dismissed", ctxpopup_dismissed_cb, ugd);
 568         elm_ctxpopup_auto_hide_disabled_set(ugd->ctxpopup, EINA_TRUE);
 569
 570         elm_ctxpopup_direction_priority_set(ugd->ctxpopup, ELM_CTXPOPUP_DIRECTION_UP,
 571                                         ELM_CTXPOPUP_DIRECTION_LEFT,
 572                                         ELM_CTXPOPUP_DIRECTION_RIGHT,
 573                                         ELM_CTXPOPUP_DIRECTION_DOWN);
 574
 575         _ctxpopup_move();
 576
 577         multi_connect_item = elm_ctxpopup_item_append(ugd->ctxpopup, "IDS_WIFI_BUTTON_MULTI_CONNECT", NULL, _create_mluti_connect_view, ugd);
 578         elm_object_item_domain_text_translatable_set(multi_connect_item, PACKAGE, EINA_TRUE);
 579         ugd->more_btn_multiconnect_item = multi_connect_item;
 580
 581         wfd_refresh_wifi_direct_state(ugd);
 582         if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status ||
 583                 WIFI_DIRECT_STATE_CONNECTED == ugd->wfd_status ||
 584                 WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status ||
 585                 ugd->raw_connected_peer_cnt > 0) {
 586                 elm_object_item_disabled_set(multi_connect_item, TRUE);
 587         }
 588
 589         rename_item = elm_ctxpopup_item_append(ugd->ctxpopup, "IDS_ST_BODY_RENAME_DEVICE_ABB", NULL, _gl_rename_device_sel, ugd);
 590         elm_object_item_domain_text_translatable_set(rename_item, PACKAGE, EINA_TRUE);
 591         evas_object_show(ugd->ctxpopup);
 592
 593         __FUNC_EXIT__;
 594 }
 595
 596 /**
 597  *      This function make items into group
 598 */
 599 void _wfd_realize_item(Elm_Object_Item *pre_item, int count)
 600 {
 601         __FUNC_ENTER__;
 602         int i = 0;
 603         if (count < 1 || pre_item == NULL) {
 604                 return;
 605         }
 606
 607         Elm_Object_Item *item = elm_genlist_item_next_get(pre_item);
 608         if (item == NULL) {
 609                 return;
 610         }
 611
 612         if (count == 1) {
 613                 elm_object_item_signal_emit(item, "elm,state,normal", "");
 614                 return;
 615         }
 616
 617         for (i = 0; i < count; i++) {
 618                 if (i == 0) {
 619                         elm_object_item_signal_emit(item, "elm,state,top", "");
 620                 } else if (i == count - 1) {
 621                         elm_object_item_signal_emit(item, "elm,state,bottom", "");
 622                 } else {
 623                         elm_object_item_signal_emit(item, "elm,state,center", "");
 624                 }
 625
 626                 item = elm_genlist_item_next_get(item);
 627         }
 628         __FUNC_EXIT__;
 629 }
 630
 631 /**
 632  *      This function let the ug call it when unresized event is received
 633 */
 634 static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info)
 635 {
 636         __FUNC_ENTER__;
 637         struct ug_data *ugd = (struct ug_data *)data;
 638
 639         _wfd_realize_item(ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt);
 640         _wfd_realize_item(ugd->conn_wfd_item, ugd->gl_connected_peer_cnt);
 641         _wfd_realize_item(ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt);
 642         _wfd_realize_item(ugd->busy_wfd_item, ugd->gl_busy_peer_cnt);
 643         _wfd_realize_item(ugd->conn_failed_wfd_item, ugd->gl_connected_failed_peer_cnt);
 644         __FUNC_EXIT__;
 645 }
 646
 647 /**
 648  *      This function let the ug call it when resized event is received
 649  *      @return   void
 650  *      @param[in] data the pointer to the main data structure
 651  *      @param[in] obj the pointer to the evas object
 652  *      @param[in] event_info the pointer to the event information
 653  */
 654 static void _gl_realized(void *data, Evas_Object *obj, void *event_info)
 655 {
 656         __FUNC_ENTER__;
 657
 658         if (!data || !event_info) {
 659                 DBG(LOG_ERROR, "Invalid parameters");
 660                 return;
 661         }
 662
 663         struct ug_data *ugd = (struct ug_data *)data;
 664 #ifdef ACCESSIBILITY_FEATURE
 665         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 666         int index = elm_genlist_item_index_get(item);
 667         char *sr_msg = NULL;
 668 #endif
 669
 670         _wfd_realize_item(ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt);
 671         _wfd_realize_item(ugd->conn_wfd_item, ugd->gl_connected_peer_cnt);
 672         _wfd_realize_item(ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt);
 673         _wfd_realize_item(ugd->busy_wfd_item, ugd->gl_busy_peer_cnt);
 674         _wfd_realize_item(ugd->conn_failed_wfd_item, ugd->gl_connected_failed_peer_cnt);
 675
 676 #ifdef ACCESSIBILITY_FEATURE
 677         /* screen reader */
 678         if (GENLIST_HEADER_POS == index && item != NULL) {
 679                 Evas_Object *check = elm_object_item_part_content_get(item, "elm.icon");
 680                 if (check) {
 681                         Eina_Bool state = elm_check_state_get(check);
 682                         if (state) {
 683                                 sr_msg = strdup(SR_CHECKBOX_ON_MSG);
 684                         } else {
 685                                 sr_msg = strdup(SR_CHECKBOX_OFF_MSG);
 686                         }
 687
 688                         if (sr_msg) {
 689                                 Evas_Object *ao = NULL;
 690                                 ao = elm_object_item_access_object_get(item);
 691                                 elm_access_info_set(ao, ELM_ACCESS_CONTEXT_INFO, sr_msg);
 692                                 free(sr_msg);
 693                         } else {
 694                                 DBG(LOG_ERROR, "index = %d, screen reader message create fail!", index);
 695                         }
 696                 } else {
 697                         DBG(LOG_ERROR, "index = %d, get check box fail!", index);
 698                 }
 699         }
 700 #endif
 701
 702         __FUNC_EXIT__;
 703 }
 704
 705 /**
 706  *      This function let the ug call it when click 'disconnect' button
 707  *      @return   void
 708  *      @param[in] data the pointer to the main data structure
 709  *      @param[in] obj the pointer to the evas object
 710  *      @param[in] event_info the pointer to the event information
 711  */
 712 void _wfd_ug_disconnect_button_cb(void *data, Evas_Object * obj, void *event_info)
 713 {
 714         __FUNC_ENTER__;
 715         struct ug_data *ugd = (struct ug_data *)data;
 716         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
 717
 718         wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_CONTINUE_Q"), POP_TYPE_DISCONNECT);
 719
 720         __FUNC_EXIT__;
 721 }
 722
 723 /**
 724  *      This function let the ug call it when click "cancel connection" button
 725  *      @return   void
 726  *      @param[in] data the pointer to the main data structure
 727  *      @param[in] obj the pointer to the evas object
 728  *      @param[in] event_info the pointer to the event information
 729  */
 730 void _wfd_ug_cancel_connection_button_cb(void *data, Evas_Object * obj, void *event_info)
 731 {
 732         __FUNC_ENTER__;
 733         struct ug_data *ugd = (struct ug_data *)data;
 734         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
 735
 736         wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_THIS_WI_FI_DIRECT_CONNECTION_WILL_BE_CANCELLED"), POP_TYPE_CANCEL_CONNECT);
 737
 738         __FUNC_EXIT__;
 739 }
 740
 741
 742 /**
 743  *      This function let the ug update the genlist item
 744  *      @return   void
 745  *      @param[in] gl_item the pointer to genlist item
 746  */
 747 void wfd_ug_view_refresh_glitem(Elm_Object_Item *gl_item)
 748 {
 749         __FUNC_ENTER__;
 750         if (gl_item != NULL) {
 751                 elm_genlist_item_update(gl_item);
 752         }
 753         __FUNC_EXIT__;
 754 }
 755
 756 /**
 757  *      This function let the ug refresh the attributes of button
 758  *      @return   void
 759  *      @param[in] tb_item the pointer to the toolbar button
 760  *      @param[in] text the pointer to the text of button
 761  *      @param[in] enable whether the button is disabled
 762  */
 763 void wfd_ug_view_refresh_button(Evas_Object *tb_item, const char *text,
 764                 int enable)
 765 {
 766         __FUNC_ENTER__;
 767
 768         if (NULL == tb_item || NULL == text) {
 769                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 770                 return;
 771         }
 772
 773         DBG(LOG_INFO, "Set the attributes of button: text[%s], enabled[%d]\n", text, enable);
 774         elm_object_domain_translatable_part_text_set(tb_item, "default",
 775                          PACKAGE, text);
 776         elm_object_disabled_set(tb_item, !enable);
 777
 778         __FUNC_EXIT__;
 779 }
 780
 781 /**
 782  *      This function let the ug know whether current device is connected by me
 783  *      @return   If connected, return TRUE, else return FALSE
 784  *      @param[in] ugd the pointer to the main data structure
 785  *      @param[in] dev the pointer to the device
 786  */
 787 static bool __wfd_is_device_connected_with_me(struct ug_data *ugd, device_type_s *dev)
 788 {
 789         __FUNC_ENTER__;
 790         int i = 0;
 791
 792         for (i = 0; i < ugd->raw_connected_peer_cnt; i++) {
 793                 if (strncmp(ugd->raw_connected_peers[i].mac_addr,
 794                         dev->mac_addr, strlen(ugd->raw_connected_peers[i].mac_addr)) == 0) {
 795                         return TRUE;
 796                 }
 797         }
 798
 799         __FUNC_EXIT__;
 800         return FALSE;
 801 }
 802
 803 /**
 804  *      This function let the ug know whether current device is connected by other peer
 805  *      @return   If connected, return TRUE, else return FALSE
 806  *      @param[in] ugd the pointer to the main data structure
 807  *      @param[in] dev the pointer to the device
 808  */
 809 static bool __wfd_is_device_busy(struct ug_data *ugd, device_type_s *dev)
 810 {
 811         __FUNC_ENTER__;
 812
 813         if (ugd->I_am_group_owner == TRUE) {
 814                 if (dev->is_connected || dev->is_group_owner) {
 815                         return TRUE;
 816                 } else {
 817                         return FALSE;
 818                 }
 819         } else {
 820                 if (dev->is_connected == TRUE && dev->is_group_owner == TRUE) {
 821                         return FALSE;
 822                 }
 823
 824                 if (dev->is_connected == TRUE && dev->is_group_owner == FALSE) {
 825                         return TRUE;
 826                 }
 827
 828                 if (dev->is_connected == FALSE) {
 829                         return FALSE;
 830                 }
 831         }
 832
 833         __FUNC_EXIT__;
 834         return FALSE;
 835 }
 836
 837 /**
 838  *      This function let the ug calculate how many devices are avaliable
 839  *      @return   TRUE
 840  *      @param[in] ugd the pointer to the main data structure
 841  *      @param[in] dev the pointer to the number of avaliable devices
 842  */
 843 static bool __wfd_is_any_device_available(struct ug_data *ugd, int* no_of_available_dev)
 844 {
 845         __FUNC_ENTER__;
 846         GList *iterator = NULL;
 847
 848         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 849                 /* Not include the device which is connected with me */
 850                 if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) {
 851                         continue;
 852                 }
 853                 if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) &&
 854                         ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_FAILED_TO_CONNECT) {
 855                         (*no_of_available_dev)++;
 856                 }
 857         }
 858
 859         __FUNC_EXIT__;
 860         return TRUE;
 861 }
 862
 863 /**
 864  *      This function let the ug calculate how many devices are busy
 865  *      @return   TRUE
 866  *      @param[in] ugd the pointer to the main data structure
 867  *      @param[in] dev the pointer to the number of busy devices
 868  */
 869 static bool __wfd_is_any_device_busy(struct ug_data *ugd, int* no_of_busy_dev)
 870 {
 871         __FUNC_ENTER__;
 872         GList *iterator = NULL;
 873
 874         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 875                 /* Not include the device which is connected with me */
 876                 if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) {
 877                         continue;
 878                 }
 879                 if (__wfd_is_device_busy(ugd, (device_type_s *)iterator->data)) {
 880                         (*no_of_busy_dev)++;
 881                 }
 882         }
 883
 884         __FUNC_EXIT__;
 885         return TRUE;
 886 }
 887
 888 /**
 889  *      This function let the ug calculate how many devices are connected failed
 890  *      @return   TRUE
 891  *      @param[in] ugd the pointer to the main data structure
 892  *      @param[in] dev the pointer to the number of connected failed devices
 893  */
 894 static bool __wfd_is_any_device_connect_failed(struct ug_data *ugd, int* no_of_connect_failed_dev)
 895 {
 896         __FUNC_ENTER__;
 897         GList *iterator = NULL;
 898
 899         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 900                 /* Not include the device which is connected with me */
 901                 if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) {
 902                         continue;
 903                 }
 904                 if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) &&
 905                         ((device_type_s *)iterator->data)->conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) {
 906                         (*no_of_connect_failed_dev)++;
 907                 }
 908         }
 909
 910         __FUNC_EXIT__;
 911         return TRUE;
 912 }
 913
 914 /**
 915  *      This function let the ug create the main genlist
 916  *      @return   the main genlist
 917  *      @param[in] data the pointer to the main data structure
 918  */
 919 static Evas_Object *_create_basic_genlist(void *data)
 920 {
 921         __FUNC_ENTER__;
 922         struct ug_data *ugd = (struct ug_data *) data;
 923         Evas_Object *genlist;
 924
 925         genlist = elm_genlist_add(ugd->layout);
 926         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 927         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 928         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND,
 929                         EVAS_HINT_EXPAND);
 930         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 931
 932         /* Wifi ON/OFF toggle button */
 933 #ifdef WFD_ON_OFF_GENLIST
 934         ugd->item_wifi_onoff = elm_genlist_item_append(genlist, &wfd_onoff_itc, ugd,
 935                         NULL, ELM_GENLIST_ITEM_NONE,_onoff_changed_cb, ugd);
 936         elm_genlist_item_selected_set(ugd->item_wifi_onoff,
 937                                         EINA_FALSE);
 938 #endif
 939         evas_object_smart_callback_add(genlist, "realized", _gl_realized, ugd);
 940         evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd);
 941         ugd->device_name_item = elm_genlist_item_append(genlist, &device_name_itc, ugd, NULL,
 942                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 943         if(ugd->device_name_item != NULL)
 944                 elm_genlist_item_select_mode_set(ugd->device_name_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 945
 946         __FUNC_EXIT__;
 947         return genlist;
 948 }
 949
 950 /**
 951  *      This function let the ug create no device item to append the genlist
 952  *      @return   the main item
 953  *      @param[in] data the pointer to the main data structure
 954  */
 955 Evas_Object *_create_no_device_genlist(void *data)
 956 {
 957         __FUNC_ENTER__;
 958         struct ug_data *ugd = (struct ug_data *) data;
 959         Elm_Object_Item *last_item = NULL;
 960         int i = 0;
 961
 962         WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item);
 963
 964         if (ugd->conn_wfd_item != NULL) {
 965                 last_item = ugd->conn_wfd_item;
 966                 for (i = 0; i < ugd->gl_connected_peer_cnt; i++) {
 967                         last_item = elm_genlist_item_next_get(last_item);
 968                 }
 969         } else {
 970                 last_item = ugd->device_name_item;
 971         }
 972
 973         ugd->nodevice_title_item = elm_genlist_item_insert_after(ugd->genlist,
 974                 &title_no_device_itc, (void *)ugd, NULL, last_item,
 975                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 976         if(ugd->nodevice_title_item != NULL)
 977                 elm_genlist_item_select_mode_set(ugd->nodevice_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 978
 979         ugd->nodevice_item = elm_genlist_item_insert_after(ugd->genlist, &noitem_itc, (void *)ugd, NULL,
 980                 ugd->nodevice_title_item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 981         if(ugd->nodevice_item != NULL)
 982                 elm_genlist_item_select_mode_set(ugd->nodevice_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 983
 984         __FUNC_EXIT__;
 985         return ugd->genlist;
 986 }
 987
 988 /**
 989  *      This function let the ug create busy device list
 990  *      @return   0
 991  *      @param[in] data the pointer to the main data structure
 992  */
 993 int _create_busy_dev_list(void *data)
 994 {
 995         __FUNC_ENTER__;
 996         struct ug_data *ugd = (struct ug_data *) data;
 997
 998         ugd->busy_wfd_item = elm_genlist_item_append(ugd->genlist, &title_busy_itc, (void *)ugd,
 999                 NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1000         if(ugd->busy_wfd_item != NULL)
1001                 elm_genlist_item_select_mode_set(ugd->busy_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1002         __FUNC_EXIT__;
1003         return 0;
1004 }
1005
1006 void wfd_free_nodivice_item(struct ug_data *ugd)
1007 {
1008         __FUNC_ENTER__;
1009         WFD_IF_DEL_ITEM(ugd->nodevice_title_item);
1010         WFD_IF_DEL_ITEM(ugd->nodevice_item);
1011         __FUNC_EXIT__;
1012 }
1013
1014 /**
1015  *      This function let the ug create avaliable device list
1016  *      @return   0
1017  *      @param[in] data the pointer to the main data structure
1018  */
1019 int _create_available_dev_genlist(void *data)
1020 {
1021         __FUNC_ENTER__;
1022         int i = 0;
1023         struct ug_data *ugd = (struct ug_data *) data;
1024         Elm_Object_Item *last_item = NULL;
1025
1026         wfd_free_nodivice_item(ugd);
1027
1028         if (ugd->conn_wfd_item != NULL) {
1029                 last_item = ugd->conn_wfd_item;
1030                 for (i=0; i<ugd->gl_connected_peer_cnt; i++) {
1031                         last_item = elm_genlist_item_next_get(last_item);
1032                 }
1033         } else {
1034                 last_item = ugd->device_name_item;
1035         }
1036
1037         ugd->avlbl_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_available_itc, (void *)ugd, NULL,
1038                 last_item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1039         if(ugd->avlbl_wfd_item != NULL) {
1040                 elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1041                 elm_genlist_item_update(ugd->avlbl_wfd_item);
1042         }
1043         __FUNC_EXIT__;
1044         return 0;
1045 }
1046
1047 /**
1048  *      This function let the ug create multi connect device list
1049  *      @return   0
1050  *      @param[in] data the pointer to the main data structure
1051  */
1052 static int _create_multi_connect_dev_genlist(void *data)
1053 {
1054         __FUNC_ENTER__;
1055         struct ug_data *ugd = (struct ug_data *) data;
1056
1057         ugd->multi_connect_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_multi_connect_itc, (void *)ugd,
1058                                                                 NULL, ugd->device_name_item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1059         if(ugd->multi_connect_wfd_item != NULL)
1060                 elm_genlist_item_select_mode_set(ugd->multi_connect_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1061         __FUNC_EXIT__;
1062         return 0;
1063 }
1064
1065 /**
1066  *      This function let the ug create connected device list
1067  *      @return   0
1068  *      @param[in] data the pointer to the main data structure
1069  */
1070 int _create_connected_dev_genlist(void *data)
1071 {
1072         __FUNC_ENTER__;
1073         struct ug_data *ugd = (struct ug_data *) data;
1074
1075         ugd->conn_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_conn_itc, (void *)ugd, NULL,
1076                 ugd->device_name_item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1077         if(ugd->conn_wfd_item != NULL) {
1078                 elm_genlist_item_select_mode_set(ugd->conn_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1079                 elm_genlist_item_update(ugd->conn_wfd_item);
1080         }
1081
1082         __FUNC_EXIT__;
1083         return 0;
1084 }
1085
1086 /**
1087  *      This function let the ug create connected falied device list
1088  *      @return   0
1089  *      @param[in] data the pointer to the main data structure
1090  */
1091 int _create_connected_failed_dev_genlist(void *data)
1092 {
1093         __FUNC_ENTER__;
1094         struct ug_data *ugd = (struct ug_data *) data;
1095         Elm_Object_Item *last_item = NULL;
1096         int i = 0;
1097
1098         if (ugd->avlbl_wfd_item != NULL) {
1099                 last_item = ugd->avlbl_wfd_item;
1100                 for (i=0; i<ugd->gl_available_peer_cnt; i++) {
1101                         last_item = elm_genlist_item_next_get(last_item);
1102                 }
1103         } else if (ugd->conn_wfd_item != NULL) {
1104                 last_item = ugd->conn_wfd_item;
1105                 for (i=0; i<ugd->gl_connected_peer_cnt; i++) {
1106                         last_item = elm_genlist_item_next_get(last_item);
1107                 }
1108         } else {
1109                 last_item = ugd->device_name_item;
1110         }
1111
1112         ugd->conn_failed_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_conn_failed_itc, (void *)ugd,
1113                                                                 NULL, last_item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1114         if(ugd->conn_failed_wfd_item != NULL)
1115                 elm_genlist_item_select_mode_set(ugd->conn_failed_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1116         __FUNC_EXIT__;
1117         return 0;
1118 }
1119
1120 /**
1121  *      This function let the ug make the display callback for connect failed peers
1122  *      @return   if stop the timer, return ECORE_CALLBACK_CANCEL, else return ECORE_CALLBACK_RENEW
1123  *      @param[in] data the pointer to the user data
1124  */
1125 static Eina_Bool _connect_failed_peers_display_cb(void *user_data)
1126 {
1127         __FUNC_ENTER__;
1128         int interval = 0;
1129         int res = -1;
1130         struct ug_data *ugd = (struct ug_data *) user_data;
1131
1132         if (NULL == ugd) {
1133                 DBG(LOG_ERROR, "NULL parameters.\n");
1134                 return ECORE_CALLBACK_CANCEL;
1135         }
1136
1137         if (ugd->avlbl_wfd_item == NULL) {
1138                 _create_available_dev_genlist(ugd);
1139         }
1140
1141         if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_BACKGROUND) {
1142                 DBG(LOG_INFO, "Background mode\n");
1143                 ugd->display_timer = NULL;
1144                 return ECORE_CALLBACK_CANCEL;
1145         }
1146
1147         /* check the timeout, if not timeout, keep the cb */
1148         interval = time(NULL) - ugd->last_display_time;
1149         if (interval < MAX_DISPLAY_TIME_OUT) {
1150                 return ECORE_CALLBACK_RENEW;
1151         }
1152
1153         if (ugd->is_paused == false) {
1154                 DBG(LOG_INFO, "Not Paused");
1155                 /* start discovery again */
1156                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
1157                 res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
1158                 if (res != WIFI_DIRECT_ERROR_NONE) {
1159                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
1160                         DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res);
1161                         wifi_direct_cancel_discovery();
1162                 }
1163         }
1164
1165         ugd->display_timer = NULL;
1166         __FUNC_EXIT__;
1167         return ECORE_CALLBACK_CANCEL;
1168 }
1169
1170 void wfd_ug_view_free_peer(device_type_s *gl_peers_start)
1171 {
1172         __FUNC_ENTER__;
1173         device_type_s *peer_for_free = NULL;
1174         device_type_s *peer = gl_peers_start;
1175
1176         while (peer != NULL && peer->gl_item != NULL) {
1177                 DBG(LOG_INFO, "Deleted item, ssid:%s\n", peer->ssid);
1178                 elm_object_item_del(peer->gl_item);
1179                 peer->gl_item = NULL;
1180                 peer_for_free = peer;
1181                 peer = peer->next;
1182                 free(peer_for_free);
1183         }
1184         __FUNC_EXIT__;
1185 }
1186
1187 void wfd_check_gl_conn_peers(struct ug_data *ugd)
1188 {
1189         __FUNC_ENTER__;
1190         if (ugd->gl_connected_peer_cnt == 0) {
1191                 WFD_IF_DEL_ITEM(ugd->conn_wfd_item);
1192         }
1193         __FUNC_EXIT__;
1194 }
1195
1196 /**
1197  *      This function let the ug free the peers
1198  *      @return   void
1199  *      @param[in] data the pointer to the main data structure
1200  */
1201 void wfd_ug_view_free_peers(void *data)
1202 {
1203         __FUNC_ENTER__;
1204
1205         struct ug_data *ugd = (struct ug_data *) data;
1206
1207         ugd->gl_connected_peer_cnt = 0;
1208
1209         if (ugd->gl_conn_peers_start != NULL) {
1210                 wfd_ug_view_free_peer(ugd->gl_conn_peers_start);
1211                 ugd->gl_conn_peers_start = NULL;
1212         }
1213
1214         ugd->gl_available_peer_cnt = 0;
1215
1216         if (ugd->gl_avlb_peers_start != NULL) {
1217                 wfd_ug_view_free_peer(ugd->gl_avlb_peers_start);
1218                 ugd->gl_avlb_peers_start = NULL;
1219         }
1220
1221         ugd->gl_busy_peer_cnt = 0;
1222
1223         if (ugd->gl_busy_peers_start != NULL) {
1224                 wfd_ug_view_free_peer(ugd->gl_busy_peers_start);
1225                 ugd->gl_busy_peers_start = NULL;
1226         }
1227
1228         ugd->gl_multi_connect_peer_cnt = 0;
1229
1230         if (ugd->gl_mul_conn_peers_start != NULL) {
1231                 wfd_ug_view_free_peer(ugd->gl_mul_conn_peers_start);
1232                 ugd->gl_mul_conn_peers_start = NULL;
1233         }
1234
1235         if (ugd->gl_connected_peer_cnt == 0) {
1236                 WFD_IF_DEL_ITEM(ugd->conn_wfd_item);
1237         }
1238
1239         if (ugd->display_timer != NULL) {
1240                 ecore_timer_del(ugd->display_timer);
1241                 ugd->display_timer = NULL;
1242         }
1243
1244         WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item);
1245         WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item);
1246         WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item);
1247         WFD_IF_DEL_ITEM(ugd->busy_wfd_item);
1248
1249         __FUNC_EXIT__;
1250 }
1251
1252 void wfd_ug_update_toolbar(struct ug_data *ugd)
1253 {
1254         __FUNC_ENTER__;
1255         int no_of_conn_dev = ugd->raw_connected_peer_cnt;
1256         Evas_Object *btn;
1257
1258         wfd_refresh_wifi_direct_state(ugd);
1259                 if (ugd->wfd_status == WIFI_DIRECT_STATE_CONNECTING) {
1260                         DBG(LOG_INFO, "WIFI_DIRECT_STATE_CONNECTING\n");
1261                         if( ugd->multi_connect_wfd_item != NULL) {
1262                                 DBG(LOG_INFO, "multi_connect_toolbar_item\n");
1263                                 btn = elm_button_add(ugd->layout);
1264                                 /* Use "bottom" style button */
1265                                 elm_object_style_set(btn, "bottom");
1266                                 elm_object_domain_translatable_text_set(btn, PACKAGE,
1267                                                 "IDS_WIFI_SK2_CANCEL_CONNECTION");
1268                                 evas_object_smart_callback_add(btn, "clicked",
1269                                         _wfd_ug_cancel_connection_button_cb, (void *)ugd);
1270                                 /* Set button into "toolbar" swallow part */
1271                                 elm_object_part_content_set(ugd->layout, "button.next", btn);
1272                                 ugd->disconnect_btn = btn;
1273                                 evas_object_show(ugd->disconnect_btn);
1274                                 elm_object_part_content_set(ugd->layout, "button.prev",
1275                                         ugd->scan_toolbar);
1276                                 wfd_ug_view_refresh_button(ugd->scan_toolbar,
1277                                         "IDS_WIFI_SK4_SCAN", FALSE);
1278                                 evas_object_data_set(ugd->disconnect_btn, "multi", "disconnect");
1279                                 DBG(LOG_INFO, "button: disconnect button added\n");
1280                         } else {
1281                                 DBG(LOG_INFO, "scan_toolbar\n");
1282                                 WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item);
1283                                 wfd_ug_view_refresh_button(ugd->scan_toolbar,
1284                                         "IDS_WIFI_SK2_CANCEL_CONNECTION", TRUE);
1285                                 evas_object_data_set(ugd->scan_btn, "multi", "cancel");
1286                                 DBG(LOG_INFO, "button: stop connect button added\n");
1287                         }
1288                 } else if (no_of_conn_dev > 0) {
1289                 if (!ugd->multi_connect_toolbar_item) {
1290                         btn = elm_button_add(ugd->layout);
1291                         /* Use "bottom" style button */
1292                         elm_object_style_set(btn, "bottom");
1293                         elm_object_domain_translatable_text_set(btn, PACKAGE,
1294                                         "IDS_WIFI_SK_DISCONNECT");
1295                         evas_object_smart_callback_add(btn, "clicked",
1296                                 _wfd_ug_disconnect_button_cb, (void *)ugd);
1297                         /* Set button into "toolbar" swallow part */
1298                         elm_object_part_content_set(ugd->layout, "button.next", btn);
1299                         ugd->disconnect_btn = btn;
1300                         evas_object_show(ugd->disconnect_btn);
1301                 }
1302                 elm_object_part_content_set(ugd->layout, "button.prev",
1303                         ugd->scan_toolbar);
1304                 wfd_ug_view_refresh_button(ugd->scan_toolbar,
1305                         "IDS_WIFI_SK4_SCAN", TRUE);
1306                 evas_object_data_set(ugd->disconnect_btn, "multi", "disconnect");
1307                 DBG(LOG_INFO, "button: disconnect button added\n");
1308         }else {
1309                 if (no_of_conn_dev == 0 && ugd->disconnect_btn != NULL) {
1310                         DBG(LOG_INFO, "disconnect btn removed when conn failed\n");
1311                         Evas_Object *content;
1312                         content = elm_object_part_content_unset(ugd->layout, "button.next");
1313                         WFD_IF_DEL_OBJ(content);
1314                         ugd->disconnect_btn = NULL;
1315                         elm_object_part_content_set(ugd->layout, "button.big",
1316                                 ugd->scan_toolbar);
1317                 }
1318                 wfd_ug_view_refresh_button(ugd->scan_toolbar,
1319                         "IDS_WIFI_SK4_SCAN", TRUE);
1320                 evas_object_data_set(ugd->scan_toolbar, "multi", "connect");
1321                 DBG(LOG_INFO, "button: scan button added\n");
1322         }
1323         __FUNC_EXIT__;
1324 }
1325
1326 /**
1327  *      This function let the ug init the genlist
1328  */
1329 void wfd_ug_view_init_genlist(void *data, bool is_free_all_peers)
1330 {
1331         __FUNC_ENTER__;
1332         struct ug_data *ugd = (struct ug_data *) data;
1333         int no_of_busy_dev = 0;
1334         int no_of_available_dev = 0;
1335         int no_of_conn_failed_dev = 0;
1336
1337         if (is_free_all_peers) {
1338                 wfd_ug_view_free_peers(ugd);
1339         }
1340
1341         if (ugd->gl_failed_peers_start != NULL) {
1342                 DBG(LOG_INFO, "These are failed peers, must clear them");
1343                 ugd->gl_connected_failed_peer_cnt = 0;
1344                 wfd_ug_view_free_peer(ugd->gl_failed_peers_start);
1345                 ugd->gl_failed_peers_start = NULL;
1346                 WFD_IF_DEL_ITEM(ugd->conn_failed_wfd_item);
1347         }
1348
1349         if (ugd->avlbl_wfd_item != NULL) {
1350                 DBG(LOG_INFO, "There are available peers in genlist");
1351                 wfd_ug_view_refresh_glitem(ugd->avlbl_wfd_item);
1352                 return;
1353         }
1354
1355         __wfd_is_any_device_busy(ugd, &no_of_busy_dev);
1356         __wfd_is_any_device_available(ugd, &no_of_available_dev);
1357         __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev);
1358
1359         __FUNC_EXIT__;
1360 }
1361
1362 /**
1363  *      This function let the ug find a peer in genlist
1364  */
1365 device_type_s *find_peer_in_glist(device_type_s *start_pos, const char *mac_addr)
1366 {
1367         __FUNC_ENTER__;
1368
1369         if (start_pos == NULL) {
1370                 DBG(LOG_INFO, "no peer in genlist");
1371                 return NULL;
1372         }
1373
1374         device_type_s *peer = start_pos;
1375
1376         while (peer != NULL) {
1377                 if (!strncmp(peer->mac_addr, mac_addr, MAC_LENGTH - 1)) {
1378                         peer->is_alive = true;
1379                         DBG(LOG_INFO, "device [%s] found in genlist", peer->ssid);
1380                         __FUNC_EXIT__;
1381                         return peer;
1382                 }
1383                 peer = peer->next;
1384         }
1385
1386         __FUNC_EXIT__;
1387         return NULL;
1388 }
1389
1390 void delete_not_alive_peers(struct ug_data *ugd, device_type_s **start_pos, int *cnt)
1391 {
1392         __FUNC_ENTER__;
1393         if (*start_pos == NULL) {
1394                 DBG(LOG_INFO, "no peer in genlist");
1395                 return;
1396         }
1397
1398         device_type_s *peer = *start_pos;
1399         device_type_s *peer_tmp = NULL;
1400         while (peer != NULL) {
1401                 peer_tmp = peer->next;
1402                 if(peer->is_alive == false) {
1403                          free_gl_peer(start_pos, peer->mac_addr, cnt);
1404                 }
1405                 peer = peer_tmp;
1406         }
1407
1408 //      wfd_check_gl_available_peers(ugd);
1409         if (ugd->gl_busy_peer_cnt == 0) {
1410                 WFD_IF_DEL_ITEM(ugd->busy_wfd_item);
1411         }
1412         __FUNC_EXIT__;
1413         return;
1414 }
1415
1416 void set_not_alive_peers(device_type_s *start_pos)
1417 {
1418         __FUNC_ENTER__;
1419         if (start_pos == NULL) {
1420                 DBG(LOG_INFO, "no peer in genlist");
1421                 return;
1422         }
1423
1424         device_type_s *peer = start_pos;
1425         while (peer != NULL) {
1426                 peer->is_alive = false;
1427                 peer = peer->next;
1428         }
1429
1430         __FUNC_EXIT__;
1431         return;
1432 }
1433
1434 /**
1435  *      This function let the ug get the insert position for next item
1436  */
1437 Elm_Object_Item *get_insert_postion(device_type_s *peer, Elm_Object_Item *pre_item, int peer_cnt)
1438 {
1439         __FUNC_ENTER__;
1440         int i = 0;
1441         device_type_s *peer_ite = NULL;
1442         Elm_Object_Item *head = elm_genlist_item_next_get(pre_item);
1443         Elm_Object_Item *item = NULL;
1444
1445         if(peer_cnt == 0) {
1446                 DBG(LOG_INFO, "first peer [%s] would be added", peer->ssid);
1447                 return pre_item;
1448         }
1449
1450         peer_ite = (device_type_s *)elm_object_item_data_get(head);
1451         if(peer_ite->gl_item != NULL) {
1452                 for(i=0; i < peer_cnt; i++) {
1453                         if (strcasecmp(peer_ite->ssid, peer->ssid) > 0) {
1454                                 /* if peer_ite is greater than peer, return previous item */
1455                                 __FUNC_EXIT__;
1456                                 return  elm_genlist_item_prev_get(head);
1457                         } else {
1458                                 item = elm_genlist_item_next_get(head);
1459                                 if (item == NULL) {
1460                                         /* return the last item */
1461                                         return head;
1462                                 } else {
1463                                         head = item;
1464                                         peer_ite = (device_type_s *)elm_object_item_data_get(head);
1465                                 }
1466                         }
1467                 }
1468         }
1469         __FUNC_EXIT__;
1470         return elm_genlist_item_prev_get(head);
1471 }
1472
1473 /**
1474  *      This function let the ug insert peer item to genlist
1475  */
1476 int insert_gl_item(Evas_Object *genlist, Elm_Object_Item *item, Elm_Gen_Item_Class *itc, device_type_s **start_pos,
1477                                 device_type_s *peer_for_insert, void *callback)
1478 {
1479         __FUNC_ENTER__;
1480         WFD_RETV_IF(item == NULL, -1, "Item is NULL\n");
1481         device_type_s *peer = NULL;
1482         device_type_s *peer_ite = NULL;
1483
1484         peer = (device_type_s *)malloc(sizeof(device_type_s));
1485         WFD_RETV_IF(peer == NULL, -1, "malloc failed\n");
1486
1487         memcpy(peer, peer_for_insert, sizeof(device_type_s));
1488         peer->next = NULL;
1489
1490         if(*start_pos == NULL) {
1491                 *start_pos = peer;
1492         } else {
1493                 peer_ite = *start_pos;
1494                 while(peer_ite->next != NULL) {
1495                         /* move pointer to the last peer */
1496                         peer_ite = peer_ite->next;
1497                 }
1498                 peer_ite->next = peer;
1499         }
1500
1501         peer->is_alive = true;
1502         peer->gl_item = elm_genlist_item_insert_after(genlist, itc, (void *)peer, NULL, item,
1503                 ELM_GENLIST_ITEM_NONE, callback, (void *)peer);
1504         if (callback == NULL && peer->gl_item != NULL) {
1505                 elm_genlist_item_select_mode_set(peer->gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1506         }
1507         __FUNC_EXIT__;
1508         return 0;
1509 }
1510
1511 /**
1512  *      This function let the ug update connected peers
1513  *      @return   void
1514  *      @param[in] data the pointer to the main data structure
1515  */
1516 void wfd_ug_update_connected_peers(void *data)
1517 {
1518         __FUNC_ENTER__;
1519
1520         struct ug_data *ugd = (struct ug_data *) data;
1521         int i = 0 ;
1522         int res;
1523         bool is_group_owner = FALSE;
1524         Elm_Object_Item *item = NULL;
1525
1526         res = wifi_direct_is_group_owner(&is_group_owner);
1527         if (res == WIFI_DIRECT_ERROR_NONE) {
1528                 DBG(LOG_INFO, "is_group_owner=[%d]", is_group_owner);
1529         }
1530
1531         if (!ugd->conn_wfd_item) {
1532                 _create_connected_dev_genlist(ugd);
1533         }
1534
1535         for (i = 0; i < ugd->raw_connected_peer_cnt; i++) {
1536                 if (find_peer_in_glist(ugd->gl_conn_peers_start, ugd->raw_connected_peers[i].mac_addr) == NULL) {
1537                         if (find_peer_in_glist(ugd->gl_avlb_peers_start, ugd->raw_connected_peers[i].mac_addr) != NULL) {
1538                                 free_gl_peer(&ugd->gl_avlb_peers_start, ugd->raw_connected_peers[i].mac_addr,
1539                                         &ugd->gl_available_peer_cnt);
1540                                 wfd_check_gl_available_peers(ugd);
1541                         }
1542
1543                         if (find_peer_in_glist(ugd->gl_mul_conn_peers_start, ugd->raw_connected_peers[i].mac_addr) != NULL) {
1544                                 free_gl_peer(&ugd->gl_mul_conn_peers_start, ugd->raw_connected_peers[i].mac_addr,
1545                                         &ugd->gl_multi_connect_peer_cnt);
1546                                 if (ugd->gl_multi_connect_peer_cnt == 0) {
1547                                         WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item);
1548                                         WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item);
1549                                 }
1550                         }
1551
1552                         item = get_insert_postion(&(ugd->raw_connected_peers[i]), ugd->conn_wfd_item,
1553                                 ugd->gl_connected_peer_cnt);
1554                         res = insert_gl_item(ugd->genlist, item, &peer_conn_itc, &ugd->gl_conn_peers_start,
1555                                         &ugd->raw_connected_peers[i], NULL);
1556                         if (res != 0) {
1557                                 break;
1558                         }
1559                         ugd->gl_connected_peer_cnt++;
1560                 }
1561         }
1562
1563         /* if is not GO, free all available peers */
1564         if (is_group_owner == FALSE) {
1565                 ugd->gl_available_peer_cnt = 0;
1566                 WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item);
1567
1568                 if (ugd->gl_avlb_peers_start != NULL) {
1569                         wfd_ug_view_free_peer(ugd->gl_avlb_peers_start);
1570                         ugd->gl_avlb_peers_start = NULL;
1571                 }
1572         }
1573
1574         /* free busy peers */
1575         if (ugd->gl_busy_peers_start != NULL) {
1576                 ugd->gl_busy_peer_cnt = 0;
1577                 WFD_IF_DEL_ITEM(ugd->busy_wfd_item);
1578
1579                 wfd_ug_view_free_peer(ugd->gl_busy_peers_start);
1580                 ugd->gl_busy_peers_start = NULL;
1581
1582         }
1583
1584         __FUNC_EXIT__;
1585 }
1586
1587 /**
1588  *      This function let the ug update the multi-connect peers
1589  *      @return   void
1590  *      @param[in] data the pointer to the main data structure
1591  */
1592 void wfd_ug_view_update_multiconn_peers(void *data)
1593 {
1594         __FUNC_ENTER__;
1595
1596         struct ug_data *ugd = (struct ug_data *) data;
1597         int i;
1598         int res;
1599         Elm_Object_Item *item = NULL;
1600
1601         if (ugd->raw_multi_selected_peer_cnt > 0) {
1602                 if (ugd->raw_connected_peer_cnt < ugd->raw_multi_selected_peer_cnt &&
1603                         ugd->multi_connect_wfd_item == NULL) {
1604                         _create_multi_connect_dev_genlist(ugd);
1605                 }
1606
1607                 for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
1608                         if (ugd->raw_multi_selected_peers[i].conn_status != PEER_CONN_STATUS_CONNECTED) {
1609                                 item = get_insert_postion(&(ugd->raw_multi_selected_peers[i]),
1610                                         ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt);
1611                                 res = insert_gl_item(ugd->genlist, item, &peer_itc, &ugd->gl_mul_conn_peers_start,
1612                                                 &ugd->raw_multi_selected_peers[i], NULL);
1613                                 if (res != 0) {
1614                                         break;
1615                                 }
1616                                 ugd->gl_multi_connect_peer_cnt++;
1617                         }
1618                 }
1619         }
1620
1621         __FUNC_EXIT__;
1622 }
1623
1624 /**
1625  *      This function let the ug update the available and busy peers
1626  */
1627 void wfd_ug_update_available_peers(void *data)
1628 {
1629         __FUNC_ENTER__;
1630
1631         struct ug_data *ugd = (struct ug_data *) data;
1632         int no_of_busy_dev = 0;
1633         int no_of_available_dev = 0;
1634         int no_of_conn_dev = 0;
1635         bool is_group_owner = FALSE;
1636         int res = 0;
1637         Elm_Object_Item *item = NULL;
1638         device_type_s *peer = NULL;
1639         GList *iterator = NULL;
1640
1641         __wfd_is_any_device_busy(ugd, &no_of_busy_dev);
1642         __wfd_is_any_device_available(ugd, &no_of_available_dev);
1643         no_of_conn_dev = ugd->raw_connected_peer_cnt;
1644
1645         res = wifi_direct_is_group_owner(&is_group_owner);
1646         if (res != WIFI_DIRECT_ERROR_NONE) {
1647                 DBG(LOG_INFO, "Fail to get group_owner_state. ret=[%d]", res);
1648                 ugd->I_am_group_owner = FALSE;
1649         } else {
1650                 ugd->I_am_group_owner = is_group_owner;
1651         }
1652
1653         DBG(LOG_INFO, "avail_dev=[%d], busy_dev=[%d], GO=[%d]\n", no_of_available_dev, no_of_busy_dev, is_group_owner);
1654         if (no_of_available_dev != 0 || no_of_busy_dev != 0) {
1655                 DBG(LOG_INFO, "There are available or busy peers\n");
1656                 wfd_free_nodivice_item(ugd);
1657         }
1658
1659         if (no_of_conn_dev == 0 || is_group_owner == TRUE) {
1660                 if (ugd->avlbl_wfd_item == NULL) {
1661                         _create_available_dev_genlist(ugd);
1662                 }
1663
1664                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
1665                         /* Not include the device which is connected with me */
1666                         if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) {
1667                                 continue;
1668                         }
1669                         if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) &&
1670                                 ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_FAILED_TO_CONNECT &&
1671                                 ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_CONNECTED) {
1672                                 /* free disconnected gl peer */
1673                                 if (find_peer_in_glist(ugd->gl_conn_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) {
1674                                         free_gl_peer(&ugd->gl_conn_peers_start, ((device_type_s *)iterator->data)->mac_addr,
1675                                                 &ugd->gl_connected_peer_cnt);
1676                                 }
1677
1678                                 /* free busy gl peer, which is available now */
1679                                 if (find_peer_in_glist(ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) {
1680                                         free_gl_peer(&ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr, &ugd->gl_busy_peer_cnt);
1681                                         if (ugd->gl_busy_peer_cnt == 0) {
1682                                                 WFD_IF_DEL_ITEM(ugd->busy_wfd_item);
1683                                         }
1684                                 }
1685
1686                                 if (find_peer_in_glist(ugd->gl_failed_peers_start, (const char *)((device_type_s *)iterator->data)->mac_addr) != NULL) {
1687                                         continue;
1688                                 }
1689
1690                                 peer = find_peer_in_glist(ugd->gl_avlb_peers_start, (const char *)((device_type_s *)iterator->data)->mac_addr);
1691                                 if (peer == NULL) {
1692                                         item = get_insert_postion((device_type_s *)iterator->data,
1693                                                 ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt);
1694                                         res = insert_gl_item(ugd->genlist, item, &peer_itc, &ugd->gl_avlb_peers_start,
1695                                                         (device_type_s *)iterator->data, _gl_peer_sel);
1696                                         if (res != 0) {
1697                                                 break;
1698                                         }
1699                                         ugd->gl_available_peer_cnt++;
1700                                 } else if (no_of_conn_dev > 0 && ((device_type_s *)iterator->data)->is_group_owner == TRUE) {
1701                                         /* if peer is GO, free it */
1702                                         free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr,
1703                                                 &ugd->gl_available_peer_cnt);
1704                                 }
1705                         }
1706                 }
1707         }
1708
1709         wfd_check_gl_available_peers(ugd);
1710         wfd_check_gl_conn_peers(ugd);
1711
1712         if (no_of_conn_dev == 0 && no_of_busy_dev > 0) {
1713                 if (ugd->busy_wfd_item == NULL) {
1714                         _create_busy_dev_list(ugd);
1715                 }
1716
1717                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
1718                         /* Not include the device which is connected with me */
1719                         if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) {
1720                                 continue;
1721                         }
1722                         if (__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) == TRUE) {
1723                                 if (find_peer_in_glist(ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr) == NULL) {
1724                                         if (find_peer_in_glist(ugd->gl_avlb_peers_start,
1725                                                 ((device_type_s *)iterator->data)->mac_addr) != NULL) {
1726                                                 free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr,
1727                                                         &ugd->gl_available_peer_cnt);
1728                                                 wfd_check_gl_available_peers(ugd);
1729                                         }
1730                                         item = get_insert_postion((device_type_s *)iterator->data, ugd->busy_wfd_item,
1731                                                 ugd->gl_busy_peer_cnt);
1732                                         res = insert_gl_item(ugd->genlist, item, &peer_busy_itc, &ugd->gl_busy_peers_start,
1733                                                         (device_type_s *)iterator->data, _gl_busy_peer_sel);
1734                                         if (res != 0) {
1735                                                 break;
1736                                         }
1737                                         ugd->gl_busy_peer_cnt++;
1738                                 }
1739                         }
1740                 }
1741         }
1742
1743         wfd_check_gl_busy_peers(ugd);
1744
1745         __FUNC_EXIT__;
1746 }
1747
1748 /**
1749  *      This function let the ug update the failed peers
1750  *      @return   void
1751  *      @param[in] data the pointer to the main data structure
1752  */
1753 void wfd_ug_update_failed_peers(void *data)
1754 {
1755         __FUNC_ENTER__;
1756         struct ug_data *ugd = (struct ug_data *) data;
1757         int no_of_conn_failed_dev = 0;
1758         GList *iterator = NULL;
1759
1760         __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev);
1761         DBG(LOG_INFO, "conn_failed_dev=[%d]", no_of_conn_failed_dev);
1762
1763         if (no_of_conn_failed_dev == 0) {
1764                 return;
1765         }
1766
1767         /* add timer for disappearing failed peers after N secs */
1768         if (NULL == ugd->display_timer) {
1769                 ugd->last_display_time = time(NULL);
1770                 ugd->display_timer = ecore_timer_add(0.05, (Ecore_Task_Cb)_connect_failed_peers_display_cb, ugd);
1771         }
1772
1773         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
1774                 if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) &&
1775                         ((device_type_s *)iterator->data)->conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) {
1776                         if (find_peer_in_glist(ugd->gl_failed_peers_start, ((device_type_s *)iterator->data)->mac_addr) == NULL) {
1777                                 if (find_peer_in_glist(ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) {
1778                                         free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr,
1779                                                 &ugd->gl_available_peer_cnt);
1780                                         wfd_check_gl_available_peers(ugd);
1781                                 }
1782                         }
1783                 }
1784         }
1785
1786         __FUNC_EXIT__;
1787 }
1788
1789 #ifdef WFD_ON_OFF_GENLIST
1790 /**
1791  *      This function is called when user swipes on/off button
1792  *      @return   void
1793  *      @param[in] data the pointer to the main data structure
1794  *      @param[in] obj the pointer to the evas object
1795  *      @param[in] event_info the pointer to the event information
1796  */
1797 void _onoff_changed_cb(void *data, Evas_Object *obj, void *event_info)
1798 {
1799         __FUNC_ENTER__;
1800         struct ug_data *ugd = (struct ug_data *)data;
1801         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
1802         WFD_RET_IF(ugd->on_off_check == NULL, "on_off_check(NULL)\n");
1803         wfd_refresh_wifi_direct_state(ugd);
1804         if(ugd->device_name_item != NULL)
1805                 elm_genlist_item_update(ugd->device_name_item);
1806
1807         elm_object_disabled_set(ugd->on_off_check, TRUE);
1808         if(ugd->disconnect_btn) {
1809                 Evas_Object *content;
1810                 content = elm_object_part_content_unset(ugd->layout, "button.next");
1811                 WFD_IF_DEL_OBJ(content);
1812                 ugd->disconnect_btn = NULL;
1813         }
1814         elm_object_part_content_set(ugd->layout, "button.big", ugd->scan_toolbar);
1815
1816         /* turn on/off wfd */
1817         if (!ugd->wfd_onoff) {
1818                 if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) {
1819                         DBG(LOG_INFO, "wifi-direct switch on\n");
1820                         elm_genlist_item_selected_set(ugd->item_wifi_onoff,
1821                                                                 EINA_FALSE);
1822                         wfd_client_switch_on(ugd);
1823                 }
1824         } else {
1825                 if (ugd->wfd_status >= WIFI_DIRECT_STATE_ACTIVATING) {
1826                         DBG(LOG_INFO, "wifi-direct switch off\n");
1827                         elm_genlist_item_selected_set(ugd->item_wifi_onoff,
1828                                                                 EINA_FALSE);
1829                         wfd_client_switch_off(ugd);
1830                 }
1831         }
1832
1833         __FUNC_EXIT__;
1834 }
1835
1836 void wfd_ug_refresh_on_off_check(struct ug_data *ugd)
1837 {
1838         __FUNC_ENTER__;
1839         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
1840         WFD_RET_IF(ugd->on_off_check == NULL, "on_off_check(NULL)\n");
1841
1842         wfd_refresh_wifi_direct_state(ugd);
1843         if (ugd->wfd_status == WIFI_DIRECT_STATE_DEACTIVATING ||
1844                 ugd->wfd_status == WIFI_DIRECT_STATE_ACTIVATING ) {
1845                 elm_object_disabled_set(ugd->on_off_check, TRUE);
1846         } else {
1847                 elm_object_disabled_set(ugd->on_off_check, FALSE);
1848         }
1849         if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) {
1850                 elm_check_state_set(ugd->on_off_check, TRUE);
1851         } else {
1852                 elm_check_state_set(ugd->on_off_check, FALSE);
1853         }
1854
1855         __FUNC_EXIT__;
1856 }
1857
1858 void wfd_ug_create_on_off_check(struct ug_data *ugd)
1859 {
1860         __FUNC_ENTER__;
1861         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
1862         WFD_RET_IF(ugd->naviframe == NULL, "naviframe NULL\n");
1863
1864         Evas_Object *check = elm_check_add(ugd->naviframe);
1865         elm_object_style_set(check, "naviframe/title_on&off");
1866         elm_check_state_set(check, ugd->wfd_onoff);
1867         evas_object_propagate_events_set(check, EINA_FALSE);
1868         evas_object_smart_callback_add(check, "changed", _onoff_changed_cb, ugd);
1869         elm_object_focus_allow_set(check, EINA_TRUE);
1870         elm_object_item_part_content_set(ugd->navi_item, "title_right_btn", check);
1871         evas_object_show(check);
1872         ugd->on_off_check = check;
1873
1874         __FUNC_EXIT__;
1875 }
1876 #endif
1877
1878 /**
1879  *      This function let the ug create the main view
1880  *      @return   void
1881  *      @param[in] data the pointer to the main data structure
1882  */
1883 void create_wfd_ug_view(void *data)
1884 {
1885         __FUNC_ENTER__;
1886         struct ug_data *ugd = (struct ug_data *) data;
1887         WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n");
1888 #ifdef TIZEN_WIFIDIRECT_MORE_BTN
1889         Evas_Object *more_btn;
1890 #endif
1891         Evas_Object *layout;
1892
1893         ugd->naviframe = elm_naviframe_add(ugd->base);
1894         elm_naviframe_prev_btn_auto_pushed_set(ugd->naviframe, EINA_FALSE);
1895         eext_object_event_callback_add(ugd->naviframe, EA_CALLBACK_BACK, eext_naviframe_back_cb, NULL);
1896         eext_object_event_callback_add(ugd->naviframe, EA_CALLBACK_MORE, eext_naviframe_more_cb, NULL);
1897         elm_object_part_content_set(ugd->base, "elm.swallow.content", ugd->naviframe);
1898
1899         ugd->back_btn = elm_button_add(ugd->naviframe);
1900         elm_object_style_set(ugd->back_btn, "naviframe/back_btn/default");
1901         evas_object_smart_callback_add(ugd->back_btn, "clicked", _back_btn_cb, (void *)ugd);
1902         elm_object_focus_allow_set(ugd->back_btn, EINA_FALSE);
1903
1904         /* Create layout */
1905         layout = elm_layout_add(ugd->naviframe);
1906         elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "main_layout");
1907         ugd->layout = layout;
1908
1909         ugd->genlist = _create_basic_genlist(ugd);
1910         if (ugd->genlist == NULL) {
1911                 DBG(LOG_ERROR, "Failed to create basic genlist");
1912                 return;
1913         }
1914         elm_object_part_content_set(layout, "elm.swallow.content", ugd->genlist);
1915
1916         elm_genlist_fx_mode_set(ugd->genlist, EINA_FALSE);
1917         evas_object_show(ugd->base);
1918         elm_object_focus_set(ugd->base, EINA_TRUE);
1919
1920         ugd->navi_item = elm_naviframe_item_push(ugd->naviframe, ugd->title,
1921                         ugd->back_btn, NULL, layout, NULL);
1922         elm_naviframe_item_pop_cb_set(ugd->navi_item, _back_btn_cb, ugd);
1923
1924 #ifdef TIZEN_WIFIDIRECT_MORE_BTN
1925         more_btn = elm_button_add(ugd->naviframe);
1926         elm_object_style_set(more_btn, "naviframe/more/default");
1927         evas_object_smart_callback_add(more_btn, "clicked",
1928                         _more_button_cb, ugd->win);
1929         elm_object_item_part_content_set(ugd->navi_item, "toolbar_more_btn",
1930                         more_btn);
1931 #endif
1932
1933         wifi_direct_initialize();
1934         wifi_direct_get_state(&ugd->wfd_status);
1935         if (ugd->wfd_status > WIFI_DIRECT_STATE_DEACTIVATING) {
1936                 scan_button_create(ugd);
1937         }
1938
1939         if (ugd->view_type && g_strcmp0(_(ugd->view_type), _("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) {
1940                 int ret = 0;
1941                 ugd->raw_discovered_peer_cnt = 0;
1942                 wfd_create_multiconnect_view(ugd);
1943                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
1944                 ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
1945                 if (ret != WIFI_DIRECT_ERROR_NONE) {
1946                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
1947                         DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
1948                         wifi_direct_cancel_discovery();
1949                 }
1950                 return;
1951         }
1952
1953         __FUNC_EXIT__;
1954 }
1955
1956 /**
1957  *      This function let the ug destroy the main view
1958  *      @return   void
1959  *      @param[in] data the pointer to the main data structure
1960  */
1961 void destroy_wfd_ug_view(void *data)
1962 {
1963         __FUNC_ENTER__;
1964         struct ug_data *ugd = (struct ug_data *) data;
1965         WFD_IF_DEL_ITEM(ugd->device_name_item);
1966         WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item);
1967         WFD_IF_DEL_ITEM(ugd->conn_wfd_item);
1968
1969         WFD_IF_DEL_OBJ(ugd->scan_toolbar);
1970         WFD_IF_DEL_OBJ(ugd->back_btn);
1971         WFD_IF_DEL_OBJ(ugd->toolbar);
1972         WFD_IF_DEL_OBJ(ugd->genlist);
1973         WFD_IF_DEL_OBJ(ugd->naviframe);
1974         __FUNC_EXIT__;
1975 }