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