ug-wifidirect/src/wfd_ug_multiconnect_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 #include <libintl.h>
  21 #include <glib.h>
  22
  23 #include <Elementary.h>
  24 #include <vconf.h>
  25 #include <ui-gadget-module.h>
  26
  27 #include "wfd_ug.h"
  28 #include "wfd_ug_view.h"
  29 #include "wfd_client.h"
  30
  31 Elm_Gen_Item_Class device_itc;
  32
  33 /**
  34  *      This function let the ug call it when click 'back' button in multi connect view
  35  *      @return   void
  36  *      @param[in] data the pointer to the main data structure
  37  *      @param[in] obj the pointer to the evas object
  38  *      @param[in] event_info the pointer to the event information
  39  */
  40 Eina_Bool _multiconnect_view_pop_cb(void *data, Elm_Object_Item *it)
  41 {
  42         __FUNC_ENTER__;
  43         struct ug_data *ugd = (struct ug_data *)data;
  44         int ret = 0;
  45         device_type_s *peer_for_free = NULL;
  46         device_type_s *peer = NULL;
  47
  48         if (!ugd) {
  49                 DBG(LOG_ERROR, "The param is NULL\n");
  50                 return EINA_FALSE;
  51         }
  52
  53         peer = ugd->multi_conn_dev_list_start;
  54
  55         while (peer != NULL) {
  56                 DBG(LOG_INFO, "Free peer, ssid:%s\n", peer->ssid);
  57                 peer_for_free = peer;
  58                 peer = peer->next;
  59                 free(peer_for_free);
  60                 peer_for_free = NULL;
  61         }
  62
  63         ugd->multi_conn_dev_list_start = NULL;
  64         ugd->multiconn_view_genlist = NULL;
  65         ugd->mcview_title_item = NULL;
  66         ugd->mcview_nodevice_item = NULL;
  67         ugd->multi_navi_item = NULL;
  68         ugd->multiconn_conn_btn = NULL;
  69         ugd->multiconn_layout = NULL;
  70         ugd->multiconn_scan_stop_btn = NULL;
  71
  72         DBG(LOG_INFO, "MultiConnectMode: %d\n", ugd->multi_connect_mode);
  73
  74         /* if pressing connect for multi-connecting, it should not start discovery again */
  75         if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_NONE) {
  76                 if (ugd->view_type == NULL) {
  77                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
  78                         DBG(LOG_INFO, "Discovery started\n");
  79                         ret = wifi_direct_start_discovery_specific_channel(false, 1,
  80                                 WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
  81                         if (ret != WIFI_DIRECT_ERROR_NONE) {
  82                                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
  83                                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
  84                                 wifi_direct_cancel_discovery();
  85                         }
  86                 } else if (g_strcmp0(D_(ugd->view_type),
  87                         D_("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) {
  88                         DBG(LOG_INFO, "Discovery not started\n");
  89                         ug_destroy_me(ugd->ug);
  90                 }
  91         }
  92
  93         __FUNC_EXIT__;
  94         return EINA_TRUE;
  95 }
  96
  97 /**
  98  *      This function let the ug reset the connected failed peers
  99  *      @return   false
 100  *      @param[in] event_info the pointer to the event information
 101  */
 102 gboolean __wfd_multi_connect_reset_cb(void *data)
 103 {
 104         __FUNC_ENTER__;
 105
 106         if (!data) {
 107                 DBG(LOG_ERROR, "The param is NULL\n");
 108                 return false;
 109         }
 110
 111         device_type_s *peer = NULL;
 112         struct ug_data *ugd = (struct ug_data *)data;
 113
 114         peer = ugd->gl_mul_conn_peers_start;
 115         while (peer != NULL) {
 116                 elm_object_item_del(peer->gl_item);
 117                 peer->gl_item = NULL;
 118                 peer = peer->next;
 119         }
 120
 121         WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item);
 122         WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item);
 123
 124         wfd_ug_update_available_peers(ugd);
 125
 126         __FUNC_EXIT__;
 127         return false;
 128 }
 129
 130 /**
 131  *      This function let the ug free the selected peers in multi connect view
 132  *      @return   void
 133  *      @param[in] data the pointer to the main data structure
 134  */
 135 void wfd_free_multi_selected_peers(void *data)
 136 {
 137         __FUNC_ENTER__;
 138
 139         int i = 0;
 140         struct ug_data *ugd = (struct ug_data *)data;
 141
 142         /* destroy the created group */
 143         wifi_direct_destroy_group();
 144
 145         /* release the selected peers */
 146         for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
 147                 memset(&ugd->raw_multi_selected_peers[i], 0x00, sizeof(device_type_s));
 148         }
 149
 150         ugd->raw_multi_selected_peer_cnt = 0;
 151         ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE;
 152
 153         __FUNC_EXIT__;
 154
 155 }
 156
 157 /**
 158  *      This function let the ug stop to connect to selected peer
 159  *      @return   If success, return 0, else return -1
 160  *      @param[in] data the pointer to the main data structure
 161  */
 162 int wfd_stop_multi_connect(void *data)
 163 {
 164         __FUNC_ENTER__;
 165         struct ug_data *ugd = (struct ug_data *)data;
 166
 167         if (ugd->act_popup) {
 168                 evas_object_del(ugd->act_popup);
 169                 ugd->act_popup = NULL;
 170         }
 171
 172         /* change the title of failed peers */
 173         ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_COMPLETED;
 174         wfd_ug_view_refresh_glitem(ugd->multi_connect_wfd_item);
 175         wfd_ug_update_toolbar(ugd);
 176
 177         if (ugd->gl_connected_peer_cnt > 0) {
 178                 wfd_client_set_p2p_group_owner_intent(7);
 179         } else {
 180                 wifi_direct_destroy_group();
 181         }
 182
 183         if(ugd->timer_multi_reset > 0) {
 184                 g_source_remove(ugd->timer_multi_reset);
 185         }
 186         /* after 30s, remove the failed peers */
 187         ugd->timer_multi_reset = g_timeout_add(30000 /*ms*/,
 188                 __wfd_multi_connect_reset_cb, ugd);
 189
 190         if (ugd->g_source_multi_connect_next > 0) {
 191                 g_source_remove(ugd->g_source_multi_connect_next);
 192         }
 193         ugd->g_source_multi_connect_next = 0;
 194
 195         /*when multi-connect end and auto_exit is true, exit UG*/
 196         if (ugd->is_auto_exit) {
 197                 _wfd_ug_auto_exit(ugd);
 198         }
 199
 200         __FUNC_EXIT__;
 201         return 0;
 202 }
 203
 204 /**
 205  *      This function let the ug start to connect the selected peers
 206  *      @return   If success, return 0, else return -1
 207  *      @param[in] data the pointer to the main data structure
 208  */
 209 int wfd_start_multi_connect(void *data)
 210 {
 211         __FUNC_ENTER__;
 212         struct ug_data *ugd = (struct ug_data *)data;
 213         int res;
 214
 215         if (ugd->raw_multi_selected_peer_cnt > 0) {
 216                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 217
 218                 res = wfd_client_group_add();
 219                 if (res == -1) {
 220                         DBG(LOG_ERROR, "Failed to add group");
 221                         wfd_free_multi_selected_peers(ugd);
 222
 223                         __FUNC_EXIT__;
 224                         return -1;
 225                 }
 226         } else {
 227                 DBG(LOG_INFO, "No selected peers.\n");
 228                 return -1;
 229         }
 230
 231         __FUNC_EXIT__;
 232         return 0;
 233 }
 234
 235 void wfd_sort_multi_selected_peers(struct ug_data *ugd)
 236 {
 237         __FUNC_ENTER__;
 238         int i = 0;
 239         int j = 0;
 240         device_type_s peer;
 241
 242         for(i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
 243                 for(j = 0; j < ugd->raw_multi_selected_peer_cnt-i-1; j++) {
 244                         if (strcasecmp(ugd->raw_multi_selected_peers[j].ssid, ugd->raw_multi_selected_peers[j + 1].ssid) > 0) {
 245                                 peer = ugd->raw_multi_selected_peers[j];
 246                                 ugd->raw_multi_selected_peers[j] = ugd->raw_multi_selected_peers[j + 1];
 247                                 ugd->raw_multi_selected_peers[j + 1] = peer;
 248                         }
 249                 }
 250         }
 251         __FUNC_EXIT__;
 252 }
 253
 254 /**
 255  *      This function let the ug connect to the next selected peer automatically
 256  *      @return   If stop the timer, return false, else return true
 257  *      @param[in] data the pointer to the main data structure
 258  */
 259 gboolean wfd_multi_connect_next_cb(void *data)
 260 {
 261         __FUNC_ENTER__;
 262         struct ug_data *ugd = (struct ug_data *)data;
 263         int i;
 264         int res;
 265
 266         // Reset g_source handler..
 267         if (ugd->g_source_multi_connect_next > 0) {
 268                 g_source_remove(ugd->g_source_multi_connect_next);
 269         }
 270         ugd->g_source_multi_connect_next = 0;
 271
 272         if (ugd->raw_multi_selected_peer_cnt > 0) {
 273                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 274                 for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
 275                         if (ugd->raw_multi_selected_peers[i].conn_status == PEER_CONN_STATUS_WAIT_FOR_CONNECT) {
 276                                 ugd->mac_addr_connecting = ugd->raw_multi_selected_peers[i].mac_addr;
 277                                 res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr);
 278                                 if (res == -1) {
 279                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT;
 280                                 } else {
 281                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING;
 282                                         break;
 283                                 }
 284                         }
 285                 }
 286
 287                 if (i >= ugd->raw_multi_selected_peer_cnt) {
 288                         // All selected peers are touched.
 289                         DBG(LOG_INFO, "Stop Multi Connect...\n");
 290                         wfd_stop_multi_connect(ugd);
 291                 }
 292         } else {
 293                 DBG(LOG_INFO, "No selected peers.\n");
 294         }
 295
 296         __FUNC_EXIT__;
 297         return false;
 298 }
 299
 300 /**
 301  *      This function let the ug call it when click 'connect' button in multi connect view
 302  *      @return   void
 303  *      @param[in] data the pointer to the main data structure
 304  *      @param[in] obj the pointer to the evas object
 305  *      @param[in] event_info the pointer to the event information
 306  */
 307 void _connect_btn_cb(void *data, Evas_Object *obj, void *event_info)
 308 {
 309         __FUNC_ENTER__;
 310         struct ug_data *ugd = (struct ug_data *)data;
 311         int count = 0;
 312         char popup_text[MAX_POPUP_TEXT_SIZE] = {0};
 313         device_type_s *peer = NULL;
 314
 315         peer = ugd->multi_conn_dev_list_start;
 316         while (peer != NULL) {
 317                 if(peer->dev_sel_state) {
 318                         count++;
 319                 }
 320                 peer = peer->next;
 321         }
 322         DBG(LOG_INFO, "MultiSelected Peer Count: %d", count);
 323
 324         /* if more than 7 device selected, show the popup */
 325         if (count > MAX_CONNECTED_PEER_NUM) {
 326                 snprintf(popup_text, MAX_POPUP_TEXT_SIZE, D_("IDS_ST_POP_YOU_CAN_CONNECT_UP_TO_PD_DEVICES_AT_THE_SAME_TIME"), MAX_CONNECTED_PEER_NUM);
 327                 wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP);
 328                 __FUNC_EXIT__;
 329                 return;
 330         }
 331
 332         peer = ugd->multi_conn_dev_list_start;
 333         count = 0;
 334         while (peer != NULL) {
 335                 if(peer->dev_sel_state) {
 336                         DBG(LOG_INFO, "peer_name[%s] select state[%d]", peer->ssid, peer->dev_sel_state);
 337                         memcpy(&ugd->raw_multi_selected_peers[count], peer, sizeof(device_type_s));
 338                         ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT;
 339                         count++;
 340                 }
 341                 peer = peer->next;
 342         }
 343
 344         DBG(LOG_INFO, "MultiSelected Peer Count2: %d", count);
 345         ugd->raw_multi_selected_peer_cnt = count;
 346         wfd_sort_multi_selected_peers(ugd);
 347         wfd_cancel_progressbar_stop_timer(ugd);
 348         wfd_cancel_not_alive_delete_timer(ugd);
 349
 350         /* start multi connection */
 351         wfd_start_multi_connect(ugd);
 352
 353         elm_naviframe_item_pop(ugd->naviframe);
 354
 355         __FUNC_EXIT__;
 356         return;
 357 }
 358
 359 void wfd_naviframe_title_set(struct ug_data *ugd, const char *title)
 360 {
 361         if (!ugd || !ugd->multi_navi_item) {
 362                 DBG(LOG_ERROR, "The param is NULL\n");
 363                 return;
 364         }
 365
 366         elm_object_item_part_text_set(ugd->multi_navi_item, "default", title);
 367 }
 368
 369 /**
 370  *      This function let the ug call it when click the peer in multi connect view
 371  *      @return   void
 372  *      @param[in] data the pointer to the main data structure
 373  *      @param[in] obj the pointer to the evas object
 374  *      @param[in] event_info the pointer to the event information
 375  */
 376 static void _wfd_gl_multi_sel_cb(void *data, Evas_Object *obj, void *event_info)
 377 {
 378         __FUNC_ENTER__;
 379
 380         int sel_count = 0;
 381         bool is_sel = FALSE;
 382
 383         Eina_Bool state = EINA_FALSE;
 384         Evas_Object *chk_box = NULL;
 385         const char *object_type = NULL;
 386         struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data();
 387         device_type_s *peer = (device_type_s *)data;
 388
 389         if (NULL == ugd) {
 390                 DBG(LOG_ERROR, "ugd is NULL\n");
 391                 return;
 392         }
 393
 394         ugd->is_multi_check_all_selected = TRUE;
 395
 396         if(event_info != NULL) {
 397                 Evas_Object *content = elm_object_item_part_content_get(event_info, "elm.icon.2");
 398                 chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 399                 state = elm_check_state_get(chk_box);
 400                 DBG(LOG_INFO, "state = %d \n", state);
 401                 if (chk_box ==  NULL) {
 402                         DBG(LOG_INFO, "Check box is null\n");
 403                 }
 404         }
 405
 406         object_type = evas_object_type_get(obj);
 407          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 408                 Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 409                 if (item) {
 410                         elm_genlist_item_selected_set(item, EINA_FALSE);
 411                 }
 412                 DBG(LOG_INFO, "State elm_genlist %d\n", state);
 413                 elm_check_state_set(chk_box, !state);
 414                 peer->dev_sel_state = !state;
 415         } else if (g_strcmp0(object_type, "elm_check") == 0){
 416                 DBG(LOG_INFO, "elm_check state; %d\n", peer->dev_sel_state);
 417                 peer->dev_sel_state = !peer->dev_sel_state;
 418         }
 419
 420         DBG(LOG_INFO, "ptr->dev_sel_state = %d \n", peer->dev_sel_state);
 421         DBG_SECURE(LOG_INFO, "ptr->peer.mac_addr = ["MACSECSTR"]\n",
 422                 MAC2SECSTR(peer->mac_addr));
 423
 424         peer = ugd->multi_conn_dev_list_start;
 425         while (peer != NULL) {
 426                 if(peer->dev_sel_state) {
 427                         is_sel = TRUE;
 428                         sel_count++;
 429                 } else {
 430                         ugd->is_multi_check_all_selected = FALSE;
 431                 }
 432                 peer = peer->next;
 433         }
 434
 435         if (is_sel) {
 436                 char title[MAX_POPUP_TEXT_SIZE] = {0};
 437                 snprintf(title, MAX_POPUP_TEXT_SIZE, D_("IDS_ST_HEADER_PD_SELECTED"), sel_count);
 438                 wfd_naviframe_title_set(ugd, title);
 439         } else {
 440                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 441         }
 442
 443         state = elm_check_state_get(ugd->select_all_icon);
 444         if (ugd->multiconn_layout) {
 445                 if (state != EINA_TRUE && ugd->is_multi_check_all_selected == TRUE) {
 446                         elm_check_state_set(ugd->select_all_icon, TRUE);
 447                         ugd->is_select_all_checked = TRUE;
 448                 } else if (ugd->is_multi_check_all_selected == FALSE) {
 449                         elm_check_state_set(ugd->select_all_icon, FALSE);
 450                         ugd->is_select_all_checked = FALSE;
 451                 }
 452                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 453                         "IDS_WIFI_SK_CONNECT", is_sel);
 454         }
 455
 456         __FUNC_EXIT__;
 457 }
 458
 459 /**
 460  *      This function let the ug get the label of peer
 461  *      @return   the label of peer
 462  *      @param[in] data the pointer to the main data structure
 463  *      @param[in] obj the pointer to the evas object
 464  *      @param[in] part the pointer to the part of item
 465  */
 466 static char *_wfd_gl_device_label_get(void *data, Evas_Object *obj, const char *part)
 467 {
 468         __FUNC_ENTER__;
 469         DBG(LOG_INFO, "part %s", part);
 470         device_type_s *peer = (device_type_s *)data;
 471         char *ssid;
 472
 473         if (NULL == peer) {
 474                 return NULL;
 475         }
 476
 477         if (!strcmp("elm.text", part)) {
 478                 if (strlen(peer->ssid) != 0) {
 479                         ssid = elm_entry_utf8_to_markup(peer->ssid);
 480                         if (NULL == ssid) {
 481                                 DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n");
 482                                 __FUNC_EXIT__;
 483                                 return NULL;
 484                         }
 485                         __FUNC_EXIT__;
 486                         return ssid;
 487                 }
 488         }
 489         return NULL;
 490 }
 491
 492 /**
 493  *      This function let the ug get the icon path of peer
 494  *      @return   the  icon path of titile
 495  *      @param[in] peer the pointer to the peer
 496  */
 497 static char *__wfd_get_device_icon_path(device_type_s *peer)
 498 {
 499         __FUNC_ENTER__;
 500         char *img_name = NULL;
 501
 502         switch (peer->category) {
 503         case WFD_DEVICE_TYPE_COMPUTER:
 504                 img_name = WFD_ICON_DEVICE_COMPUTER;
 505                 break;
 506         case WFD_DEVICE_TYPE_INPUT_DEVICE:
 507                 img_name = WFD_ICON_DEVICE_INPUT_DEVICE;
 508                 break;
 509         case WFD_DEVICE_TYPE_PRINTER:
 510                 img_name = WFD_ICON_DEVICE_PRINTER;
 511                 break;
 512         case WFD_DEVICE_TYPE_CAMERA:
 513                 img_name = WFD_ICON_DEVICE_CAMERA;
 514                 break;
 515         case WFD_DEVICE_TYPE_STORAGE:
 516                 img_name = WFD_ICON_DEVICE_STORAGE;
 517                 break;
 518         case WFD_DEVICE_TYPE_NW_INFRA:
 519                 img_name = WFD_ICON_DEVICE_NETWORK_INFRA;
 520                 break;
 521         case WFD_DEVICE_TYPE_DISPLAYS:
 522                 img_name = WFD_ICON_DEVICE_DISPLAY;
 523                 break;
 524         case WFD_DEVICE_TYPE_MM_DEVICES:
 525                 img_name = WFD_ICON_DEVICE_MULTIMEDIA;
 526                 break;
 527         case WFD_DEVICE_TYPE_GAME_DEVICES:
 528                 img_name = WFD_ICON_DEVICE_GAMING;
 529                 break;
 530         case WFD_DEVICE_TYPE_TELEPHONE:
 531                 img_name = WFD_ICON_DEVICE_TELEPHONE;
 532                 break;
 533         case WFD_DEVICE_TYPE_AUDIO:
 534                 img_name = WFD_ICON_DEVICE_HEADSET;
 535                 break;
 536         default:
 537                 img_name = WFD_ICON_DEVICE_UNKNOWN;
 538                 break;
 539         }
 540         return img_name;
 541 }
 542
 543 /**
 544  *      This function let the ug get the icon of peer
 545  *      @return   the icon of peer
 546  *      @param[in] data the pointer to the main data structure
 547  *      @param[in] obj the pointer to the evas object
 548  *      @param[in] part the pointer to the part of item
 549  */
 550 static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part)
 551 {
 552         __FUNC_ENTER__;
 553         char *img_name = NULL;
 554         device_type_s *peer = (device_type_s *) data;
 555         Evas_Object *icon = NULL;
 556         Evas_Object *icon_layout = NULL;
 557
 558         DBG(LOG_INFO, "Part %s", part);
 559
 560         if (!strcmp("elm.swallow.icon", part)) {
 561                 DBG(LOG_INFO, "Part %s", part);
 562                 icon_layout = elm_layout_add(obj);
 563                 elm_layout_theme_set(icon_layout, "layout", "list/B/type.3", "default");
 564                 img_name = __wfd_get_device_icon_path(peer);
 565                 icon = elm_image_add(icon_layout);
 566                 elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name);
 567                 evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 568                 evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 569                 evas_object_color_set(icon, 2, 61, 132, 204);
 570                 evas_object_show(icon);
 571                 evas_object_propagate_events_set(icon, EINA_FALSE);
 572                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 573         } else if (!strcmp("elm.swallow.end", part)) {
 574                 icon_layout = elm_layout_add(obj);
 575                 elm_layout_theme_set(icon_layout, "layout", "list/C/type.2", "default");
 576                 DBG(LOG_INFO, "Part %s", part);
 577                 icon = elm_check_add(icon_layout);
 578                 elm_object_style_set(icon, "default/genlist");
 579                 evas_object_propagate_events_set(icon, EINA_FALSE);
 580                 if (peer->dev_sel_state == EINA_TRUE) {
 581                         elm_check_state_set(icon, EINA_TRUE);
 582                 }
 583                 evas_object_smart_callback_add(icon,
 584                         "changed", _wfd_gl_multi_sel_cb, (void *)data);
 585                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 586         }
 587
 588         if (icon_layout)
 589                 evas_object_show(icon_layout);
 590
 591         return icon_layout;
 592 }
 593
 594 /**
 595  *      This function let the ug call it when unresized event is received
 596 */
 597 static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info)
 598 {
 599         __FUNC_ENTER__;
 600         struct ug_data *ugd = (struct ug_data *)data;
 601         int sel_count = 0;
 602         bool is_sel = FALSE;
 603         device_type_s *peer = NULL;
 604
 605         if (!ugd->multiconn_conn_btn) {
 606                 DBG(LOG_INFO, "popup naviframe, no need to update UI\n");
 607                 return;
 608         }
 609
 610         if (ugd->gl_available_dev_cnt_at_multiconn_view > 0) {
 611                 peer = ugd->multi_conn_dev_list_start;
 612                 while (peer != NULL) {
 613                         if(peer->dev_sel_state) {
 614                                 is_sel = TRUE;
 615                                 sel_count++;
 616                         }
 617                         peer = peer->next;
 618                 }
 619         }
 620
 621         if (is_sel) {
 622                 char title[MAX_POPUP_TEXT_SIZE] = {0};
 623                 snprintf(title, MAX_POPUP_TEXT_SIZE, D_("IDS_ST_HEADER_PD_SELECTED"), sel_count);
 624                 wfd_naviframe_title_set(ugd, title);
 625         } else {
 626                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 627         }
 628
 629         if (ugd->multiconn_conn_btn) {
 630                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 631                         "IDS_WIFI_SK_CONNECT", is_sel);
 632         }
 633
 634         __FUNC_EXIT__;
 635 }
 636
 637 /**
 638  *      This function let the ug free the multi connect devices
 639  *      @return   0
 640  *      @param[in] data the pointer to the main data structure
 641  */
 642 int wfd_free_multiconnect_device(struct ug_data *ugd)
 643 {
 644         __FUNC_ENTER__;
 645
 646         if (ugd->multiconn_view_genlist == NULL) {
 647                 return 0;
 648         }
 649
 650         ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 651         if (ugd->multi_conn_dev_list_start != NULL) {
 652                 wfd_ug_view_free_peer(ugd->multi_conn_dev_list_start);
 653                 ugd->multi_conn_dev_list_start = NULL;
 654         }
 655
 656         __FUNC_EXIT__;
 657         return 0;
 658 }
 659
 660 /**
 661  *      This function let the ug create "no device found" item
 662 */
 663 Evas_Object *_create_no_device_multiconnect_genlist(struct ug_data *ugd)
 664 {
 665         __FUNC_ENTER__;
 666
 667         if (NULL == ugd) {
 668                 DBG(LOG_ERROR, "NULL parameters.\n");
 669                 return NULL;
 670         }
 671
 672         if (!ugd->mcview_nodevice_item) {
 673                 ugd->mcview_nodevice_item = elm_genlist_item_append(ugd->multiconn_view_genlist, &noitem_itc, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 674                 if(ugd->mcview_nodevice_item != NULL)
 675                         elm_genlist_item_select_mode_set(ugd->mcview_nodevice_item , ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 676         }
 677
 678         __FUNC_EXIT__;
 679         return ugd->multiconn_view_genlist;
 680 }
 681
 682 /**
 683  *      This function let the ug update the multi connect devices
 684  *      @return   0
 685  *      @param[in] data the pointer to the main data structure
 686  */
 687 int wfd_update_multiconnect_device(struct ug_data *ugd, bool is_free_all_peers)
 688 {
 689         __FUNC_ENTER__;
 690
 691         int count = 0;
 692         device_type_s *device = NULL;
 693         Evas_Object *genlist = NULL;
 694         Elm_Object_Item *item = NULL;
 695         int res = 0;
 696
 697         genlist = ugd->multiconn_view_genlist;
 698         if (ugd->multiconn_view_genlist == NULL) {
 699                 return 0;
 700         }
 701
 702         if (is_free_all_peers) {
 703                 wfd_free_multiconnect_device(ugd);
 704         }
 705
 706         GList *iterator = NULL;
 707         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 708                 device = (device_type_s *)iterator->data;
 709                 if (device->is_connected == FALSE && device->is_group_owner == FALSE) {
 710                         count++;
 711                 }
 712         }
 713
 714         if (count == 0) {
 715                 DBG(LOG_INFO, "There are No peers\n");
 716                 if (!ugd->mcview_title_item) {
 717                         ugd->mcview_title_item = elm_genlist_item_append(genlist, &multi_view_title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 718                         if(ugd->mcview_title_item != NULL)
 719                                 elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 720                 } else {
 721                         wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 722                 }
 723                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 724                 ugd->is_select_all_checked = FALSE;
 725                 wfd_free_multiconnect_device(ugd);
 726                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 727         } else {
 728                 WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 729                 wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 730
 731                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 732                         device = (device_type_s *)iterator->data;
 733                         if (device->is_connected == FALSE && device->is_group_owner == FALSE) {
 734                                 if (!find_peer_in_glist(ugd->multi_conn_dev_list_start, device->mac_addr)) {
 735                                         item = get_insert_postion(device, ugd->mcview_title_item, ugd->gl_available_dev_cnt_at_multiconn_view);
 736                                         res = insert_gl_item(genlist, item, &device_itc, &ugd->multi_conn_dev_list_start,
 737                                                                 device, _wfd_gl_multi_sel_cb);
 738                                         if (res != 0) {
 739                                                 break;
 740                                         }
 741                                         elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 742                                         ugd->is_select_all_checked = FALSE;
 743
 744                                         ugd->gl_available_dev_cnt_at_multiconn_view++;
 745                                 }
 746                         }
 747                 }
 748         }
 749         ugd->is_multi_check_all_selected = FALSE;
 750
 751         __FUNC_EXIT__;
 752         return 0;
 753 }
 754
 755 void wfd_genlist_select_all_check_changed_cb(void *data, Evas_Object * obj, void *event_info)
 756 {
 757         __FUNC_ENTER__;
 758         Elm_Object_Item *item = NULL;
 759         Evas_Object *chk_box = NULL;
 760         Evas_Object *content = NULL;
 761         const char *object_type;
 762         Eina_Bool state;
 763
 764
 765         struct ug_data *ugd = (struct ug_data *)data;
 766         if (NULL == ugd || NULL == obj) {
 767                 DBG(LOG_ERROR, "NULL parameters.\n");
 768                 return;
 769         }
 770
 771         if (ugd->multi_conn_dev_list_start == NULL) {
 772                 elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 773                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 774                 ugd->is_select_all_checked = FALSE;
 775
 776                 DBG(LOG_INFO, "No devices in multi-connect view.\n");
 777                 return;
 778         }
 779
 780         device_type_s *peer = ugd->multi_conn_dev_list_start;
 781         elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 782
 783
 784         object_type = evas_object_type_get(obj);
 785          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 786                 state = elm_check_state_get(ugd->select_all_icon);
 787                 elm_check_state_set(ugd->select_all_icon, !state);
 788                 ugd->is_select_all_checked = !state;
 789         }
 790
 791         state = elm_check_state_get(ugd->select_all_icon);
 792         DBG(LOG_INFO, "state = %d",state);
 793         if (state == EINA_TRUE) {
 794                 if (ugd->is_multi_check_all_selected == FALSE) {
 795                         int sel_count = 0;
 796                         while (peer != NULL) {
 797                                 peer->dev_sel_state = TRUE;
 798                                 item = peer->gl_item;
 799                                 content = elm_object_item_part_content_get(item, "elm.icon.2");
 800                                 chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 801                                 elm_check_state_set(chk_box, TRUE);
 802                                 sel_count++;
 803                                 peer = peer->next;
 804                         }
 805                         ugd->is_multi_check_all_selected = TRUE;
 806
 807                         char title[MAX_POPUP_TEXT_SIZE] = {0};
 808                         snprintf(title, MAX_POPUP_TEXT_SIZE,
 809                                 D_("IDS_ST_HEADER_PD_SELECTED"), sel_count);
 810                         wfd_naviframe_title_set(ugd, title);
 811
 812                         if (ugd->multiconn_layout) {
 813                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 814                                         "IDS_WIFI_SK_CONNECT", TRUE);
 815                         }
 816                 }
 817         } else {
 818                 while (peer != NULL) {
 819                         peer->dev_sel_state = FALSE;
 820                         item = peer->gl_item;
 821                         content = elm_object_item_part_content_get(item, "elm.icon.2");
 822                         chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 823                         elm_check_state_set(chk_box, FALSE);
 824                         peer = peer->next;
 825                 }
 826                 ugd->is_multi_check_all_selected = FALSE;
 827                 wfd_naviframe_title_set(ugd,
 828                         D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 829
 830                 if (ugd->multiconn_layout) {
 831                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 832                                 "IDS_WIFI_SK_CONNECT", FALSE);
 833                 }
 834         }
 835 }
 836
 837 /**
 838  *      This function let the ug call it when click 'scan' button
 839  *      @return   void
 840  *      @param[in] data the pointer to the main data structure
 841  *      @param[in] obj the pointer to the evas object
 842  *      @param[in] event_info the pointer to the event information
 843  */
 844 void _multi_scan_btn_cb(void *data, Evas_Object *obj, void *event_info)
 845 {
 846         __FUNC_ENTER__;
 847         int ret = -1;
 848         const char *btn_text = NULL;
 849         device_type_s *peer = NULL;
 850         struct ug_data *ugd = (struct ug_data *) data;
 851
 852         if (NULL == ugd) {
 853                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 854                 return;
 855         }
 856
 857         if (ugd->multiconn_conn_btn) {
 858                 peer = ugd->multi_conn_dev_list_start;
 859                 while (peer) {
 860                         if(peer->dev_sel_state) {
 861                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", TRUE);
 862                                 break;
 863                         }
 864                         peer = peer->next;
 865                 }
 866                 if (!peer) {
 867                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", FALSE);
 868                 }
 869         }
 870
 871         btn_text = elm_object_text_get(ugd->multiconn_scan_stop_btn);
 872         if (NULL == btn_text) {
 873                 DBG(LOG_ERROR, "Incorrect button text(NULL)\n");
 874                 return;
 875         }
 876
 877         if (0 == strcmp(btn_text, D_("IDS_WIFI_SK4_SCAN"))) {
 878                 wfd_refresh_wifi_direct_state(ugd);
 879                 DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status);
 880
 881                 /* if connected, show the popup*/
 882                 if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) {
 883                         wfd_ug_act_popup(ugd, D_("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN);
 884                 } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) {
 885                         wfd_client_switch_on(ugd);
 886                         __FUNC_EXIT__;
 887                         return;
 888                 } else {
 889                         WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 890                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 891                         ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 892                         if (ret != WIFI_DIRECT_ERROR_NONE) {
 893                                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 894                                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 895                                 wifi_direct_cancel_discovery();
 896                         }
 897                 }
 898                 elm_object_domain_translatable_text_set(ugd->multiconn_scan_stop_btn,
 899                                 PACKAGE, "IDS_WIFI_SK_STOP");
 900         } else if (0 == strcmp(btn_text, D_("IDS_WIFI_SK_STOP"))) {
 901                 DBG(LOG_INFO, "Stop pressed.\n");
 902                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 903                 wfd_cancel_progressbar_stop_timer(ugd);
 904                 wfd_delete_progressbar_cb(ugd);
 905                 wfd_cancel_not_alive_delete_timer(ugd);
 906         }
 907
 908         __FUNC_EXIT__;
 909         return;
 910 }
 911
 912 /**
 913  *      This function let the ug create the view for multi connection
 914  *      @return   void
 915  *      @param[in] ugd the pointer to the main data structure
 916  */
 917 void wfd_create_multiconnect_view(struct ug_data *ugd)
 918 {
 919         __FUNC_ENTER__;
 920
 921         Evas_Object *genlist = NULL;
 922         Elm_Object_Item *navi_item = NULL;
 923         Evas_Object *btn1 = NULL;
 924         Evas_Object *btn2 = NULL;
 925         Evas_Object *layout = NULL;
 926
 927         if (ugd == NULL) {
 928                 DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 929                 return;
 930         }
 931
 932         device_itc.item_style = WFD_GENLIST_1LINE_TEXT_ICON_STYLE;
 933         device_itc.func.text_get = _wfd_gl_device_label_get;
 934         device_itc.func.content_get = _wfd_gl_device_icon_get;
 935         device_itc.func.state_get = NULL;
 936         device_itc.func.del = NULL;
 937
 938         /* Create layout */
 939         layout = elm_layout_add(ugd->naviframe);
 940         elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "bottom_btn");
 941         ugd->multiconn_layout = layout;
 942
 943
 944         genlist = elm_genlist_add(ugd->multiconn_layout);
 945         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 946         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 947         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 948         evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd);
 949
 950         elm_object_part_content_set(layout, "elm.swallow.content", genlist);
 951         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 952 #if defined(GENLIST_REALIZATION_MOTE_SET)
 953         elm_genlist_realization_mode_set(genlist, TRUE);
 954 #endif
 955
 956         ugd->multiconn_view_genlist = genlist;
 957         ugd->mcview_title_item = NULL;
 958         ugd->mcview_nodevice_item = NULL;
 959         ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 960         evas_object_show(genlist);
 961
 962         navi_item = elm_naviframe_item_push(ugd->naviframe,
 963                 "IDS_DLNA_HEADER_SELECT_DEVICES_ABB", NULL, NULL, layout, NULL);
 964         elm_object_item_domain_text_translatable_set(navi_item, PACKAGE, EINA_TRUE);
 965
 966         elm_naviframe_item_pop_cb_set(navi_item, _multiconnect_view_pop_cb, (void *)ugd);
 967         ugd->select_all_view_genlist = elm_genlist_item_append(genlist,
 968                         &select_all_multi_connect_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE,
 969                         wfd_genlist_select_all_check_changed_cb, (void *)ugd );
 970
 971
 972         btn1 = elm_button_add(ugd->multiconn_layout);
 973         elm_object_style_set(btn1, "bottom");
 974         if (ugd->view_type && g_strcmp0(D_(ugd->view_type),
 975                 D_("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) {
 976                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 977                                 "IDS_WIFI_SK4_SCAN");
 978         } else {
 979                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 980                                 "IDS_WIFI_SK_STOP");
 981         }
 982         elm_object_part_content_set(ugd->multiconn_layout, "button.prev", btn1);
 983         evas_object_smart_callback_add(btn1, "clicked",_multi_scan_btn_cb, (void *)ugd);
 984         evas_object_show(btn1);
 985         ugd->multiconn_scan_stop_btn = btn1;
 986
 987         btn2 = elm_button_add(ugd->multiconn_layout);
 988         elm_object_style_set(btn2, "bottom");
 989         elm_object_domain_translatable_text_set(btn2, PACKAGE,
 990                         "IDS_WIFI_SK_CONNECT");
 991         elm_object_part_content_set(ugd->multiconn_layout, "button.next", btn2);
 992         evas_object_smart_callback_add(btn2, "clicked",_connect_btn_cb, (void *)ugd);
 993         evas_object_show(btn2);
 994         ugd->multiconn_conn_btn = btn2;
 995         elm_object_disabled_set(ugd->multiconn_conn_btn, EINA_TRUE);
 996
 997         ugd->multi_navi_item = navi_item;
 998
 999         wfd_update_multiconnect_device(ugd, true);
1000
1001         __FUNC_EXIT__;
1002 }