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.1 (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         ugd->raw_multi_selected_peer_cnt = 0;
 150         ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE;
 151
 152         __FUNC_EXIT__;
 153
 154 }
 155
 156 /**
 157  *      This function let the ug stop to connect to selected peer
 158  *      @return   If success, return 0, else return -1
 159  *      @param[in] data the pointer to the main data structure
 160  */
 161 int wfd_stop_multi_connect(void *data)
 162 {
 163         __FUNC_ENTER__;
 164         struct ug_data *ugd = (struct ug_data *)data;
 165
 166         if (ugd->act_popup) {
 167                 evas_object_del(ugd->act_popup);
 168                 ugd->act_popup = NULL;
 169         }
 170
 171         /* change the title of failed peers */
 172         ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_COMPLETED;
 173         wfd_ug_view_refresh_glitem(ugd->multi_connect_wfd_item);
 174         wfd_ug_update_toolbar(ugd);
 175
 176         if (ugd->gl_connected_peer_cnt > 0)
 177                 wfd_client_set_p2p_group_owner_intent(7);
 178         else
 179                 wifi_direct_destroy_group();
 180
 181         if (ugd->timer_multi_reset > 0)
 182                 g_source_remove(ugd->timer_multi_reset);
 183
 184         /* after 30s, remove the failed peers */
 185         ugd->timer_multi_reset = g_timeout_add(30000 /*ms*/,
 186                 __wfd_multi_connect_reset_cb, ugd);
 187
 188         if (ugd->g_source_multi_connect_next > 0)
 189                 g_source_remove(ugd->g_source_multi_connect_next);
 190
 191         ugd->g_source_multi_connect_next = 0;
 192
 193         /*when multi-connect end and auto_exit is true, exit UG*/
 194         if (ugd->is_auto_exit)
 195                 _wfd_ug_auto_exit(ugd);
 196
 197         __FUNC_EXIT__;
 198         return 0;
 199 }
 200
 201 /**
 202  *      This function let the ug start to connect the selected peers
 203  *      @return   If success, return 0, else return -1
 204  *      @param[in] data the pointer to the main data structure
 205  */
 206 int wfd_start_multi_connect(void *data)
 207 {
 208         __FUNC_ENTER__;
 209         struct ug_data *ugd = (struct ug_data *)data;
 210         int res;
 211
 212         if (ugd->raw_multi_selected_peer_cnt > 0) {
 213                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 214
 215                 res = wfd_client_group_add();
 216                 if (res == -1) {
 217                         DBG(LOG_ERROR, "Failed to add group");
 218                         wfd_free_multi_selected_peers(ugd);
 219
 220                         __FUNC_EXIT__;
 221                         return -1;
 222                 }
 223         } else {
 224                 DBG(LOG_INFO, "No selected peers.\n");
 225                 return -1;
 226         }
 227
 228         __FUNC_EXIT__;
 229         return 0;
 230 }
 231
 232 void wfd_sort_multi_selected_peers(struct ug_data *ugd)
 233 {
 234         __FUNC_ENTER__;
 235         int i = 0;
 236         int j = 0;
 237         device_type_s peer;
 238
 239         for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
 240                 for (j = 0; j < ugd->raw_multi_selected_peer_cnt-i-1; j++) {
 241                         if (strcasecmp(ugd->raw_multi_selected_peers[j].ssid, ugd->raw_multi_selected_peers[j + 1].ssid) > 0) {
 242                                 peer = ugd->raw_multi_selected_peers[j];
 243                                 ugd->raw_multi_selected_peers[j] = ugd->raw_multi_selected_peers[j + 1];
 244                                 ugd->raw_multi_selected_peers[j + 1] = peer;
 245                         }
 246                 }
 247         }
 248         __FUNC_EXIT__;
 249 }
 250
 251 /**
 252  *      This function let the ug connect to the next selected peer automatically
 253  *      @return   If stop the timer, return false, else return true
 254  *      @param[in] data the pointer to the main data structure
 255  */
 256 gboolean wfd_multi_connect_next_cb(void *data)
 257 {
 258         __FUNC_ENTER__;
 259         struct ug_data *ugd = (struct ug_data *)data;
 260         int i;
 261         int res;
 262
 263         // Reset g_source handler..
 264         if (ugd->g_source_multi_connect_next > 0)
 265                 g_source_remove(ugd->g_source_multi_connect_next);
 266
 267         ugd->g_source_multi_connect_next = 0;
 268
 269         if (ugd->raw_multi_selected_peer_cnt > 0) {
 270                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 271                 for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) {
 272                         if (ugd->raw_multi_selected_peers[i].conn_status == PEER_CONN_STATUS_WAIT_FOR_CONNECT) {
 273                                 ugd->mac_addr_connecting = ugd->raw_multi_selected_peers[i].mac_addr;
 274                                 res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr);
 275                                 if (res == -1) {
 276                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT;
 277                                 } else {
 278                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING;
 279                                         break;
 280                                 }
 281                         }
 282                 }
 283
 284                 if (i >= ugd->raw_multi_selected_peer_cnt) {
 285                         // All selected peers are touched.
 286                         DBG(LOG_INFO, "Stop Multi Connect...\n");
 287                         wfd_stop_multi_connect(ugd);
 288                 }
 289         } else {
 290                 DBG(LOG_INFO, "No selected peers.\n");
 291         }
 292
 293         __FUNC_EXIT__;
 294         return false;
 295 }
 296
 297 /**
 298  *      This function let the ug call it when click 'connect' button in multi connect view
 299  *      @return   void
 300  *      @param[in] data the pointer to the main data structure
 301  *      @param[in] obj the pointer to the evas object
 302  *      @param[in] event_info the pointer to the event information
 303  */
 304 void _connect_btn_cb(void *data, Evas_Object *obj, void *event_info)
 305 {
 306         __FUNC_ENTER__;
 307         struct ug_data *ugd = (struct ug_data *)data;
 308         int count = 0;
 309         char popup_text[MAX_POPUP_TEXT_SIZE] = {0};
 310         device_type_s *peer = NULL;
 311         char *format_str = NULL;
 312
 313         peer = ugd->multi_conn_dev_list_start;
 314         while (peer != NULL) {
 315                 if (peer->dev_sel_state)
 316                         count++;
 317
 318                 peer = peer->next;
 319         }
 320         DBG(LOG_INFO, "MultiSelected Peer Count: %d", count);
 321
 322         /* if more than 7 device selected, show the popup */
 323         if (count > MAX_CONNECTED_PEER_NUM) {
 324                 format_str = D_("IDS_ST_POP_YOU_CAN_CONNECT_UP_TO_PD_DEVICES_AT_THE_SAME_TIME");
 325                 snprintf(popup_text, MAX_POPUP_TEXT_SIZE, format_str, MAX_CONNECTED_PEER_NUM);
 326                 wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP);
 327                 __FUNC_EXIT__;
 328                 return;
 329         }
 330
 331         peer = ugd->multi_conn_dev_list_start;
 332         count = 0;
 333         while (peer != NULL) {
 334                 if (peer->dev_sel_state) {
 335                         DBG(LOG_INFO, "peer_name[%s] select state[%d]", peer->ssid, peer->dev_sel_state);
 336                         memcpy(&ugd->raw_multi_selected_peers[count], peer, sizeof(device_type_s));
 337                         ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT;
 338                         count++;
 339                 }
 340                 peer = peer->next;
 341         }
 342
 343         DBG(LOG_INFO, "MultiSelected Peer Count2: %d", count);
 344         ugd->raw_multi_selected_peer_cnt = count;
 345         wfd_sort_multi_selected_peers(ugd);
 346         wfd_cancel_progressbar_stop_timer(ugd);
 347         wfd_cancel_not_alive_delete_timer(ugd);
 348
 349         /* start multi connection */
 350         wfd_start_multi_connect(ugd);
 351
 352         elm_naviframe_item_pop(ugd->naviframe);
 353
 354         __FUNC_EXIT__;
 355         return;
 356 }
 357
 358 void wfd_naviframe_title_set(struct ug_data *ugd, const char *title)
 359 {
 360         if (!ugd || !ugd->multi_navi_item) {
 361                 DBG(LOG_ERROR, "The param is NULL\n");
 362                 return;
 363         }
 364
 365         elm_object_item_part_text_set(ugd->multi_navi_item, "default", title);
 366 }
 367
 368 /**
 369  *      This function let the ug call it when click the peer in multi connect view
 370  *      @return   void
 371  *      @param[in] data the pointer to the main data structure
 372  *      @param[in] obj the pointer to the evas object
 373  *      @param[in] event_info the pointer to the event information
 374  */
 375 static void _wfd_gl_multi_sel_cb(void *data, Evas_Object *obj, void *event_info)
 376 {
 377         __FUNC_ENTER__;
 378
 379         int sel_count = 0;
 380         bool is_sel = FALSE;
 381
 382         Eina_Bool state = EINA_FALSE;
 383         Evas_Object *chk_box = NULL;
 384         const char *object_type = NULL;
 385         struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data();
 386         device_type_s *peer = (device_type_s *)data;
 387         char *format_str = NULL;
 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         object_type = evas_object_type_get(obj);
 406          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 407                 Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 408                 if (item)
 409                         elm_genlist_item_selected_set(item, EINA_FALSE);
 410
 411                 DBG(LOG_INFO, "State elm_genlist %d\n", state);
 412                 elm_check_state_set(chk_box, !state);
 413                 peer->dev_sel_state = !state;
 414         } else if (g_strcmp0(object_type, "elm_check") == 0) {
 415                 DBG(LOG_INFO, "elm_check state; %d\n", peer->dev_sel_state);
 416                 peer->dev_sel_state = !peer->dev_sel_state;
 417         }
 418
 419         DBG(LOG_INFO, "ptr->dev_sel_state = %d \n", peer->dev_sel_state);
 420         DBG_SECURE(LOG_INFO, "ptr->peer.mac_addr = ["MACSECSTR"]\n",
 421                 MAC2SECSTR(peer->mac_addr));
 422
 423         peer = ugd->multi_conn_dev_list_start;
 424         while (peer != NULL) {
 425                 if (peer->dev_sel_state) {
 426                         is_sel = TRUE;
 427                         sel_count++;
 428                 } else {
 429                         ugd->is_multi_check_all_selected = FALSE;
 430                 }
 431                 peer = peer->next;
 432         }
 433
 434         if (is_sel) {
 435                 char title[MAX_POPUP_TEXT_SIZE] = {0};
 436                 format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 437                 snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, 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         if (!strcmp("elm.text", part)) {
 477                 if (strlen(peer->ssid) != 0) {
 478                         ssid = elm_entry_utf8_to_markup(peer->ssid);
 479                         if (NULL == ssid) {
 480                                 DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n");
 481                                 __FUNC_EXIT__;
 482                                 return NULL;
 483                         }
 484                         __FUNC_EXIT__;
 485                         return ssid;
 486                 }
 487         }
 488         return NULL;
 489 }
 490
 491 /**
 492  *      This function let the ug get the icon path of peer
 493  *      @return   the  icon path of titile
 494  *      @param[in] peer the pointer to the peer
 495  */
 496 static char *__wfd_get_device_icon_path(device_type_s *peer)
 497 {
 498         __FUNC_ENTER__;
 499         char *img_name = NULL;
 500
 501         switch (peer->category) {
 502         case WFD_DEVICE_TYPE_COMPUTER:
 503                 img_name = WFD_ICON_DEVICE_COMPUTER;
 504                 break;
 505         case WFD_DEVICE_TYPE_INPUT_DEVICE:
 506                 img_name = WFD_ICON_DEVICE_INPUT_DEVICE;
 507                 break;
 508         case WFD_DEVICE_TYPE_PRINTER:
 509                 img_name = WFD_ICON_DEVICE_PRINTER;
 510                 break;
 511         case WFD_DEVICE_TYPE_CAMERA:
 512                 img_name = WFD_ICON_DEVICE_CAMERA;
 513                 break;
 514         case WFD_DEVICE_TYPE_STORAGE:
 515                 img_name = WFD_ICON_DEVICE_STORAGE;
 516                 break;
 517         case WFD_DEVICE_TYPE_NW_INFRA:
 518                 img_name = WFD_ICON_DEVICE_NETWORK_INFRA;
 519                 break;
 520         case WFD_DEVICE_TYPE_DISPLAYS:
 521                 img_name = WFD_ICON_DEVICE_DISPLAY;
 522                 break;
 523         case WFD_DEVICE_TYPE_MM_DEVICES:
 524                 img_name = WFD_ICON_DEVICE_MULTIMEDIA;
 525                 break;
 526         case WFD_DEVICE_TYPE_GAME_DEVICES:
 527                 img_name = WFD_ICON_DEVICE_GAMING;
 528                 break;
 529         case WFD_DEVICE_TYPE_TELEPHONE:
 530                 img_name = WFD_ICON_DEVICE_TELEPHONE;
 531                 break;
 532         case WFD_DEVICE_TYPE_AUDIO:
 533                 img_name = WFD_ICON_DEVICE_HEADSET;
 534                 break;
 535         default:
 536                 img_name = WFD_ICON_DEVICE_UNKNOWN;
 537                 break;
 538         }
 539         return img_name;
 540 }
 541
 542 /**
 543  *      This function let the ug get the icon of peer
 544  *      @return   the icon of peer
 545  *      @param[in] data the pointer to the main data structure
 546  *      @param[in] obj the pointer to the evas object
 547  *      @param[in] part the pointer to the part of item
 548  */
 549 static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part)
 550 {
 551         __FUNC_ENTER__;
 552         char *img_name = NULL;
 553         device_type_s *peer = (device_type_s *) data;
 554         Evas_Object *icon = NULL;
 555         Evas_Object *icon_layout = NULL;
 556
 557         DBG(LOG_INFO, "Part %s", part);
 558
 559         if (!strcmp("elm.swallow.icon", part)) {
 560                 DBG(LOG_INFO, "Part %s", part);
 561                 icon_layout = elm_layout_add(obj);
 562                 elm_layout_theme_set(icon_layout, "layout", "list/B/type.3", "default");
 563                 img_name = __wfd_get_device_icon_path(peer);
 564                 icon = elm_image_add(icon_layout);
 565                 elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name);
 566                 evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 567                 evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 568                 evas_object_color_set(icon, 2, 61, 132, 204);
 569                 evas_object_show(icon);
 570                 evas_object_propagate_events_set(icon, EINA_FALSE);
 571                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 572         } else if (!strcmp("elm.swallow.end", part)) {
 573                 icon_layout = elm_layout_add(obj);
 574                 elm_layout_theme_set(icon_layout, "layout", "list/C/type.2", "default");
 575                 DBG(LOG_INFO, "Part %s", part);
 576                 icon = elm_check_add(icon_layout);
 577                 elm_object_style_set(icon, "default/genlist");
 578                 evas_object_propagate_events_set(icon, EINA_FALSE);
 579                 if (peer->dev_sel_state == EINA_TRUE)
 580                         elm_check_state_set(icon, EINA_TRUE);
 581
 582                 evas_object_smart_callback_add(icon,
 583                         "changed", _wfd_gl_multi_sel_cb, (void *)data);
 584                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 585         }
 586
 587         if (icon_layout)
 588                 evas_object_show(icon_layout);
 589
 590         return icon_layout;
 591 }
 592
 593 /**
 594  *      This function let the ug call it when unresized event is received
 595 */
 596 static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info)
 597 {
 598         __FUNC_ENTER__;
 599         struct ug_data *ugd = (struct ug_data *)data;
 600         int sel_count = 0;
 601         bool is_sel = FALSE;
 602         device_type_s *peer = NULL;
 603         char *format_str = 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                 format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 624                 snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, sel_count);
 625                 wfd_naviframe_title_set(ugd, title);
 626         } else {
 627                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 628         }
 629
 630         if (ugd->multiconn_conn_btn) {
 631                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 632                         "IDS_WIFI_SK_CONNECT", is_sel);
 633         }
 634
 635         __FUNC_EXIT__;
 636 }
 637
 638 /**
 639  *      This function let the ug free the multi connect devices
 640  *      @return   0
 641  *      @param[in] data the pointer to the main data structure
 642  */
 643 int wfd_free_multiconnect_device(struct ug_data *ugd)
 644 {
 645         __FUNC_ENTER__;
 646
 647         if (ugd->multiconn_view_genlist == NULL)
 648                 return 0;
 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         if (is_free_all_peers)
 702                 wfd_free_multiconnect_device(ugd);
 703
 704         GList *iterator = NULL;
 705         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 706                 device = (device_type_s *)iterator->data;
 707                 if (device->is_connected == FALSE && device->is_group_owner == FALSE)
 708                         count++;
 709         }
 710
 711         if (count == 0) {
 712                 DBG(LOG_INFO, "There are No peers\n");
 713                 if (!ugd->mcview_title_item) {
 714                         ugd->mcview_title_item = elm_genlist_item_append(genlist, &multi_view_title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 715                         if (ugd->mcview_title_item != NULL)
 716                                 elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 717                 } else {
 718                         wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 719                 }
 720                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 721                 ugd->is_select_all_checked = FALSE;
 722                 wfd_free_multiconnect_device(ugd);
 723                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 724         } else {
 725                 WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 726                 wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 727
 728                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 729                         device = (device_type_s *)iterator->data;
 730                         if (device->is_connected == FALSE && device->is_group_owner == FALSE) {
 731                                 if (!find_peer_in_glist(ugd->multi_conn_dev_list_start, device->mac_addr)) {
 732                                         item = get_insert_postion(device, ugd->mcview_title_item, ugd->gl_available_dev_cnt_at_multiconn_view);
 733                                         res = insert_gl_item(genlist, item, &device_itc, &ugd->multi_conn_dev_list_start,
 734                                                                 device, _wfd_gl_multi_sel_cb);
 735                                         if (res != 0)
 736                                                 break;
 737
 738                                         elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 739                                         ugd->is_select_all_checked = FALSE;
 740
 741                                         ugd->gl_available_dev_cnt_at_multiconn_view++;
 742                                 }
 743                         }
 744                 }
 745         }
 746         ugd->is_multi_check_all_selected = FALSE;
 747
 748         __FUNC_EXIT__;
 749         return 0;
 750 }
 751
 752 void wfd_genlist_select_all_check_changed_cb(void *data, Evas_Object * obj, void *event_info)
 753 {
 754         __FUNC_ENTER__;
 755         Elm_Object_Item *item = NULL;
 756         Evas_Object *chk_box = NULL;
 757         Evas_Object *content = NULL;
 758         const char *object_type;
 759         Eina_Bool state;
 760         char *format_str = NULL;
 761
 762
 763         struct ug_data *ugd = (struct ug_data *)data;
 764         if (NULL == ugd || NULL == obj) {
 765                 DBG(LOG_ERROR, "NULL parameters.\n");
 766                 return;
 767         }
 768
 769         if (ugd->multi_conn_dev_list_start == NULL) {
 770                 elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 771                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 772                 ugd->is_select_all_checked = FALSE;
 773
 774                 DBG(LOG_INFO, "No devices in multi-connect view.\n");
 775                 return;
 776         }
 777
 778         device_type_s *peer = ugd->multi_conn_dev_list_start;
 779         elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 780
 781
 782         object_type = evas_object_type_get(obj);
 783          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 784                 state = elm_check_state_get(ugd->select_all_icon);
 785                 elm_check_state_set(ugd->select_all_icon, !state);
 786                 ugd->is_select_all_checked = !state;
 787         }
 788
 789         state = elm_check_state_get(ugd->select_all_icon);
 790         DBG(LOG_INFO, "state = %d", state);
 791         if (state == EINA_TRUE) {
 792                 if (ugd->is_multi_check_all_selected == FALSE) {
 793                         int sel_count = 0;
 794                         while (peer != NULL) {
 795                                 peer->dev_sel_state = TRUE;
 796                                 item = peer->gl_item;
 797                                 content = elm_object_item_part_content_get(item, "elm.icon.2");
 798                                 chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 799                                 elm_check_state_set(chk_box, TRUE);
 800                                 sel_count++;
 801                                 peer = peer->next;
 802                         }
 803                         ugd->is_multi_check_all_selected = TRUE;
 804
 805                         char title[MAX_POPUP_TEXT_SIZE] = {0};
 806                         format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 807                         snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, sel_count);
 808                         wfd_naviframe_title_set(ugd, title);
 809
 810                         if (ugd->multiconn_layout) {
 811                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 812                                         "IDS_WIFI_SK_CONNECT", TRUE);
 813                         }
 814                 }
 815         } else {
 816                 while (peer != NULL) {
 817                         peer->dev_sel_state = FALSE;
 818                         item = peer->gl_item;
 819                         content = elm_object_item_part_content_get(item, "elm.icon.2");
 820                         chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 821                         elm_check_state_set(chk_box, FALSE);
 822                         peer = peer->next;
 823                 }
 824                 ugd->is_multi_check_all_selected = FALSE;
 825                 wfd_naviframe_title_set(ugd,
 826                         D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 827
 828                 if (ugd->multiconn_layout) {
 829                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 830                                 "IDS_WIFI_SK_CONNECT", FALSE);
 831                 }
 832         }
 833 }
 834
 835 /**
 836  *      This function let the ug call it when click 'scan' button
 837  *      @return   void
 838  *      @param[in] data the pointer to the main data structure
 839  *      @param[in] obj the pointer to the evas object
 840  *      @param[in] event_info the pointer to the event information
 841  */
 842 void _multi_scan_btn_cb(void *data, Evas_Object *obj, void *event_info)
 843 {
 844         __FUNC_ENTER__;
 845         int ret = -1;
 846         const char *btn_text = NULL;
 847         device_type_s *peer = NULL;
 848         struct ug_data *ugd = (struct ug_data *) data;
 849
 850         if (NULL == ugd) {
 851                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 852                 return;
 853         }
 854
 855         if (ugd->multiconn_conn_btn) {
 856                 peer = ugd->multi_conn_dev_list_start;
 857                 while (peer) {
 858                         if (peer->dev_sel_state) {
 859                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", TRUE);
 860                                 break;
 861                         }
 862                         peer = peer->next;
 863                 }
 864                 if (!peer)
 865                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", FALSE);
 866         }
 867
 868         btn_text = elm_object_text_get(ugd->multiconn_scan_stop_btn);
 869         if (NULL == btn_text) {
 870                 DBG(LOG_ERROR, "Incorrect button text(NULL)\n");
 871                 return;
 872         }
 873
 874         if (0 == strcmp(btn_text, D_("IDS_WIFI_SK4_SCAN"))) {
 875                 wfd_refresh_wifi_direct_state(ugd);
 876                 DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status);
 877
 878                 /* if connected, show the popup*/
 879                 if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) {
 880                         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);
 881                 } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) {
 882                         wfd_client_switch_on(ugd);
 883                         __FUNC_EXIT__;
 884                         return;
 885                 } else {
 886                         WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 887                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 888                         ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 889                         if (ret != WIFI_DIRECT_ERROR_NONE) {
 890                                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 891                                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 892                                 wifi_direct_cancel_discovery();
 893                         }
 894                 }
 895                 elm_object_domain_translatable_text_set(ugd->multiconn_scan_stop_btn,
 896                                 PACKAGE, "IDS_WIFI_SK_STOP");
 897         } else if (0 == strcmp(btn_text, D_("IDS_WIFI_SK_STOP"))) {
 898                 DBG(LOG_INFO, "Stop pressed.\n");
 899                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 900                 wfd_cancel_progressbar_stop_timer(ugd);
 901                 wfd_delete_progressbar_cb(ugd);
 902                 wfd_cancel_not_alive_delete_timer(ugd);
 903         }
 904
 905         __FUNC_EXIT__;
 906         return;
 907 }
 908
 909 /**
 910  *      This function let the ug create the view for multi connection
 911  *      @return   void
 912  *      @param[in] ugd the pointer to the main data structure
 913  */
 914 void wfd_create_multiconnect_view(struct ug_data *ugd)
 915 {
 916         __FUNC_ENTER__;
 917
 918         Evas_Object *genlist = NULL;
 919         Elm_Object_Item *navi_item = NULL;
 920         Evas_Object *btn1 = NULL;
 921         Evas_Object *btn2 = NULL;
 922         Evas_Object *layout = NULL;
 923
 924         if (ugd == NULL) {
 925                 DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 926                 return;
 927         }
 928
 929         device_itc.item_style = WFD_GENLIST_1LINE_TEXT_ICON_STYLE;
 930         device_itc.func.text_get = _wfd_gl_device_label_get;
 931         device_itc.func.content_get = _wfd_gl_device_icon_get;
 932         device_itc.func.state_get = NULL;
 933         device_itc.func.del = NULL;
 934
 935         /* Create layout */
 936         layout = elm_layout_add(ugd->naviframe);
 937         elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "bottom_btn");
 938         ugd->multiconn_layout = layout;
 939
 940
 941         genlist = elm_genlist_add(ugd->multiconn_layout);
 942         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 943         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 944         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 945         evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd);
 946
 947         elm_object_part_content_set(layout, "elm.swallow.content", genlist);
 948         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 949 #if defined(GENLIST_REALIZATION_MOTE_SET)
 950         elm_genlist_realization_mode_set(genlist, TRUE);
 951 #endif
 952
 953         ugd->multiconn_view_genlist = genlist;
 954         ugd->mcview_title_item = NULL;
 955         ugd->mcview_nodevice_item = NULL;
 956         ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 957         evas_object_show(genlist);
 958
 959         navi_item = elm_naviframe_item_push(ugd->naviframe,
 960                 "IDS_DLNA_HEADER_SELECT_DEVICES_ABB", NULL, NULL, layout, NULL);
 961         elm_object_item_domain_text_translatable_set(navi_item, PACKAGE, EINA_TRUE);
 962
 963         elm_naviframe_item_pop_cb_set(navi_item, _multiconnect_view_pop_cb, (void *)ugd);
 964         ugd->select_all_view_genlist = elm_genlist_item_append(genlist,
 965                         &select_all_multi_connect_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE,
 966                         wfd_genlist_select_all_check_changed_cb, (void *)ugd);
 967
 968
 969         btn1 = elm_button_add(ugd->multiconn_layout);
 970         elm_object_style_set(btn1, "bottom");
 971         if (ugd->view_type && g_strcmp0(D_(ugd->view_type),
 972                 D_("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) {
 973                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 974                                 "IDS_WIFI_SK4_SCAN");
 975         } else {
 976                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 977                                 "IDS_WIFI_SK_STOP");
 978         }
 979         elm_object_part_content_set(ugd->multiconn_layout, "button.prev", btn1);
 980         evas_object_smart_callback_add(btn1, "clicked", _multi_scan_btn_cb, (void *)ugd);
 981         evas_object_show(btn1);
 982         ugd->multiconn_scan_stop_btn = btn1;
 983
 984         btn2 = elm_button_add(ugd->multiconn_layout);
 985         elm_object_style_set(btn2, "bottom");
 986         elm_object_domain_translatable_text_set(btn2, PACKAGE,
 987                         "IDS_WIFI_SK_CONNECT");
 988         elm_object_part_content_set(ugd->multiconn_layout, "button.next", btn2);
 989         evas_object_smart_callback_add(btn2, "clicked", _connect_btn_cb, (void *)ugd);
 990         evas_object_show(btn2);
 991         ugd->multiconn_conn_btn = btn2;
 992         elm_object_disabled_set(ugd->multiconn_conn_btn, EINA_TRUE);
 993
 994         ugd->multi_navi_item = navi_item;
 995
 996         wfd_update_multiconnect_device(ugd, true);
 997
 998         __FUNC_EXIT__;
 999 }