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         char *format_str = NULL;
 315
 316         peer = ugd->multi_conn_dev_list_start;
 317         while (peer != NULL) {
 318                 if(peer->dev_sel_state) {
 319                         count++;
 320                 }
 321                 peer = peer->next;
 322         }
 323         DBG(LOG_INFO, "MultiSelected Peer Count: %d", count);
 324
 325         /* if more than 7 device selected, show the popup */
 326         if (count > MAX_CONNECTED_PEER_NUM) {
 327                 format_str = D_("IDS_ST_POP_YOU_CAN_CONNECT_UP_TO_PD_DEVICES_AT_THE_SAME_TIME");
 328                 snprintf(popup_text, MAX_POPUP_TEXT_SIZE, format_str, MAX_CONNECTED_PEER_NUM);
 329                 wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP);
 330                 __FUNC_EXIT__;
 331                 return;
 332         }
 333
 334         peer = ugd->multi_conn_dev_list_start;
 335         count = 0;
 336         while (peer != NULL) {
 337                 if(peer->dev_sel_state) {
 338                         DBG(LOG_INFO, "peer_name[%s] select state[%d]", peer->ssid, peer->dev_sel_state);
 339                         memcpy(&ugd->raw_multi_selected_peers[count], peer, sizeof(device_type_s));
 340                         ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT;
 341                         count++;
 342                 }
 343                 peer = peer->next;
 344         }
 345
 346         DBG(LOG_INFO, "MultiSelected Peer Count2: %d", count);
 347         ugd->raw_multi_selected_peer_cnt = count;
 348         wfd_sort_multi_selected_peers(ugd);
 349         wfd_cancel_progressbar_stop_timer(ugd);
 350         wfd_cancel_not_alive_delete_timer(ugd);
 351
 352         /* start multi connection */
 353         wfd_start_multi_connect(ugd);
 354
 355         elm_naviframe_item_pop(ugd->naviframe);
 356
 357         __FUNC_EXIT__;
 358         return;
 359 }
 360
 361 void wfd_naviframe_title_set(struct ug_data *ugd, const char *title)
 362 {
 363         if (!ugd || !ugd->multi_navi_item) {
 364                 DBG(LOG_ERROR, "The param is NULL\n");
 365                 return;
 366         }
 367
 368         elm_object_item_part_text_set(ugd->multi_navi_item, "default", title);
 369 }
 370
 371 /**
 372  *      This function let the ug call it when click the peer in multi connect view
 373  *      @return   void
 374  *      @param[in] data the pointer to the main data structure
 375  *      @param[in] obj the pointer to the evas object
 376  *      @param[in] event_info the pointer to the event information
 377  */
 378 static void _wfd_gl_multi_sel_cb(void *data, Evas_Object *obj, void *event_info)
 379 {
 380         __FUNC_ENTER__;
 381
 382         int sel_count = 0;
 383         bool is_sel = FALSE;
 384
 385         Eina_Bool state = EINA_FALSE;
 386         Evas_Object *chk_box = NULL;
 387         const char *object_type = NULL;
 388         struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data();
 389         device_type_s *peer = (device_type_s *)data;
 390         char *format_str = NULL;
 391
 392         if (NULL == ugd) {
 393                 DBG(LOG_ERROR, "ugd is NULL\n");
 394                 return;
 395         }
 396
 397         ugd->is_multi_check_all_selected = TRUE;
 398
 399         if(event_info != NULL) {
 400                 Evas_Object *content = elm_object_item_part_content_get(event_info, "elm.icon.2");
 401                 chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 402                 state = elm_check_state_get(chk_box);
 403                 DBG(LOG_INFO, "state = %d \n", state);
 404                 if (chk_box ==  NULL) {
 405                         DBG(LOG_INFO, "Check box is null\n");
 406                 }
 407         }
 408
 409         object_type = evas_object_type_get(obj);
 410          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 411                 Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 412                 if (item) {
 413                         elm_genlist_item_selected_set(item, EINA_FALSE);
 414                 }
 415                 DBG(LOG_INFO, "State elm_genlist %d\n", state);
 416                 elm_check_state_set(chk_box, !state);
 417                 peer->dev_sel_state = !state;
 418         } else if (g_strcmp0(object_type, "elm_check") == 0){
 419                 DBG(LOG_INFO, "elm_check state; %d\n", peer->dev_sel_state);
 420                 peer->dev_sel_state = !peer->dev_sel_state;
 421         }
 422
 423         DBG(LOG_INFO, "ptr->dev_sel_state = %d \n", peer->dev_sel_state);
 424         DBG_SECURE(LOG_INFO, "ptr->peer.mac_addr = ["MACSECSTR"]\n",
 425                 MAC2SECSTR(peer->mac_addr));
 426
 427         peer = ugd->multi_conn_dev_list_start;
 428         while (peer != NULL) {
 429                 if(peer->dev_sel_state) {
 430                         is_sel = TRUE;
 431                         sel_count++;
 432                 } else {
 433                         ugd->is_multi_check_all_selected = FALSE;
 434                 }
 435                 peer = peer->next;
 436         }
 437
 438         if (is_sel) {
 439                 char title[MAX_POPUP_TEXT_SIZE] = {0};
 440                 format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 441                 snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, sel_count);
 442                 wfd_naviframe_title_set(ugd, title);
 443         } else {
 444                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 445         }
 446
 447         state = elm_check_state_get(ugd->select_all_icon);
 448         if (ugd->multiconn_layout) {
 449                 if (state != EINA_TRUE && ugd->is_multi_check_all_selected == TRUE) {
 450                         elm_check_state_set(ugd->select_all_icon, TRUE);
 451                         ugd->is_select_all_checked = TRUE;
 452                 } else if (ugd->is_multi_check_all_selected == FALSE) {
 453                         elm_check_state_set(ugd->select_all_icon, FALSE);
 454                         ugd->is_select_all_checked = FALSE;
 455                 }
 456                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 457                         "IDS_WIFI_SK_CONNECT", is_sel);
 458         }
 459
 460         __FUNC_EXIT__;
 461 }
 462
 463 /**
 464  *      This function let the ug get the label of peer
 465  *      @return   the label of peer
 466  *      @param[in] data the pointer to the main data structure
 467  *      @param[in] obj the pointer to the evas object
 468  *      @param[in] part the pointer to the part of item
 469  */
 470 static char *_wfd_gl_device_label_get(void *data, Evas_Object *obj, const char *part)
 471 {
 472         __FUNC_ENTER__;
 473         DBG(LOG_INFO, "part %s", part);
 474         device_type_s *peer = (device_type_s *)data;
 475         char *ssid;
 476
 477         if (NULL == peer) {
 478                 return NULL;
 479         }
 480
 481         if (!strcmp("elm.text", part)) {
 482                 if (strlen(peer->ssid) != 0) {
 483                         ssid = elm_entry_utf8_to_markup(peer->ssid);
 484                         if (NULL == ssid) {
 485                                 DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n");
 486                                 __FUNC_EXIT__;
 487                                 return NULL;
 488                         }
 489                         __FUNC_EXIT__;
 490                         return ssid;
 491                 }
 492         }
 493         return NULL;
 494 }
 495
 496 /**
 497  *      This function let the ug get the icon path of peer
 498  *      @return   the  icon path of titile
 499  *      @param[in] peer the pointer to the peer
 500  */
 501 static char *__wfd_get_device_icon_path(device_type_s *peer)
 502 {
 503         __FUNC_ENTER__;
 504         char *img_name = NULL;
 505
 506         switch (peer->category) {
 507         case WFD_DEVICE_TYPE_COMPUTER:
 508                 img_name = WFD_ICON_DEVICE_COMPUTER;
 509                 break;
 510         case WFD_DEVICE_TYPE_INPUT_DEVICE:
 511                 img_name = WFD_ICON_DEVICE_INPUT_DEVICE;
 512                 break;
 513         case WFD_DEVICE_TYPE_PRINTER:
 514                 img_name = WFD_ICON_DEVICE_PRINTER;
 515                 break;
 516         case WFD_DEVICE_TYPE_CAMERA:
 517                 img_name = WFD_ICON_DEVICE_CAMERA;
 518                 break;
 519         case WFD_DEVICE_TYPE_STORAGE:
 520                 img_name = WFD_ICON_DEVICE_STORAGE;
 521                 break;
 522         case WFD_DEVICE_TYPE_NW_INFRA:
 523                 img_name = WFD_ICON_DEVICE_NETWORK_INFRA;
 524                 break;
 525         case WFD_DEVICE_TYPE_DISPLAYS:
 526                 img_name = WFD_ICON_DEVICE_DISPLAY;
 527                 break;
 528         case WFD_DEVICE_TYPE_MM_DEVICES:
 529                 img_name = WFD_ICON_DEVICE_MULTIMEDIA;
 530                 break;
 531         case WFD_DEVICE_TYPE_GAME_DEVICES:
 532                 img_name = WFD_ICON_DEVICE_GAMING;
 533                 break;
 534         case WFD_DEVICE_TYPE_TELEPHONE:
 535                 img_name = WFD_ICON_DEVICE_TELEPHONE;
 536                 break;
 537         case WFD_DEVICE_TYPE_AUDIO:
 538                 img_name = WFD_ICON_DEVICE_HEADSET;
 539                 break;
 540         default:
 541                 img_name = WFD_ICON_DEVICE_UNKNOWN;
 542                 break;
 543         }
 544         return img_name;
 545 }
 546
 547 /**
 548  *      This function let the ug get the icon of peer
 549  *      @return   the icon of peer
 550  *      @param[in] data the pointer to the main data structure
 551  *      @param[in] obj the pointer to the evas object
 552  *      @param[in] part the pointer to the part of item
 553  */
 554 static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part)
 555 {
 556         __FUNC_ENTER__;
 557         char *img_name = NULL;
 558         device_type_s *peer = (device_type_s *) data;
 559         Evas_Object *icon = NULL;
 560         Evas_Object *icon_layout = NULL;
 561
 562         DBG(LOG_INFO, "Part %s", part);
 563
 564         if (!strcmp("elm.swallow.icon", part)) {
 565                 DBG(LOG_INFO, "Part %s", part);
 566                 icon_layout = elm_layout_add(obj);
 567                 elm_layout_theme_set(icon_layout, "layout", "list/B/type.3", "default");
 568                 img_name = __wfd_get_device_icon_path(peer);
 569                 icon = elm_image_add(icon_layout);
 570                 elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name);
 571                 evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 572                 evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 573                 evas_object_color_set(icon, 2, 61, 132, 204);
 574                 evas_object_show(icon);
 575                 evas_object_propagate_events_set(icon, EINA_FALSE);
 576                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 577         } else if (!strcmp("elm.swallow.end", part)) {
 578                 icon_layout = elm_layout_add(obj);
 579                 elm_layout_theme_set(icon_layout, "layout", "list/C/type.2", "default");
 580                 DBG(LOG_INFO, "Part %s", part);
 581                 icon = elm_check_add(icon_layout);
 582                 elm_object_style_set(icon, "default/genlist");
 583                 evas_object_propagate_events_set(icon, EINA_FALSE);
 584                 if (peer->dev_sel_state == EINA_TRUE) {
 585                         elm_check_state_set(icon, EINA_TRUE);
 586                 }
 587                 evas_object_smart_callback_add(icon,
 588                         "changed", _wfd_gl_multi_sel_cb, (void *)data);
 589                 elm_layout_content_set(icon_layout, "elm.swallow.content", icon);
 590         }
 591
 592         if (icon_layout)
 593                 evas_object_show(icon_layout);
 594
 595         return icon_layout;
 596 }
 597
 598 /**
 599  *      This function let the ug call it when unresized event is received
 600 */
 601 static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info)
 602 {
 603         __FUNC_ENTER__;
 604         struct ug_data *ugd = (struct ug_data *)data;
 605         int sel_count = 0;
 606         bool is_sel = FALSE;
 607         device_type_s *peer = NULL;
 608         char *format_str = NULL;
 609
 610         if (!ugd->multiconn_conn_btn) {
 611                 DBG(LOG_INFO, "popup naviframe, no need to update UI\n");
 612                 return;
 613         }
 614
 615         if (ugd->gl_available_dev_cnt_at_multiconn_view > 0) {
 616                 peer = ugd->multi_conn_dev_list_start;
 617                 while (peer != NULL) {
 618                         if(peer->dev_sel_state) {
 619                                 is_sel = TRUE;
 620                                 sel_count++;
 621                         }
 622                         peer = peer->next;
 623                 }
 624         }
 625
 626         if (is_sel) {
 627                 char title[MAX_POPUP_TEXT_SIZE] = {0};
 628                 format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 629                 snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, sel_count);
 630                 wfd_naviframe_title_set(ugd, title);
 631         } else {
 632                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 633         }
 634
 635         if (ugd->multiconn_conn_btn) {
 636                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 637                         "IDS_WIFI_SK_CONNECT", is_sel);
 638         }
 639
 640         __FUNC_EXIT__;
 641 }
 642
 643 /**
 644  *      This function let the ug free the multi connect devices
 645  *      @return   0
 646  *      @param[in] data the pointer to the main data structure
 647  */
 648 int wfd_free_multiconnect_device(struct ug_data *ugd)
 649 {
 650         __FUNC_ENTER__;
 651
 652         if (ugd->multiconn_view_genlist == NULL) {
 653                 return 0;
 654         }
 655
 656         ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 657         if (ugd->multi_conn_dev_list_start != NULL) {
 658                 wfd_ug_view_free_peer(ugd->multi_conn_dev_list_start);
 659                 ugd->multi_conn_dev_list_start = NULL;
 660         }
 661
 662         __FUNC_EXIT__;
 663         return 0;
 664 }
 665
 666 /**
 667  *      This function let the ug create "no device found" item
 668 */
 669 Evas_Object *_create_no_device_multiconnect_genlist(struct ug_data *ugd)
 670 {
 671         __FUNC_ENTER__;
 672
 673         if (NULL == ugd) {
 674                 DBG(LOG_ERROR, "NULL parameters.\n");
 675                 return NULL;
 676         }
 677
 678         if (!ugd->mcview_nodevice_item) {
 679                 ugd->mcview_nodevice_item = elm_genlist_item_append(ugd->multiconn_view_genlist, &noitem_itc, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 680                 if(ugd->mcview_nodevice_item != NULL)
 681                         elm_genlist_item_select_mode_set(ugd->mcview_nodevice_item , ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 682         }
 683
 684         __FUNC_EXIT__;
 685         return ugd->multiconn_view_genlist;
 686 }
 687
 688 /**
 689  *      This function let the ug update the multi connect devices
 690  *      @return   0
 691  *      @param[in] data the pointer to the main data structure
 692  */
 693 int wfd_update_multiconnect_device(struct ug_data *ugd, bool is_free_all_peers)
 694 {
 695         __FUNC_ENTER__;
 696
 697         int count = 0;
 698         device_type_s *device = NULL;
 699         Evas_Object *genlist = NULL;
 700         Elm_Object_Item *item = NULL;
 701         int res = 0;
 702
 703         genlist = ugd->multiconn_view_genlist;
 704         if (ugd->multiconn_view_genlist == NULL) {
 705                 return 0;
 706         }
 707
 708         if (is_free_all_peers) {
 709                 wfd_free_multiconnect_device(ugd);
 710         }
 711
 712         GList *iterator = NULL;
 713         for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 714                 device = (device_type_s *)iterator->data;
 715                 if (device->is_connected == FALSE && device->is_group_owner == FALSE) {
 716                         count++;
 717                 }
 718         }
 719
 720         if (count == 0) {
 721                 DBG(LOG_INFO, "There are No peers\n");
 722                 if (!ugd->mcview_title_item) {
 723                         ugd->mcview_title_item = elm_genlist_item_append(genlist, &multi_view_title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 724                         if(ugd->mcview_title_item != NULL)
 725                                 elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 726                 } else {
 727                         wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 728                 }
 729                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 730                 ugd->is_select_all_checked = FALSE;
 731                 wfd_free_multiconnect_device(ugd);
 732                 wfd_naviframe_title_set(ugd, D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 733         } else {
 734                 WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 735                 wfd_ug_view_refresh_glitem(ugd->mcview_title_item);
 736
 737                 for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) {
 738                         device = (device_type_s *)iterator->data;
 739                         if (device->is_connected == FALSE && device->is_group_owner == FALSE) {
 740                                 if (!find_peer_in_glist(ugd->multi_conn_dev_list_start, device->mac_addr)) {
 741                                         item = get_insert_postion(device, ugd->mcview_title_item, ugd->gl_available_dev_cnt_at_multiconn_view);
 742                                         res = insert_gl_item(genlist, item, &device_itc, &ugd->multi_conn_dev_list_start,
 743                                                                 device, _wfd_gl_multi_sel_cb);
 744                                         if (res != 0) {
 745                                                 break;
 746                                         }
 747                                         elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 748                                         ugd->is_select_all_checked = FALSE;
 749
 750                                         ugd->gl_available_dev_cnt_at_multiconn_view++;
 751                                 }
 752                         }
 753                 }
 754         }
 755         ugd->is_multi_check_all_selected = FALSE;
 756
 757         __FUNC_EXIT__;
 758         return 0;
 759 }
 760
 761 void wfd_genlist_select_all_check_changed_cb(void *data, Evas_Object * obj, void *event_info)
 762 {
 763         __FUNC_ENTER__;
 764         Elm_Object_Item *item = NULL;
 765         Evas_Object *chk_box = NULL;
 766         Evas_Object *content = NULL;
 767         const char *object_type;
 768         Eina_Bool state;
 769         char *format_str = NULL;
 770
 771
 772         struct ug_data *ugd = (struct ug_data *)data;
 773         if (NULL == ugd || NULL == obj) {
 774                 DBG(LOG_ERROR, "NULL parameters.\n");
 775                 return;
 776         }
 777
 778         if (ugd->multi_conn_dev_list_start == NULL) {
 779                 elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 780                 elm_check_state_set(ugd->select_all_icon, EINA_FALSE);
 781                 ugd->is_select_all_checked = FALSE;
 782
 783                 DBG(LOG_INFO, "No devices in multi-connect view.\n");
 784                 return;
 785         }
 786
 787         device_type_s *peer = ugd->multi_conn_dev_list_start;
 788         elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE);
 789
 790
 791         object_type = evas_object_type_get(obj);
 792          if (g_strcmp0(object_type, "elm_genlist") == 0) {
 793                 state = elm_check_state_get(ugd->select_all_icon);
 794                 elm_check_state_set(ugd->select_all_icon, !state);
 795                 ugd->is_select_all_checked = !state;
 796         }
 797
 798         state = elm_check_state_get(ugd->select_all_icon);
 799         DBG(LOG_INFO, "state = %d",state);
 800         if (state == EINA_TRUE) {
 801                 if (ugd->is_multi_check_all_selected == FALSE) {
 802                         int sel_count = 0;
 803                         while (peer != NULL) {
 804                                 peer->dev_sel_state = TRUE;
 805                                 item = peer->gl_item;
 806                                 content = elm_object_item_part_content_get(item, "elm.icon.2");
 807                                 chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 808                                 elm_check_state_set(chk_box, TRUE);
 809                                 sel_count++;
 810                                 peer = peer->next;
 811                         }
 812                         ugd->is_multi_check_all_selected = TRUE;
 813
 814                         char title[MAX_POPUP_TEXT_SIZE] = {0};
 815                         format_str = D_("IDS_ST_HEADER_PD_SELECTED");
 816                         snprintf(title, MAX_POPUP_TEXT_SIZE, format_str, sel_count);
 817                         wfd_naviframe_title_set(ugd, title);
 818
 819                         if (ugd->multiconn_layout) {
 820                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 821                                         "IDS_WIFI_SK_CONNECT", TRUE);
 822                         }
 823                 }
 824         } else {
 825                 while (peer != NULL) {
 826                         peer->dev_sel_state = FALSE;
 827                         item = peer->gl_item;
 828                         content = elm_object_item_part_content_get(item, "elm.icon.2");
 829                         chk_box = elm_object_part_content_get(content, "elm.swallow.content");
 830                         elm_check_state_set(chk_box, FALSE);
 831                         peer = peer->next;
 832                 }
 833                 ugd->is_multi_check_all_selected = FALSE;
 834                 wfd_naviframe_title_set(ugd,
 835                         D_("IDS_DLNA_HEADER_SELECT_DEVICES_ABB"));
 836
 837                 if (ugd->multiconn_layout) {
 838                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn,
 839                                 "IDS_WIFI_SK_CONNECT", FALSE);
 840                 }
 841         }
 842 }
 843
 844 /**
 845  *      This function let the ug call it when click 'scan' button
 846  *      @return   void
 847  *      @param[in] data the pointer to the main data structure
 848  *      @param[in] obj the pointer to the evas object
 849  *      @param[in] event_info the pointer to the event information
 850  */
 851 void _multi_scan_btn_cb(void *data, Evas_Object *obj, void *event_info)
 852 {
 853         __FUNC_ENTER__;
 854         int ret = -1;
 855         const char *btn_text = NULL;
 856         device_type_s *peer = NULL;
 857         struct ug_data *ugd = (struct ug_data *) data;
 858
 859         if (NULL == ugd) {
 860                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 861                 return;
 862         }
 863
 864         if (ugd->multiconn_conn_btn) {
 865                 peer = ugd->multi_conn_dev_list_start;
 866                 while (peer) {
 867                         if(peer->dev_sel_state) {
 868                                 wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", TRUE);
 869                                 break;
 870                         }
 871                         peer = peer->next;
 872                 }
 873                 if (!peer) {
 874                         wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", FALSE);
 875                 }
 876         }
 877
 878         btn_text = elm_object_text_get(ugd->multiconn_scan_stop_btn);
 879         if (NULL == btn_text) {
 880                 DBG(LOG_ERROR, "Incorrect button text(NULL)\n");
 881                 return;
 882         }
 883
 884         if (0 == strcmp(btn_text, D_("IDS_WIFI_SK4_SCAN"))) {
 885                 wfd_refresh_wifi_direct_state(ugd);
 886                 DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status);
 887
 888                 /* if connected, show the popup*/
 889                 if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) {
 890                         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);
 891                 } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) {
 892                         wfd_client_switch_on(ugd);
 893                         __FUNC_EXIT__;
 894                         return;
 895                 } else {
 896                         WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item);
 897                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 898                         ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 899                         if (ret != WIFI_DIRECT_ERROR_NONE) {
 900                                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 901                                 DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 902                                 wifi_direct_cancel_discovery();
 903                         }
 904                 }
 905                 elm_object_domain_translatable_text_set(ugd->multiconn_scan_stop_btn,
 906                                 PACKAGE, "IDS_WIFI_SK_STOP");
 907         } else if (0 == strcmp(btn_text, D_("IDS_WIFI_SK_STOP"))) {
 908                 DBG(LOG_INFO, "Stop pressed.\n");
 909                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 910                 wfd_cancel_progressbar_stop_timer(ugd);
 911                 wfd_delete_progressbar_cb(ugd);
 912                 wfd_cancel_not_alive_delete_timer(ugd);
 913         }
 914
 915         __FUNC_EXIT__;
 916         return;
 917 }
 918
 919 /**
 920  *      This function let the ug create the view for multi connection
 921  *      @return   void
 922  *      @param[in] ugd the pointer to the main data structure
 923  */
 924 void wfd_create_multiconnect_view(struct ug_data *ugd)
 925 {
 926         __FUNC_ENTER__;
 927
 928         Evas_Object *genlist = NULL;
 929         Elm_Object_Item *navi_item = NULL;
 930         Evas_Object *btn1 = NULL;
 931         Evas_Object *btn2 = NULL;
 932         Evas_Object *layout = NULL;
 933
 934         if (ugd == NULL) {
 935                 DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 936                 return;
 937         }
 938
 939         device_itc.item_style = WFD_GENLIST_1LINE_TEXT_ICON_STYLE;
 940         device_itc.func.text_get = _wfd_gl_device_label_get;
 941         device_itc.func.content_get = _wfd_gl_device_icon_get;
 942         device_itc.func.state_get = NULL;
 943         device_itc.func.del = NULL;
 944
 945         /* Create layout */
 946         layout = elm_layout_add(ugd->naviframe);
 947         elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "bottom_btn");
 948         ugd->multiconn_layout = layout;
 949
 950
 951         genlist = elm_genlist_add(ugd->multiconn_layout);
 952         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 953         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 954         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 955         evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd);
 956
 957         elm_object_part_content_set(layout, "elm.swallow.content", genlist);
 958         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 959 #if defined(GENLIST_REALIZATION_MOTE_SET)
 960         elm_genlist_realization_mode_set(genlist, TRUE);
 961 #endif
 962
 963         ugd->multiconn_view_genlist = genlist;
 964         ugd->mcview_title_item = NULL;
 965         ugd->mcview_nodevice_item = NULL;
 966         ugd->gl_available_dev_cnt_at_multiconn_view = 0;
 967         evas_object_show(genlist);
 968
 969         navi_item = elm_naviframe_item_push(ugd->naviframe,
 970                 "IDS_DLNA_HEADER_SELECT_DEVICES_ABB", NULL, NULL, layout, NULL);
 971         elm_object_item_domain_text_translatable_set(navi_item, PACKAGE, EINA_TRUE);
 972
 973         elm_naviframe_item_pop_cb_set(navi_item, _multiconnect_view_pop_cb, (void *)ugd);
 974         ugd->select_all_view_genlist = elm_genlist_item_append(genlist,
 975                         &select_all_multi_connect_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE,
 976                         wfd_genlist_select_all_check_changed_cb, (void *)ugd );
 977
 978
 979         btn1 = elm_button_add(ugd->multiconn_layout);
 980         elm_object_style_set(btn1, "bottom");
 981         if (ugd->view_type && g_strcmp0(D_(ugd->view_type),
 982                 D_("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) {
 983                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 984                                 "IDS_WIFI_SK4_SCAN");
 985         } else {
 986                 elm_object_domain_translatable_text_set(btn1, PACKAGE,
 987                                 "IDS_WIFI_SK_STOP");
 988         }
 989         elm_object_part_content_set(ugd->multiconn_layout, "button.prev", btn1);
 990         evas_object_smart_callback_add(btn1, "clicked",_multi_scan_btn_cb, (void *)ugd);
 991         evas_object_show(btn1);
 992         ugd->multiconn_scan_stop_btn = btn1;
 993
 994         btn2 = elm_button_add(ugd->multiconn_layout);
 995         elm_object_style_set(btn2, "bottom");
 996         elm_object_domain_translatable_text_set(btn2, PACKAGE,
 997                         "IDS_WIFI_SK_CONNECT");
 998         elm_object_part_content_set(ugd->multiconn_layout, "button.next", btn2);
 999         evas_object_smart_callback_add(btn2, "clicked",_connect_btn_cb, (void *)ugd);
1000         evas_object_show(btn2);
1001         ugd->multiconn_conn_btn = btn2;
1002         elm_object_disabled_set(ugd->multiconn_conn_btn, EINA_TRUE);
1003
1004         ugd->multi_navi_item = navi_item;
1005
1006         wfd_update_multiconnect_device(ugd, true);
1007
1008         __FUNC_EXIT__;
1009 }