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
  22 #include <assert.h>
  23 #include <glib.h>
  24
  25 #include <Elementary.h>
  26 #include <vconf.h>
  27 #include <ui-gadget-module.h>
  28 #include <wifi-direct.h>
  29
  30 #include "wfd_ug.h"
  31 #include "wfd_ug_view.h"
  32 #include "wfd_client.h"
  33
  34 Elm_Gen_Item_Class select_all_itc;
  35 Elm_Gen_Item_Class device_itc;
  36
  37
  38 void _multiconnect_view_back_btn_cb(void *data, Evas_Object * obj, void *event_info)
  39 {
  40     __FUNC_ENTER__;
  41     struct ug_data *ugd = (struct ug_data*) data;
  42
  43     if(!ugd)
  44     {
  45         DBG(LOG_ERROR, "The param is NULL\n");
  46         return;
  47     }
  48
  49     ugd->multiconn_view_genlist = NULL;
  50     elm_naviframe_item_pop(ugd->naviframe);
  51
  52     __FUNC_EXIT__;
  53     return;
  54 }
  55
  56 void reset_multi_conn_dev_list(void *data)
  57 {
  58         struct ug_data *ugd = (struct ug_data*) data;
  59         int i;
  60     for (i = 0; i < MAX_PEER_NUM; i++)
  61     {
  62         ugd->multi_conn_dev_list[i].dev_sel_state = FALSE;
  63         ugd->multi_conn_dev_list[i].peer.gl_item = NULL;
  64     }
  65     ugd->gl_available_dev_cnt_at_multiconn_view = 0;
  66 }
  67
  68 gboolean __wfd_multi_connect_reset_cb(void *data)
  69 {
  70     __FUNC_ENTER__;
  71     struct ug_data *ugd = (struct ug_data*) data;
  72
  73     ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE;
  74     ugd->raw_multi_selected_peer_cnt = 0;
  75         wfd_ug_view_update_peers(ugd);
  76
  77         __FUNC_EXIT__;
  78         return false;
  79 }
  80
  81 int wfd_stop_multi_connect(void *data)
  82 {
  83     __FUNC_ENTER__;
  84     struct ug_data *ugd = (struct ug_data*) data;
  85
  86     ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_COMPLETED;
  87     wfd_client_set_p2p_group_owner_intent(7);
  88
  89     g_timeout_add(1000 /*ms*/, __wfd_multi_connect_reset_cb, ugd);
  90
  91     __FUNC_EXIT__;
  92         return 0;
  93 }
  94
  95 int wfd_start_multi_connect(void* data)
  96 {
  97     __FUNC_ENTER__;
  98     struct ug_data *ugd = (struct ug_data*) data;
  99         int i;
 100         int res;
 101
 102         if (ugd->raw_multi_selected_peer_cnt > 0)
 103         {
 104                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 105                 if (wfd_client_set_p2p_group_owner_intent(15) == WIFI_DIRECT_ERROR_NONE)
 106                 {
 107                         for (i=0;i<ugd->raw_multi_selected_peer_cnt; i++)
 108                         {
 109                                 res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr);
 110                                 if (res == -1)
 111                                 {
 112                                         DBG(LOG_VERBOSE, "Failed to connect [%s].\n", ugd->raw_multi_selected_peers[i].ssid);
 113                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT;
 114                                 }
 115                                 else
 116                                 {
 117                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING;
 118                                         break;
 119                                 }
 120                         }
 121
 122                         if (i >= ugd->raw_multi_selected_peer_cnt)
 123                         {
 124                                 wfd_client_set_p2p_group_owner_intent(7);
 125
 126                                 DBG(LOG_VERBOSE, "All connect trails are failed.\n");
 127                                 return -1;
 128                         }
 129                 }
 130                 else
 131                 {
 132                         // error popup...
 133                         DBG(LOG_VERBOSE, "Setting GO intent is failed.\n");
 134                         return -1;
 135                 }
 136
 137         }
 138         else
 139         {
 140                 DBG(LOG_VERBOSE, "No selected peers.\n");
 141                 return -1;
 142         }
 143
 144         __FUNC_EXIT__;
 145         return 0;
 146 }
 147
 148 gboolean wfd_multi_connect_next_cb(void* data)
 149 {
 150     __FUNC_ENTER__;
 151     struct ug_data *ugd = (struct ug_data*) data;
 152         int i;
 153         int res;
 154
 155         // Reset g_source handler..
 156         ugd->g_source_multi_connect_next = 0;
 157
 158         if (ugd->raw_multi_selected_peer_cnt > 0)
 159         {
 160                 ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS;
 161                 for (i=0;i<ugd->raw_multi_selected_peer_cnt; i++)
 162                 {
 163                         if (ugd->raw_multi_selected_peers[i].conn_status == PEER_CONN_STATUS_WAIT_FOR_CONNECT)
 164                         {
 165                                 res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr);
 166                                 if (res == -1)
 167                                 {
 168                                         DBG(LOG_VERBOSE, "Failed to connect [%s].\n", ugd->raw_multi_selected_peers[i].ssid);
 169                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT;
 170                                 }
 171                                 else
 172                                 {
 173                                         ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING;
 174                                         break;
 175                                 }
 176                         }
 177                 }
 178
 179                 if (i >= ugd->raw_multi_selected_peer_cnt)
 180                 {
 181                         // All selected peers are touched.
 182                         DBG(LOG_VERBOSE, "Stop Multi Connect...\n");
 183                         wfd_stop_multi_connect(ugd);
 184                 }
 185         }
 186         else
 187         {
 188                 DBG(LOG_VERBOSE, "No selected peers.\n");
 189                 return -1;
 190         }
 191
 192         __FUNC_EXIT__;
 193         return false;
 194 }
 195
 196
 197 void _connect_btn_cb(void *data, Evas_Object * obj, void *event_info)
 198 {
 199     __FUNC_ENTER__;
 200     struct ug_data *ugd = (struct ug_data*) data;
 201     int i = 0;
 202     int count = 0;
 203     char popup_text[MAX_POPUP_TEXT_SIZE] = {0};
 204     DBG(LOG_VERBOSE, "_connect_btn_cb \n");
 205
 206     for (i = 0; i < ugd->gl_available_peer_cnt ; i++)
 207     {
 208         if (TRUE == ugd->multi_conn_dev_list[i].dev_sel_state)
 209         {
 210                         DBG(LOG_VERBOSE, "ugd->peers[i].mac_addr = %s, i = %d\n", ugd->multi_conn_dev_list[i].peer.mac_addr, i);
 211
 212                         memcpy(&ugd->raw_multi_selected_peers[count], &ugd->multi_conn_dev_list[i].peer,sizeof(device_type_s));
 213                         ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT;
 214                         count++;
 215         }
 216     }
 217
 218     ugd->raw_multi_selected_peer_cnt = count;
 219
 220     /* if more than 7 device selected, show the popup */
 221     if (count > MAX_POPUP_PEER_NUM) {
 222                 snprintf(popup_text, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_MULTI_CONNECT"), count);
 223                 wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP);
 224     }
 225
 226     if (wfd_start_multi_connect(ugd) != -1)
 227     {
 228         wfd_ug_view_update_peers(ugd);
 229     }
 230
 231         elm_naviframe_item_pop(ugd->naviframe);
 232
 233         //ToDo: Do we need to free multiconn_view_genlist?
 234         ugd->multiconn_view_genlist = NULL;
 235         _change_multi_button_title(ugd);
 236
 237         __FUNC_EXIT__;
 238         return;
 239 }
 240
 241
 242
 243 static void _wfd_gl_multi_sel_cb(void *data, Evas_Object *obj, void *event_info)
 244 {
 245         __FUNC_ENTER__;
 246
 247         int i = 0;
 248         int index = 0;
 249         int sel_count = 0;
 250         bool is_sel = FALSE;
 251         bool is_selct_all = TRUE;
 252         Eina_Bool state = 0;
 253         Evas_Object *chk_box = NULL;
 254         char msg[MAX_POPUP_TEXT_SIZE] = {0};
 255         struct ug_data *ugd = (struct ug_data*) data;
 256         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 257
 258         if (NULL == ugd || NULL == item) {
 259             DBG(LOG_ERROR, "The param is NULL\n");
 260             return;
 261         }
 262
 263         elm_genlist_item_selected_set(item, EINA_FALSE);
 264         index = elm_genlist_item_index_get(item) - 3; /* subtract the previous items */
 265         DBG(LOG_VERBOSE, "selected index = %d \n", index);
 266         if (index < 0) {
 267             DBG(LOG_ERROR, "The index is invalid.\n");
 268             return;
 269         }
 270
 271         chk_box = elm_object_item_part_content_get((Elm_Object_Item *)event_info, "elm.icon.1");
 272         state = elm_check_state_get(chk_box);
 273         DBG(LOG_VERBOSE, "state = %d \n", state);
 274         elm_check_state_set(chk_box, !state);
 275
 276         ugd->multi_conn_dev_list[index].dev_sel_state = !state;
 277         DBG(LOG_VERBOSE, "ptr->dev_sel_state = %d \n", ugd->multi_conn_dev_list[index].dev_sel_state);
 278         DBG(LOG_VERBOSE, "ptr->peer.mac_addr = %s \n", ugd->multi_conn_dev_list[index].peer.mac_addr);
 279
 280         /* update the checkbox and button */
 281         for (; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) {
 282                 if (ugd->multi_conn_dev_list[i].dev_sel_state) {
 283                         is_sel = TRUE;
 284                         sel_count++;
 285                 } else {
 286                         is_selct_all = FALSE;
 287                 }
 288         }
 289
 290         chk_box = elm_object_item_part_content_get(ugd->mcview_select_all_item, "elm.icon");
 291         elm_check_state_set(chk_box, is_selct_all);
 292
 293         if (ugd->multi_connect_btn) {
 294                 wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel);
 295         }
 296
 297         if (sel_count > 0) {
 298                 snprintf(msg, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_SELECTED_DEVICE_NUM"), sel_count);
 299                 wfd_ug_tickernoti_popup(msg);
 300         }
 301
 302         __FUNC_EXIT__;
 303 }
 304
 305 static void _wfd_gl_sel_cb(void *data, Evas_Object *obj, void *event_info)
 306 {
 307         int sel_count = 0;
 308         char msg[MAX_POPUP_TEXT_SIZE] = {0};
 309         struct ug_data *ugd = (struct ug_data*) data;
 310
 311         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 312
 313         if (NULL == ugd || NULL == obj) {
 314                 DBG(LOG_ERROR, "NULL parameters.\n");
 315                 return;
 316         }
 317
 318         Evas_Object *sel_chkbox = elm_object_item_part_content_get(ugd->mcview_select_all_item, "elm.icon");
 319         if (sel_chkbox==NULL)
 320         {
 321                 DBG(LOG_VERBOSE, "select-all chkbox is NULL\n");
 322                 return;
 323         }
 324         Eina_Bool state = elm_check_state_get(sel_chkbox);
 325
 326         if (state==TRUE)
 327                 state = FALSE;
 328         else
 329                 state = TRUE;
 330         elm_check_state_set(sel_chkbox, state);
 331
 332         DBG(LOG_VERBOSE, "state = %d \n", state);
 333
 334         int i = 0;
 335         bool is_sel = FALSE;
 336         Elm_Object_Item *item = NULL;
 337         Evas_Object *chk_box = NULL;
 338
 339         /* set the state of all the available devices */
 340         for (i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) {
 341                 is_sel = state;
 342                 ugd->multi_conn_dev_list[i].dev_sel_state = state;
 343                 item = ugd->multi_conn_dev_list[i].peer.gl_item;
 344                 chk_box = elm_object_item_part_content_get(item, "elm.icon.1");
 345                 elm_check_state_set(chk_box, state);
 346
 347                 if (state) {
 348                         sel_count++;
 349                 }
 350         }
 351
 352         /* update the connect button */
 353         if (ugd->multi_connect_btn) {
 354                 wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel);
 355         }
 356
 357         /* tickernoti popup */
 358         if (sel_count > 0) {
 359                 snprintf(msg, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_SELECTED_DEVICE_NUM"), sel_count);
 360                 wfd_ug_tickernoti_popup(msg);
 361         }
 362
 363     //elm_check_state_set(ugd->mcview_select_all_icon, EINA_FALSE);
 364 }
 365
 366
 367 static char *_wfd_gl_device_label_get(void *data, Evas_Object *obj, const char *part)
 368 {
 369         DBG(LOG_VERBOSE, "part %s", part);
 370         device_type_s *peer = (device_type_s*) data;
 371
 372         if (NULL == peer)
 373                 return NULL;
 374
 375         if (!strcmp(part, "elm.text")) {
 376                 return strdup(peer->ssid);
 377         }
 378         return NULL;
 379 }
 380
 381
 382 static char *__wfd_get_device_icon_path(device_type_s *peer)
 383 {
 384         char *img_path = NULL;
 385
 386         switch(peer->category)
 387         {
 388         case WFD_DEVICE_TYPE_COMPUTER:
 389             img_path = WFD_ICON_DEVICE_COMPUTER;
 390             break;
 391         case WFD_DEVICE_TYPE_INPUT_DEVICE:
 392             img_path = WFD_ICON_DEVICE_INPUT_DEVICE;
 393             break;
 394         case WFD_DEVICE_TYPE_PRINTER:
 395             img_path = WFD_ICON_DEVICE_PRINTER;
 396             break;
 397         case WFD_DEVICE_TYPE_CAMERA:
 398             img_path = WFD_ICON_DEVICE_CAMERA;
 399             break;
 400         case WFD_DEVICE_TYPE_STORAGE:
 401             img_path = WFD_ICON_DEVICE_STORAGE;
 402             break;
 403         case WFD_DEVICE_TYPE_NW_INFRA:
 404             img_path = WFD_ICON_DEVICE_NETWORK_INFRA;
 405             break;
 406         case WFD_DEVICE_TYPE_DISPLAYS:
 407             img_path = WFD_ICON_DEVICE_DISPLAY;
 408             break;
 409         case WFD_DEVICE_TYPE_MM_DEVICES:
 410             img_path = WFD_ICON_DEVICE_MULTIMEDIA_DEVICE;
 411             break;
 412         case WFD_DEVICE_TYPE_GAME_DEVICES:
 413             img_path = WFD_ICON_DEVICE_GAMING_DEVICE;
 414             break;
 415         case WFD_DEVICE_TYPE_TELEPHONE:
 416             img_path = WFD_ICON_DEVICE_TELEPHONE;
 417             break;
 418         case WFD_DEVICE_TYPE_AUDIO:
 419             img_path = WFD_ICON_DEVICE_AUDIO_DEVICE;
 420             break;
 421         default:
 422                 img_path = WFD_ICON_DEVICE_COMPUTER;
 423                 break;
 424         }
 425
 426         return img_path;
 427 }
 428
 429
 430
 431 static void _wfd_check_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 432 {
 433         struct ug_data *ugd = (struct ug_data*) data;
 434         if (NULL == ugd || NULL == obj) {
 435                 DBG(LOG_ERROR, "NULL parameters.\n");
 436                 return;
 437         }
 438
 439         int i = 0;
 440         bool is_sel = FALSE;
 441         Elm_Object_Item *item = NULL;
 442         Evas_Object *chk_box = NULL;
 443         Eina_Bool state = elm_check_state_get(obj);
 444         elm_check_state_set(obj, !state);
 445
 446         DBG(LOG_VERBOSE, "state = %d \n", state);
 447
 448 #if 0
 449         /* set the state of all the available devices */
 450         for (i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) {
 451                 is_sel = state;
 452                 ugd->multi_conn_dev_list[i].dev_sel_state = state;
 453                 item = ugd->multi_conn_dev_list[i].peer.gl_item;
 454                 chk_box = elm_object_item_part_content_get(item, "elm.icon.1");
 455                 elm_check_state_set(chk_box, state);
 456         }
 457
 458         /* update the connect button */
 459         wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel);
 460 #endif
 461 }
 462
 463
 464 static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part)
 465 {
 466         char *img_path = NULL;
 467         device_type_s *peer = (device_type_s*) data;
 468         Evas_Object* icon = NULL;
 469
 470         DBG(LOG_VERBOSE, "Part %s", part);
 471
 472         if (!strcmp(part, "elm.icon.1")) {
 473                 DBG(LOG_VERBOSE, "Part %s", part);
 474                 icon = elm_check_add(obj);
 475                 elm_check_state_set(icon, EINA_FALSE);
 476             evas_object_smart_callback_add(icon, "changed", _wfd_check_clicked_cb, (void *)data);
 477         } else if (!strcmp(part, "elm.icon.2")) {
 478                 img_path = __wfd_get_device_icon_path(peer);
 479                 icon = elm_icon_add(obj);
 480                 elm_icon_file_set(icon, img_path, NULL);
 481                 evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 482                 elm_icon_resizable_set(icon, 1, 1);
 483                 evas_object_show(icon);
 484         }
 485
 486         return icon;
 487 }
 488
 489
 490 static char *_wfd_gl_select_all_label_get(void *data, Evas_Object *obj, const char *part)
 491 {
 492         if (!strcmp(part, "elm.text")) {
 493                 DBG(LOG_VERBOSE, "Adding text %s", part);
 494                 return strdup("Select all");
 495         }
 496         return NULL;
 497 }
 498
 499 static Evas_Object *_wfd_gl_select_all_icon_get(void *data, Evas_Object *obj, const char *part)
 500 {
 501         struct ug_data *ugd = (struct ug_data*) data;
 502         Evas_Object* icon = NULL;
 503
 504         if (!strcmp(part, "elm.icon")) {
 505                 DBG(LOG_VERBOSE, "Part %s", part);
 506                 icon = elm_check_add(obj);
 507                 elm_check_state_set(icon, EINA_FALSE);
 508                 evas_object_smart_callback_add(icon, "changed", _wfd_check_clicked_cb, (void *)data);
 509         }
 510
 511         return icon;
 512 }
 513
 514
 515
 516
 517 int _wfd_free_multiconnect_device(struct ug_data *ugd)
 518 {
 519     __FUNC_ENTER__;
 520
 521     int count = 0;
 522     int i = 0;
 523
 524     if (ugd->multiconn_view_genlist == NULL)
 525     {
 526         return 0;
 527     }
 528
 529     if (ugd->mcview_title_item != NULL)
 530     {
 531         elm_object_item_del(ugd->mcview_title_item);
 532         ugd->mcview_title_item = NULL;
 533     }
 534
 535     if (ugd->mcview_select_all_item != NULL)
 536     {
 537         elm_object_item_del(ugd->mcview_select_all_item);
 538         ugd->mcview_select_all_item = NULL;
 539     }
 540
 541     if (ugd->mcview_nodevice_item != NULL)
 542     {
 543         elm_object_item_del(ugd->mcview_nodevice_item);
 544         ugd->mcview_nodevice_item = NULL;
 545     }
 546
 547     for(i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view;  i++)
 548     {
 549         if (ugd->multi_conn_dev_list[i].peer.gl_item != NULL)
 550         {
 551             elm_object_item_del(ugd->multi_conn_dev_list[i].peer.gl_item);
 552             ugd->multi_conn_dev_list[i].peer.gl_item = NULL;
 553         }
 554     }
 555     ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 556
 557     __FUNC_EXIT__;
 558     return 0;
 559 }
 560
 561 int _wfd_update_multiconnect_device(struct ug_data *ugd)
 562 {
 563     __FUNC_ENTER__;
 564
 565     int count = 0;
 566     device_type_s *device = NULL;
 567     Evas_Object *genlist = NULL;
 568     int i = 0;
 569
 570     genlist = ugd->multiconn_view_genlist;
 571     if (ugd->multiconn_view_genlist == NULL)
 572     {
 573         return 0;
 574     }
 575
 576     _wfd_free_multiconnect_device(ugd);
 577
 578     count = 0;
 579     for(i = 0; i < ugd->raw_discovered_peer_cnt;  i++)
 580     {
 581         device = &ugd->raw_discovered_peers[i];
 582         if (device->is_connected == FALSE)
 583         {
 584                         count++;
 585         }
 586     }
 587     ugd->gl_available_dev_cnt_at_multiconn_view = count;
 588
 589     if (ugd->gl_available_dev_cnt_at_multiconn_view == 0)
 590     {
 591                 DBG(LOG_ERROR, "There are No peers\n");
 592         ugd->mcview_title_item = elm_genlist_item_append(genlist, &title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 593         elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 594         ugd->mcview_nodevice_item = elm_genlist_item_append(genlist, &noitem_itc, (void*)ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 595         elm_genlist_item_select_mode_set(ugd->mcview_nodevice_item , ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 596     }
 597     else
 598     {
 599         ugd->mcview_title_item = elm_genlist_item_append(genlist, &title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 600         elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 601         ugd->mcview_select_all_item = elm_genlist_item_append(genlist, &select_all_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _wfd_gl_sel_cb, ugd);
 602
 603                 count = 0;
 604                 for(i = 0; i < ugd->raw_discovered_peer_cnt;  i++)
 605                 {
 606                         device = &ugd->raw_discovered_peers[i];
 607                         if (device->is_connected == FALSE)
 608                         {
 609                                 DBG(LOG_VERBOSE, "%dth peer being added on genlist\n", i);
 610
 611                                 if (ugd->multi_conn_dev_list[count].peer.gl_item != NULL)
 612                                         elm_object_item_del(ugd->multi_conn_dev_list[count].peer.gl_item);
 613                                 ugd->multi_conn_dev_list[count].peer.gl_item = NULL;
 614
 615                                 memcpy(&ugd->multi_conn_dev_list[count].peer, device, sizeof(device_type_s));
 616
 617                                 ugd->multi_conn_dev_list[count].dev_sel_state = FALSE;
 618                                 ugd->multi_conn_dev_list[count].peer.gl_item =
 619                                                 elm_genlist_item_append(genlist, &device_itc, (void*) &ugd->multi_conn_dev_list[count].peer,
 620                                                                 NULL, ELM_GENLIST_ITEM_NONE, _wfd_gl_multi_sel_cb, ugd);
 621                                 count++;
 622                         }
 623                 }
 624     }
 625
 626     __FUNC_EXIT__;
 627     return 0;
 628 }
 629
 630 void _wifid_create_multiconnect_view(struct ug_data *ugd)
 631 {
 632         __FUNC_ENTER__;
 633
 634     Evas_Object *back_btn = NULL;
 635     Evas_Object *control_bar = NULL;
 636     Evas_Object *genlist = NULL;
 637
 638     Elm_Object_Item *navi_item = NULL;
 639         Elm_Object_Item *item = NULL;
 640
 641     if(ugd == NULL)
 642     {
 643         DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 644         return;
 645     }
 646
 647     select_all_itc.item_style = "1text.1icon.3";
 648     select_all_itc.func.text_get = _wfd_gl_select_all_label_get;
 649     select_all_itc.func.content_get = _wfd_gl_select_all_icon_get;
 650     select_all_itc.func.state_get = NULL;
 651     select_all_itc.func.del = NULL;
 652
 653     device_itc.item_style = "1text.2icon.2";
 654     device_itc.func.text_get = _wfd_gl_device_label_get;
 655     device_itc.func.content_get = _wfd_gl_device_icon_get;
 656     device_itc.func.state_get = NULL;
 657     device_itc.func.del = NULL;
 658
 659     DBG(LOG_VERBOSE, "_wifid_create_multiconnect_view");
 660     back_btn = elm_button_add(ugd->naviframe);
 661     elm_object_style_set(back_btn, "naviframe/back_btn/default");
 662     evas_object_smart_callback_add(back_btn, "clicked", _multiconnect_view_back_btn_cb, (void*) ugd);
 663     elm_object_focus_allow_set(back_btn, EINA_FALSE);
 664
 665     genlist = elm_genlist_add(ugd->naviframe);
 666     ugd->multiconn_view_genlist = genlist;
 667     elm_object_style_set(ugd->multiconn_view_genlist, "dialogue");
 668
 669     ugd->mcview_title_item = NULL;
 670
 671     _wfd_update_multiconnect_device(ugd);
 672
 673     evas_object_show(genlist);
 674
 675     navi_item = elm_naviframe_item_push(ugd->naviframe, _("Multi connect"), back_btn, NULL, genlist, NULL);
 676
 677     control_bar = elm_toolbar_add(ugd->naviframe);
 678     elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND);
 679     evas_object_show(control_bar);
 680
 681     ugd->multi_scan_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_SCAN"), _scan_btn_cb, (void*) ugd);
 682     item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL);
 683     elm_object_item_disabled_set(item, EINA_TRUE);
 684     ugd->multi_connect_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_CONNECT"), _connect_btn_cb, (void*) ugd);
 685
 686     if (ugd->multi_connect_btn) {
 687         wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), FALSE);
 688     }
 689
 690     item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL);
 691     elm_object_item_disabled_set(item, EINA_TRUE);
 692     elm_object_item_part_content_set(navi_item, "controlbar", control_bar);
 693
 694     __FUNC_EXIT__;
 695 }