diff options
Diffstat (limited to 'ug-wifidirect/src')
| -rw-r--r--[-rwxr-xr-x] | ug-wifidirect/src/wfd_client.c | 2395 | ||||
| -rwxr-xr-x | ug-wifidirect/src/wfd_motion_control.c | 204 | ||||
| -rw-r--r--[-rwxr-xr-x] | ug-wifidirect/src/wfd_ug.c | 1106 | ||||
| -rw-r--r-- | ug-wifidirect/src/wfd_ug_about_view.c | 128 | ||||
| -rwxr-xr-x | ug-wifidirect/src/wfd_ug_genlist.c | 1402 | ||||
| -rw-r--r--[-rwxr-xr-x] | ug-wifidirect/src/wfd_ug_main_view.c | 2590 | ||||
| -rw-r--r--[-rwxr-xr-x] | ug-wifidirect/src/wfd_ug_multiconnect_view.c | 1274 | ||||
| -rwxr-xr-x | ug-wifidirect/src/wfd_ug_popup.c | 809 | ||||
| -rw-r--r-- | ug-wifidirect/src/wfd_ug_rename_popup.c | 415 |
9 files changed, 7037 insertions, 3286 deletions
diff --git a/ug-wifidirect/src/wfd_client.c b/ug-wifidirect/src/wfd_client.c index d0c3ae9..8bd357b 100755..100644 --- a/ug-wifidirect/src/wfd_client.c +++ b/ug-wifidirect/src/wfd_client.c @@ -22,936 +22,1941 @@ #include <libintl.h> #include <Elementary.h> -#include <pmapi.h> #include <vconf.h> -//#include <vconf-keys.h> +#include <vconf-keys.h> + #include <tethering.h> + #include <network-cm-intf.h> #include <network-wifi-intf.h> + #include <wifi-direct.h> #include "wfd_ug.h" #include "wfd_ug_view.h" #include "wfd_client.h" +bool _wfd_discoverd_peer_cb(wifi_direct_discovered_peer_info_s *peer, void *user_data); + +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE +/** + * This function let the ug make a change callback for wifi state + * @return void + * @param[in] key the pointer to the key + * @param[in] data the pointer to the main data structure + */ static void _wifi_state_cb(keynode_t *key, void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res; - int wifi_state; - - res = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state); - if (res != 0) - { - DBG(LOG_ERROR, "Failed to get wifi state from vconf. [%d]\n", res); - // TODO: set genlist head item as "WiFi Direct" - return; - } - - if(wifi_state == VCONFKEY_WIFI_OFF) - { - DBG(LOG_VERBOSE, "WiFi is turned off\n"); - wfd_client_swtch_force(ugd, TRUE); - } - else - { - DBG(LOG_VERBOSE, "WiFi is turned on\n"); - } - - res = net_deregister_client(); - if(res != NET_ERR_NONE) - { - DBG(LOG_ERROR, "Failed to deregister network client. [%d]\n", res); - } - - __FUNC_EXIT__; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res; + int wifi_state; + + res = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state); + if (res != 0) { + DBG(LOG_ERROR, "Failed to get wifi state from vconf. [%d]\n", res); + return; + } + + if (wifi_state == VCONFKEY_WIFI_OFF) { + DBG(LOG_INFO, "WiFi is turned off\n"); + wfd_client_swtch_force(ugd, TRUE); + } else { + DBG(LOG_INFO, "WiFi is turned on\n"); + } + + res = net_deregister_client(); + if (res != NET_ERR_NONE) { + DBG(LOG_ERROR, "Failed to deregister network client. [%d]\n", res); + } + + __FUNC_EXIT__; } +/** + * This function let the ug make a event callback for network registering + * @return void + * @param[in] event_info the pointer to the information of network event + * @param[in] user_data the pointer to the user data + */ static void _network_event_cb(net_event_info_t *event_info, void *user_data) { - __FUNC_ENTER__; - DBG(LOG_VERBOSE, "Event from network. [%d]\n", event_info->Event); - __FUNC_EXIT__; + __FUNC_ENTER__; + DBG(LOG_INFO, "Event from network. [%d]\n", event_info->Event); + __FUNC_EXIT__; } +/** + * This function let the ug turn wifi off + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ int wfd_wifi_off(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res; - - res = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, _wifi_state_cb, ugd); - if (res == -1) - { - DBG(LOG_ERROR, "Failed to register vconf callback\n"); - return -1; - } - DBG(LOG_VERBOSE, "Vconf key callback is registered\n"); - res = net_register_client((net_event_cb_t) _network_event_cb, NULL); - if(res != NET_ERR_NONE) - { - DBG(LOG_ERROR, "Failed to register network client. [%d]\n", res); - return -1; - } - DBG(LOG_VERBOSE, "Network client is registered\n"); - res = net_wifi_power_off(); - if(res != NET_ERR_NONE) - { - DBG(LOG_ERROR, "Failed to turn off wifi. [%d]\n", res); - return -1; - } - DBG(LOG_VERBOSE, "WiFi power off\n"); - __FUNC_EXIT__; - return 0; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res; + + res = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, _wifi_state_cb, ugd); + if (res == -1) { + DBG(LOG_ERROR, "Failed to register vconf callback\n"); + return -1; + } + + DBG(LOG_INFO, "Vconf key callback is registered\n"); + + res = net_register_client((net_event_cb_t) _network_event_cb, NULL); + if (res != NET_ERR_NONE) { + DBG(LOG_ERROR, "Failed to register network client. [%d]\n", res); + return -1; + } + + DBG(LOG_INFO, "Network client is registered\n"); + + res = net_wifi_power_off(); + if (res != NET_ERR_NONE) { + DBG(LOG_ERROR, "Failed to turn off wifi. [%d]\n", res); + return -1; + } + + DBG(LOG_INFO, "WiFi power off\n"); + + __FUNC_EXIT__; + return 0; +} +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + +/** + * This function let the ug make a callback for setting tethering mode enabled + * @return void + * @param[in] error the returned error code + * @param[in] type the type of tethering + * @param[in] is_requested whether tethering mode is enabled + * @param[in] data the pointer to the user data + */ +static void __enabled_cb(tethering_error_e error, tethering_type_e type, bool is_requested, void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + tethering_error_e ret = TETHERING_ERROR_NONE; + tethering_h th = NULL; + bool is_wifi_enabled = false; + + if (error != TETHERING_ERROR_NONE) { + if (is_requested != TRUE) { + return; + } + + DBG(LOG_ERROR, "error !!! TETHERING is not enabled.\n"); + return; + } + + th = ugd->hotspot_handle; + if (th != NULL) { + is_wifi_enabled = tethering_is_enabled(th, TETHERING_TYPE_WIFI); + if (is_wifi_enabled) { + DBG(LOG_INFO, "Mobile hotspot is activated\n"); + } + + /* Deregister cbs */ + ret = tethering_unset_enabled_cb(th, TETHERING_TYPE_WIFI); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_enabled_cb is failed(%d)\n", ret); + } + + /* Destroy tethering handle */ + ret = tethering_destroy(th); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_destroy is failed(%d)\n", ret); + } + + ugd->hotspot_handle = NULL; + } + + DBG(LOG_INFO, "TETHERING is enabled.\n"); + + __FUNC_EXIT__; + return; } +/** + * This function let the ug make a callback for setting tethering mode disabled + * @return void + * @param[in] error the returned error code + * @param[in] type the type of tethering + * @param[in] code whether tethering mode is enabled + * @param[in] data the pointer to the user data + */ static void __disabled_cb(tethering_error_e error, tethering_type_e type, tethering_disabled_cause_e code, void *data) { __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + tethering_error_e ret = TETHERING_ERROR_NONE; + tethering_h th = NULL; + bool is_wifi_enabled = false; + bool is_wifi_ap_enabled = false; + if (error != TETHERING_ERROR_NONE) { - if (code != TETHERING_DISABLED_BY_REQUEST) { return; } + DBG(LOG_ERROR, "error !!! TETHERING is not disabled.\n"); return; } - DBG(LOG_VERBOSE, "TETHERING is disabled.\n"); + th = ugd->hotspot_handle; + if (th != NULL) { + is_wifi_enabled = tethering_is_enabled(th, TETHERING_TYPE_WIFI); + is_wifi_ap_enabled = tethering_is_enabled(th, TETHERING_TYPE_RESERVED); + if (is_wifi_enabled || is_wifi_ap_enabled) { + DBG(LOG_ERROR, "error !!! TETHERING is not disabled.\n"); + DBG(LOG_ERROR, "is_wifi_enabled:%d is_wifi_ap_enabled:%d\n", is_wifi_enabled, is_wifi_ap_enabled); + return; + } - __FUNC_EXIT__; + DBG(LOG_INFO, "Mobile hotspot is deactivated\n"); + wfd_client_swtch_force(ugd, TRUE); + + ret = tethering_unset_disabled_cb(th, TETHERING_TYPE_WIFI); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_disabled_cb is failed(%d)\n", ret); + } + + ret = tethering_unset_disabled_cb(th, TETHERING_TYPE_RESERVED); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_disabled_cb is failed(%d)\n", ret); + } + /* Destroy tethering handle */ + ret = tethering_destroy(th); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_destroy is failed(%d)\n", ret); + } + + ugd->hotspot_handle = NULL; + } + + DBG(LOG_INFO, "TETHERING is disabled.\n"); + + __FUNC_EXIT__; return; } +/** + * This function let the ug turn AP on + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int wfd_mobile_ap_on(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + tethering_error_e ret = TETHERING_ERROR_NONE; + WFD_RETV_IF(ugd == NULL, -1, "Incorrect parameter(NULL)\n"); + + if (NULL == ugd->hotspot_handle) { + ret = tethering_create(&(ugd->hotspot_handle)); + if (TETHERING_ERROR_NONE != ret) { + DBG(LOG_ERROR, "Failed to tethering_create() [%d]\n", ret); + ugd->hotspot_handle = NULL; + return -1; + } + DBG(LOG_INFO, "Succeeded to tethering_create()\n"); + } + /* Register cbs */ + ret = tethering_set_enabled_cb(ugd->hotspot_handle, TETHERING_TYPE_WIFI, __enabled_cb, ugd); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_set_enabled_cb is failed\n", ret); + return -1; + } + + /* Enable tethering */ + ret = tethering_enable(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to turn on mobile hotspot. [%d]\n", ret); + return -1; + } else { + DBG(LOG_INFO, "Succeeded to turn on mobile hotspot\n"); + } + + ugd->is_hotspot_off = FALSE; -#if 0 -static device_type_s *wfd_client_find_peer_by_ssid(void *data, const char *ssid) + __FUNC_EXIT__; + return 0; +} + +/** + * This function let the ug turn AP off + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int wfd_mobile_ap_off(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int i; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RETV_IF(ugd == NULL || ugd->hotspot_handle == NULL, -1, "Incorrect parameter(NULL)\n"); + tethering_error_e ret = TETHERING_ERROR_NONE; + bool is_wifi_enabled = false; + bool is_wifi_ap_enabled = false; + + is_wifi_enabled = tethering_is_enabled(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + is_wifi_ap_enabled = tethering_is_enabled(ugd->hotspot_handle, TETHERING_TYPE_RESERVED); + + if (is_wifi_enabled) { + /* Register cbs */ + ret = tethering_set_disabled_cb(ugd->hotspot_handle, TETHERING_TYPE_WIFI, __disabled_cb, ugd); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_set_disabled_cb is failed\n", ret); + return -1; + } + /* Disable tethering */ + ret = tethering_disable(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + } else if (is_wifi_ap_enabled) { + ret = tethering_set_disabled_cb(ugd->hotspot_handle, TETHERING_TYPE_RESERVED, __disabled_cb, ugd); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_set_disabled_cb is failed\n", ret); + return -1; + } + ret = tethering_disable(ugd->hotspot_handle, TETHERING_TYPE_RESERVED); + } - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to turn off mobile hotspot. [%d]\n", ret); + return -1; + } else { + DBG(LOG_INFO, "Succeeded to turn off mobile hotspot\n"); + } - for(i=0; i<ugd->gl_available_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "check %dth peer\n", i); - if(!strcmp(ugd->gl_available_peers[i].ssid, ssid)) - { - DBG(LOG_VERBOSE, "found peer. [%d]\n", i); - __FUNC_EXIT__; - return &ugd->gl_available_peers[i]; - } - } - __FUNC_EXIT__; + ugd->is_hotspot_off = TRUE; - return NULL; + __FUNC_EXIT__; + return 0; } -#endif -static device_type_s *wfd_client_find_peer_by_mac(void *data, const char *mac_addr) +void wfd_client_free_raw_discovered_peers(struct ug_data *ugd) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int i; + __FUNC_ENTER__; + WFD_RET_IF(ugd->raw_discovered_peer_list == NULL, "Incorrect parameter(NULL)\n"); - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + g_list_free(ugd->raw_discovered_peer_list); + ugd->raw_discovered_peer_list = NULL; - if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE) - { - for(i=0; i<ugd->raw_multi_selected_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "[Multi Connect] check %dth peer\n", i); - if(!strncmp(mac_addr, (const char*) ugd->raw_multi_selected_peers[i].mac_addr, MAC_LENGTH)) - { - DBG(LOG_VERBOSE, "selected found peer. [%d]\n", i); - __FUNC_EXIT__; + __FUNC_EXIT__; +} + +/** + * This function let the ug find the peer by mac address + * @return the found peer + * @param[in] data the pointer to the main data structure + * @param[in] mac_addr the pointer to mac address + */ +static device_type_s *wfd_client_find_peer_by_mac(void *data, const char *mac_addr) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + wifi_direct_discovered_peer_info_s *peer_info = NULL; + GList *iterator = NULL; + int i; + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); + + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { + for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) { + if (!strncmp(mac_addr, (const char *)ugd->raw_multi_selected_peers[i].mac_addr, MAC_LENGTH)) { return &ugd->raw_multi_selected_peers[i]; } } - } - else - { - for(i=0; i<ugd->raw_discovered_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "check %dth peer\n", i); - if(!strncmp(mac_addr, (const char*) ugd->raw_discovered_peers[i].mac_addr, MAC_LENGTH)) - { - DBG(LOG_VERBOSE, "found peer. [%d]\n", i); - __FUNC_EXIT__; - return &ugd->raw_discovered_peers[i]; + } else { + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if (!strncmp(mac_addr, ((device_type_s *)iterator->data)->mac_addr, MAC_LENGTH)) { + return (device_type_s *)iterator->data; } } + } - } - __FUNC_EXIT__; + /* + * In case, device is not in raw discovered list, then get peer info. + * There could be situation in which device is not yet discovered and + * connected process started. + */ + if (WIFI_DIRECT_ERROR_NONE != wifi_direct_get_peer_info((char *)mac_addr, &peer_info) || + NULL == peer_info) { + DBG(LOG_ERROR, "Peer Not Found !!!"); + return NULL; + } - return NULL; -} + /* Update peer list */ + DBG(LOG_INFO, "Update Peer info"); + _wfd_discoverd_peer_cb(peer_info, (void *)ugd); -int _wfd_ug_view_clean_on_off(struct ug_data *ugd) -{ - wfd_ug_view_update_peers(ugd); - return 0; + /* Get the device from peer list */ + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if (!strncmp(mac_addr, ((device_type_s *)iterator->data)->mac_addr, MAC_LENGTH)) { + return (device_type_s *)iterator->data; + } + } + + __FUNC_EXIT__; + return NULL; } +/** + * This function let the ug make a callback for registering activation event + * @return void + * @param[in] error_code the returned error code + * @param[in] device_state the state of device + * @param[in] user_data the pointer to the main data structure + */ void _activation_cb(int error_code, wifi_direct_device_state_e device_state, void *user_data) { - __FUNC_ENTER__; - int res; - struct ug_data *ugd = (struct ug_data*) user_data; - - wfd_refresh_wifi_direct_state(ugd); + __FUNC_ENTER__; + int res = -1; + struct ug_data *ugd = (struct ug_data *)user_data; + wfd_refresh_wifi_direct_state(ugd); - switch(device_state) - { - case WIFI_DIRECT_DEVICE_STATE_ACTIVATED: - DBG(LOG_VERBOSE, "WIFI_DIRECT_DEVICE_STATE_ACTIVATED\n"); - if(error_code != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Error in Activation/Deactivation [%d]\n", error_code); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_ACTIVATE_FAIL); + switch (device_state) { + case WIFI_DIRECT_DEVICE_STATE_ACTIVATED: + DBG(LOG_INFO, "WIFI_DIRECT_DEVICE_STATE_ACTIVATED\n"); + if(ugd->scan_toolbar == NULL) { + scan_button_create(ugd); + } + if (error_code != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Error in Activation/Deactivation [%d]\n", error_code); + if (WIFI_DIRECT_ERROR_AUTH_FAILED == error_code) { + wfd_ug_warn_popup(ugd, _("IDS_COM_POP_SECURITY_POLICY_RESTRICTS_USE_OF_WI_FI"), POPUP_TYPE_ACTIVATE_FAIL_POLICY_RESTRICTS); + } else { + wfd_ug_warn_popup(ugd, _("IDS_COM_POP_FAILED"), POPUP_TYPE_ACTIVATE_FAIL); + } - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - ugd->wfd_onoff = 0; - wfd_ug_view_refresh_glitem(ugd->head); - return; - } +#ifdef WFD_ON_OFF_GENLIST + ugd->wfd_onoff = 0; + wfd_ug_refresh_on_off_check(ugd); +#endif + return; + } - ugd->head_text_mode = HEAD_TEXT_TYPE_ACTIVATED; - ugd->wfd_onoff = 1; - wfd_ug_view_refresh_glitem(ugd->head); + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; +#ifdef WFD_ON_OFF_GENLIST + ugd->wfd_onoff = 1; + wfd_ug_refresh_on_off_check(ugd); +#endif + wfg_ug_act_popup_remove(ugd); - wfg_ug_act_popup_remove(ugd); + if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_BACKGROUND) { + DBG(LOG_INFO, "Background mode\n"); + return; + } - res = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, _wifi_state_cb); - if(res == -1) - { - DBG(LOG_ERROR, "Failed to ignore vconf key callback for wifi state\n"); - } +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE + res = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, _wifi_state_cb); + if (res == -1) { + DBG(LOG_ERROR, "Failed to ignore vconf key callback for wifi state\n"); + } +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); + wifi_direct_cancel_discovery(); + } - res = wifi_direct_start_discovery(FALSE, 0); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); - } - DBG(LOG_VERBOSE, "Discovery is started\n"); - break; + break; + case WIFI_DIRECT_DEVICE_STATE_DEACTIVATED: + DBG(LOG_INFO, "WIFI_DIRECT_DEVICE_STATE_DEACTIVATED\n"); + if (error_code != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Error in Activation/Deactivation [%d]\n", error_code); + wfd_ug_warn_popup(ugd, _("IDS_WIFI_POP_DEACTIVATION_FAILED"), POPUP_TYPE_DEACTIVATE_FAIL); +#ifdef WFD_ON_OFF_GENLIST + ugd->wfd_onoff = 1; + wfd_ug_refresh_on_off_check(ugd); +#endif + return; + } - case WIFI_DIRECT_DEVICE_STATE_DEACTIVATED: - DBG(LOG_VERBOSE, "WIFI_DIRECT_DEVICE_STATE_DEACTIVATED\n"); - if(error_code != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Error in Activation/Deactivation [%d]\n", error_code); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_DEACTIVATE_FAIL); - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - ugd->wfd_onoff = 1; - wfd_ug_view_refresh_glitem(ugd->head); - return; - } + WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item); - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - ugd->wfd_onoff = 0; + if (ugd->ctxpopup) { + ctxpopup_dismissed_cb(ugd, NULL, NULL); + } - wfd_ug_view_update_peers(ugd); + /* + * When multi-connect is on ongoing and deactivte happened destroy + * disconnect button. + */ + if (ugd->disconnect_btn) { + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + ugd->disconnect_btn = NULL; + elm_object_part_content_set(ugd->layout, "button.big", + ugd->scan_toolbar); + } - break; - default: - break; - } + /* When connect is on ongoing and deactivte happened refresh scan */ + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, + "IDS_WIFI_SK4_SCAN", FALSE); + } + /* Delete pop-up when deactivate happens */ + WFD_IF_DEL_OBJ(ugd->act_popup); + /* Remove timeout handlers */ + if (ugd->timer_stop_progress_bar > 0) + g_source_remove(ugd->timer_stop_progress_bar); - wfd_ug_view_refresh_glitem(ugd->head); + if (ugd->timer_delete_not_alive_peer > 0) + g_source_remove(ugd->timer_delete_not_alive_peer); - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); - } + if (ugd->g_source_multi_connect_next > 0) + g_source_remove(ugd->g_source_multi_connect_next); - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); - } + if (ugd->timer_multi_reset > 0) + g_source_remove(ugd->timer_multi_reset); - __FUNC_EXIT__; - return; -} + /* Delete warn popups for Airplane mode */ + if (NULL != ugd->warn_popup) { + evas_object_del( ugd->warn_popup); + ugd->warn_popup = NULL; + } -bool _wfd_discoverd_peer_cb(wifi_direct_discovered_peer_info_s* peer, void *user_data) -{ - __FUNC_ENTER__; +#ifdef WFD_ON_OFF_GENLIST + ugd->wfd_onoff = 0; + wfd_ug_refresh_on_off_check(ugd); +#endif + /* + * when deactivated, clear all the + * discovered peers and connected peers + */ + wfd_client_free_raw_discovered_peers(ugd); + if (ugd->raw_connected_peer_cnt > 0) { + memset(ugd->raw_connected_peers, 0x00, ugd->raw_connected_peer_cnt*sizeof(device_type_s)); + } + + ugd->raw_discovered_peer_cnt = 0; + ugd->raw_connected_peer_cnt = 0; + + wfd_free_nodivice_item(ugd); + wfd_ug_view_init_genlist(ugd, true); + + if (ugd->multi_navi_item != NULL) { + elm_naviframe_item_pop(ugd->naviframe); + } + + if (TRUE == ugd->is_hotspot_off && TRUE == ugd->is_hotspot_locally_disabled) { + if (0 == wfd_mobile_ap_on(ugd)) { + ugd->is_hotspot_locally_disabled = FALSE; + } + } + + if(ugd->scan_toolbar) { + evas_object_del(ugd->scan_toolbar); + ugd->scan_toolbar = NULL; + } + break; + default: + break; + } + + /*if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, _("IDS_WIFI_SK4_SCAN"), TRUE); + }*/ + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", TRUE); + } - struct ug_data *ugd = (struct ug_data*) user_data; - int peer_cnt = ugd->raw_discovered_peer_cnt; + if (ugd->back_btn) { + elm_object_disabled_set(ugd->back_btn, FALSE); + } - DBG(LOG_VERBOSE, "%dth discovered peer. [%s] [%s]\n", peer_cnt, peer->ssid, peer->mac_address); + __FUNC_EXIT__; + return; +} - strncpy(ugd->raw_discovered_peers[peer_cnt].ssid, peer->ssid, sizeof(ugd->raw_discovered_peers[peer_cnt].ssid)); - ugd->raw_discovered_peers[peer_cnt].category = peer->primary_device_type; - strncpy(ugd->raw_discovered_peers[peer_cnt].mac_addr, peer->mac_address, MAC_LENGTH); - strncpy(ugd->raw_discovered_peers[peer_cnt].if_addr, peer->interface_address, MAC_LENGTH); - ugd->raw_discovered_peers[peer_cnt].is_group_owner = peer->is_group_owner; - ugd->raw_discovered_peers[peer_cnt].is_persistent_group_owner = peer->is_persistent_group_owner; - ugd->raw_discovered_peers[peer_cnt].is_connected = peer->is_connected; +/** + * This function let the ug make a callback for discovering peer + * @return TRUE + * @param[in] peer the pointer to the discovered peer + * @param[in] user_data the pointer to the main data structure + */ +bool _wfd_discoverd_peer_cb(wifi_direct_discovered_peer_info_s *peer, void *user_data) +{ + __FUNC_ENTER__; + WFD_RETV_IF(NULL == peer || NULL == user_data, FALSE, "Incorrect parameter(NULL)\n"); + + struct ug_data *ugd = (struct ug_data *)user_data; + int peer_cnt = ugd->raw_discovered_peer_cnt; + device_type_s *peer_tmp = g_new(device_type_s, 1); + int i; + + DBG_SECURE(LOG_INFO, "%dth discovered peer. [%s] ["MACSECSTR"]\n", peer_cnt, + peer->device_name, MAC2SECSTR(peer->mac_address)); + + if (ugd->device_filter < 0 || peer->primary_device_type == ugd->device_filter) { + strncpy(peer_tmp->ssid, peer->device_name, sizeof(peer_tmp->ssid) - 1); + peer_tmp->ssid[SSID_LENGTH - 1] = '\0'; + peer_tmp->category = peer->primary_device_type; + peer_tmp->sub_category = peer->secondary_device_type; + strncpy(peer_tmp->mac_addr, peer->mac_address, MAC_LENGTH - 1); + peer_tmp->mac_addr[MAC_LENGTH - 1] = '\0'; + strncpy(peer_tmp->if_addr, peer->interface_address, MAC_LENGTH - 1); + peer_tmp->if_addr[MAC_LENGTH - 1] = '\0'; + peer_tmp->is_group_owner = peer->is_group_owner; + peer_tmp->is_persistent_group_owner = peer->is_persistent_group_owner; + peer_tmp->is_connected = peer->is_connected; + peer_tmp->dev_sel_state = FALSE; + + if (TRUE == peer->is_connected) { + peer_tmp->conn_status = PEER_CONN_STATUS_CONNECTED; + } else { + peer_tmp->conn_status = PEER_CONN_STATUS_DISCONNECTED; + } - if (TRUE == peer->is_connected) { - ugd->raw_discovered_peers[peer_cnt].conn_status = PEER_CONN_STATUS_CONNECTED; - } else { - ugd->raw_discovered_peers[peer_cnt].conn_status = PEER_CONN_STATUS_DISCONNECTED; - } + ugd->raw_discovered_peer_list = g_list_append(ugd->raw_discovered_peer_list, peer_tmp); + DBG(LOG_INFO, "\tSSID: [%s]\n", peer_tmp->ssid); + DBG(LOG_INFO, "\tPeer category [%d] -> [%d]\n", peer->primary_device_type, peer_tmp->category); + DBG(LOG_INFO, "\tStatus: [%d]\n", peer_tmp->conn_status); + DBG(LOG_INFO, "\tservice_count: [%d]\n", peer->service_count); + ugd->raw_discovered_peer_cnt++; + } else { + DBG(LOG_INFO, "Unavailable WiFi-Direct Device\n"); + } - DBG(LOG_VERBOSE, "\tSSID: [%s]\n", ugd->raw_discovered_peers[peer_cnt].ssid); - DBG(LOG_VERBOSE, "\tPeer category [%d] -> [%d]\n", peer->primary_device_type, ugd->raw_discovered_peers[peer_cnt].category); - DBG(LOG_VERBOSE, "\tStatus: [%d]\n", ugd->raw_discovered_peers[peer_cnt].conn_status); + WFD_IF_FREE_MEM(peer->device_name); + WFD_IF_FREE_MEM(peer->mac_address); + WFD_IF_FREE_MEM(peer->interface_address); - ugd->raw_discovered_peer_cnt ++; + if (NULL != peer->service_list) + { + for (i=0; i<peer->service_count && peer->service_list[i] != NULL; i++) { + free(peer->service_list[i]); + } + WFD_IF_FREE_MEM(peer->service_list); + } - free(peer->ssid); - free(peer->mac_address); - free(peer->interface_address); - free(peer); + WFD_IF_FREE_MEM(peer); - __FUNC_EXIT__; - return TRUE; + __FUNC_EXIT__; + return TRUE; } -bool _wfd_connected_peer_cb(wifi_direct_connected_peer_info_s* peer, void *user_data) +/** + * This function let the ug make a callback for connected peer + * @return TRUE + * @param[in] peer the pointer to the connected peer + * @param[in] user_data the pointer to the main data structure + */ +bool _wfd_connected_peer_cb(wifi_direct_connected_peer_info_s *peer, void *user_data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) user_data; - int peer_cnt = ugd->raw_connected_peer_cnt; + __FUNC_ENTER__; + WFD_RETV_IF(NULL == peer || NULL == user_data, FALSE, "Incorrect parameter(NULL)\n"); + + struct ug_data *ugd = (struct ug_data *)user_data; + int peer_cnt = ugd->raw_connected_peer_cnt; + int i; + + DBG_SECURE(LOG_INFO, "%dth connected peer. [%s] ["MACSECSTR"]\n", peer_cnt, + peer->device_name, MAC2SECSTR(peer->mac_address)); + + /* + * check wether ug needs to exit + * automatically after successed connection + */ + + char services[256] = {0,}; + DBG(LOG_INFO, "\tservice_count: [%d]\n", peer->service_count); + if (peer->service_count>0) { + unsigned int len = 0; + for (i=0; i<peer->service_count && peer->service_list != NULL; i++) { + snprintf(services + len, 256-len, "%s ", peer->service_list[i]); + len = len + strlen(peer->service_list[i]) + 1; + } + DBG(LOG_INFO, "\tServices: [%s]\n", services); + } + + strncpy(ugd->raw_connected_peers[peer_cnt].ssid, peer->device_name, sizeof(ugd->raw_connected_peers[peer_cnt].ssid) - 1); + ugd->raw_connected_peers[peer_cnt].category = peer->primary_device_type; + ugd->raw_connected_peers[peer_cnt].sub_category = peer->secondary_device_type; + strncpy(ugd->raw_connected_peers[peer_cnt].mac_addr, peer->mac_address, MAC_LENGTH - 1); + strncpy(ugd->raw_connected_peers[peer_cnt].if_addr, peer->interface_address, MAC_LENGTH - 1); + ugd->raw_connected_peers[peer_cnt].conn_status = PEER_CONN_STATUS_CONNECTED; + + DBG(LOG_INFO, "\tStatus: [%d]\n", ugd->raw_connected_peers[peer_cnt].conn_status); + DBG(LOG_INFO, "\tCategory: [%d]\n", ugd->raw_connected_peers[peer_cnt].category); + DBG(LOG_INFO, "\tSSID: [%s]\n", ugd->raw_connected_peers[peer_cnt].ssid); + + ugd->raw_connected_peer_cnt++; + + int error = -1; + bool is_group_owner = FALSE; + error = wifi_direct_is_group_owner(&is_group_owner); + if (error != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Fail to get group_owner_state. ret=[%d]", error); + return FALSE; + } - DBG(LOG_VERBOSE, "%dth connected peer. [%s] [%s]\n", peer_cnt, peer->ssid, peer->mac_address); + if (FALSE == is_group_owner) { + /* to send ip_addr*/ + int ret = -1; + app_control_h control = NULL; + ret = app_control_create(&control); + if (ret) { + DBG(LOG_ERROR, "Failed to create control"); + return FALSE; + } - strncpy(ugd->raw_connected_peers[peer_cnt].ssid, peer->ssid, sizeof(ugd->raw_connected_peers[peer_cnt].ssid)); - ugd->raw_connected_peers[peer_cnt].category = peer->primary_device_type; - strncpy(ugd->raw_connected_peers[peer_cnt].mac_addr, peer->mac_address, MAC_LENGTH); - strncpy(ugd->raw_connected_peers[peer_cnt].if_addr, peer->interface_address, MAC_LENGTH); - ugd->raw_connected_peers[peer_cnt].conn_status = PEER_CONN_STATUS_CONNECTED; + if(peer->ip_address != NULL && strlen(services) != 0 ) { + app_control_add_extra_data(control, "ip_address", peer->ip_address); + app_control_add_extra_data(control, "wfds", services); + ug_send_result(ugd->ug, control); + } + app_control_destroy(control); + } - DBG(LOG_VERBOSE, "\tStatus: [%d]\n", ugd->raw_connected_peers[peer_cnt].conn_status); - DBG(LOG_VERBOSE, "\tCategory: [%d]\n", ugd->raw_connected_peers[peer_cnt].category); - DBG(LOG_VERBOSE, "\tSSID: [%s]\n", ugd->raw_connected_peers[peer_cnt].ssid); + WFD_IF_FREE_MEM(peer->device_name); + WFD_IF_FREE_MEM(peer->mac_address); + WFD_IF_FREE_MEM(peer->interface_address); - ugd->raw_connected_peer_cnt++; + if (NULL != peer->service_list) + { + for (i=0; i<peer->service_count && peer->service_list[i] != NULL; i++) { + free(peer->service_list[i]); + } + WFD_IF_FREE_MEM(peer->service_list); + } - free(peer->ssid); - free(peer->mac_address); - free(peer->interface_address); - free(peer); - __FUNC_EXIT__; - return TRUE; + WFD_IF_FREE_MEM(peer); + + __FUNC_EXIT__; + return TRUE; } +/** + * This function let the ug get the found peers + * @return If success, return 0, else return -1 + * @param[in] ugd the pointer to the main data structure + */ int wfd_ug_get_discovered_peers(struct ug_data *ugd) { + __FUNC_ENTER__; int res = 0; + WFD_RETV_IF(ugd == NULL, -1, "Incorrect parameter(NULL)\n"); + + ugd->raw_discovered_peer_cnt = 0; + wfd_client_free_raw_discovered_peers(ugd); + res = wifi_direct_foreach_discovered_peers(_wfd_discoverd_peer_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->raw_discovered_peer_cnt = 0; + DBG(LOG_ERROR, "Get discovery result failed: %d\n", res); + } + + __FUNC_EXIT__; + return 0; +} - if (ugd==NULL) +/** + * This function let the ug get the connecting peer + * @return If success, return 0, else return -1 + * @param[in] ugd the pointer to the main data structure + */ +int wfd_ug_get_connecting_peer(struct ug_data *ugd) +{ + __FUNC_ENTER__; + int res = 0; + WFD_RETV_IF(ugd == NULL, -1, "Incorrect parameter(NULL)\n"); + char *mac_addr = NULL; + GList *iterator = NULL; + + ugd->mac_addr_connecting = NULL; + res = wifi_direct_get_connecting_peer(&mac_addr); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Get connecting device mac failed: %d\n", res); return -1; + } + DBG_SECURE(LOG_INFO, "Mac Addr Connecting: ["MACSECSTR"]\n", + MAC2SECSTR(mac_addr)); + ugd->mac_addr_connecting = mac_addr; - ugd->raw_discovered_peer_cnt = 0; - res = wifi_direct_foreach_discovered_peers(_wfd_discoverd_peer_cb, (void*) ugd); - if (res != WIFI_DIRECT_ERROR_NONE) - { - ugd->raw_discovered_peer_cnt = 0; - DBG(LOG_ERROR, "Get discovery result failed: %d\n", res); - } + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if (!strncmp(mac_addr, ((device_type_s *)iterator->data)->mac_addr, MAC_LENGTH)) { + ((device_type_s *)iterator->data)->conn_status = PEER_CONN_STATUS_CONNECTING; + } + } + + __FUNC_EXIT__; return 0; } +/** + * This function let the ug get the connected peers + * @return If success, return 0, else return -1 + * @param[in] ugd the pointer to the main data structure + */ int wfd_ug_get_connected_peers(struct ug_data *ugd) { + __FUNC_ENTER__; int res = 0; - - if (ugd==NULL) - return -1; + WFD_RETV_IF(ugd == NULL, -1, "Incorrect parameter(NULL)\n"); ugd->raw_connected_peer_cnt = 0; - res = wifi_direct_foreach_connected_peers(_wfd_connected_peer_cb, (void*) ugd); - if(res != WIFI_DIRECT_ERROR_NONE) - { + res = wifi_direct_foreach_connected_peers(_wfd_connected_peer_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { ugd->raw_connected_peer_cnt = 0; DBG(LOG_ERROR, "Get connected peer failed: %d\n", res); } + + __FUNC_EXIT__; return 0; } -void _discover_cb(int error_code, wifi_direct_discovery_state_e discovery_state, void *user_data) +/** + * This function let the ug exits automatically after successed connection + * @return void + * @param[in] user_data the pointer to the main data structure + */ +void _wfd_ug_auto_exit(void *user_data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) user_data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; - } + usleep(1000); + deinit_wfd_client(ugd); + wfd_destroy_ug(ugd); - if(discovery_state == WIFI_DIRECT_ONLY_LISTEN_STARTED) - { - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - } - else if(discovery_state == WIFI_DIRECT_DISCOVERY_STARTED) - { - ugd->head_text_mode = HEAD_TEXT_TYPE_SCANING; - } - else if(discovery_state == WIFI_DIRECT_DISCOVERY_FOUND) - { - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - } + __FUNC_EXIT__; +} + +gboolean wfd_delete_not_alive_peer_cb(void *user_data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + WFD_RETV_IF(ugd == NULL, FALSE, "Incorrect parameter(NULL)\n"); + + delete_not_alive_peers(ugd, &ugd->gl_avlb_peers_start, &ugd->gl_available_peer_cnt); + delete_not_alive_peers(ugd, &ugd->gl_busy_peers_start, &ugd->gl_busy_peer_cnt); + delete_not_alive_peers(ugd, &ugd->multi_conn_dev_list_start, &ugd->gl_available_dev_cnt_at_multiconn_view); + wfd_ug_view_init_genlist(ugd, false); + wfd_update_multiconnect_device(ugd, false); + __FUNC_EXIT__; + return FALSE; +} - wfd_ug_view_refresh_glitem(ugd->head); - if (WIFI_DIRECT_DISCOVERY_STARTED == discovery_state) { - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE); +gboolean wfd_delete_progressbar_cb(void *user_data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + WFD_RETV_IF(ugd == NULL, FALSE, "Incorrect parameter(NULL)\n"); + + ugd->title_content_mode = TITLE_CONTENT_TYPE_NONE; + if (ugd->raw_discovered_peer_cnt == 0 && + ugd->nodevice_title_item == NULL && + ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_NONE && + ugd->gl_available_peer_cnt == 0) { + _create_no_device_genlist(ugd); + }; + + wfd_ug_view_refresh_glitem(ugd->mcview_title_item); + wfd_ug_view_refresh_glitem(ugd->avlbl_wfd_item); + + if (0 == ugd->gl_available_dev_cnt_at_multiconn_view) { + _create_no_device_multiconnect_genlist(ugd); } - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE); + wfd_refresh_wifi_direct_state(ugd); + if (WIFI_DIRECT_STATE_CONNECTING != ugd->wfd_status && + WIFI_DIRECT_STATE_DISCONNECTING != ugd->wfd_status) { + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", TRUE); + evas_object_data_set(ugd->toolbar, "scan", "scan"); + } + + if (ugd->multiconn_layout) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", TRUE); + DBG(LOG_INFO, "Multiconn button text IDS_WIFI_SK4_SCAN \n"); + + } } - } else { - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); + + __FUNC_EXIT__; + return FALSE; +} + +/** + * This function let the ug make a callback for registering discover event + * @return void + * @param[in] error_code the returned error code + * @param[in] discovery_state the state of discover + * @param[in] user_data the pointer to the main data structure + */ +void discover_cb(int error_code, wifi_direct_discovery_state_e discovery_state, void *user_data) +{ + __FUNC_ENTER__; + int ret; + struct ug_data *ugd = (struct ug_data *)user_data; + + if (ugd == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; } - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { + return; } - } - wfd_ug_get_discovered_peers(ugd); - wfd_ug_get_connected_peers(ugd); + DBG(LOG_INFO, "Discovery event [%d], error_code [%d]\n", discovery_state, error_code); + + if (discovery_state == WIFI_DIRECT_DISCOVERY_STARTED) { + if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START) { + ugd->title_content_mode = TITLE_CONTENT_TYPE_SCANNING; + wfd_cancel_progressbar_stop_timer(ugd); + ugd->timer_stop_progress_bar = g_timeout_add(1000*30, wfd_delete_progressbar_cb, ugd); + /* clear all the previous discovered peers */ + wfd_client_free_raw_discovered_peers(ugd); + + ugd->raw_discovered_peer_cnt = 0; + wfd_ug_view_init_genlist(ugd, false); - wfd_ug_view_update_peers(ugd); + if (ugd->avlbl_wfd_item == NULL) { + _create_available_dev_genlist(ugd); + } + + wfd_ug_view_refresh_glitem(ugd->mcview_title_item); + /* clear not alive peers after 5 secs */ + wfd_cancel_not_alive_delete_timer(ugd); + ugd->timer_delete_not_alive_peer = g_timeout_add(1000*5, wfd_delete_not_alive_peer_cb, ugd); + set_not_alive_peers(ugd->gl_avlb_peers_start); + set_not_alive_peers(ugd->gl_busy_peers_start); + set_not_alive_peers(ugd->multi_conn_dev_list_start); + } + } else if (discovery_state == WIFI_DIRECT_DISCOVERY_FOUND) { + if (ugd->wfd_discovery_status != WIFI_DIRECT_DISCOVERY_NONE) { + wfd_ug_get_discovered_peers(ugd); + wfd_ug_update_available_peers(ugd); + wfd_update_multiconnect_device(ugd, false); + } + } else if (discovery_state == WIFI_DIRECT_DISCOVERY_FINISHED) { + if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_FULL_SCAN_START; + ret = wifi_direct_start_discovery_specific_channel(false, 0, WIFI_DIRECT_DISCOVERY_FULL_SCAN); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery with full scan. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } + } - _wfd_free_multiconnect_device(ugd); - _wfd_update_multiconnect_device(ugd); - //_change_multi_button_title(ugd); + if (WIFI_DIRECT_DISCOVERY_STARTED == discovery_state && + ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START) { + WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item); + if (!ugd->conn_wfd_item) { + elm_object_part_content_set(ugd->layout, "button.big", ugd->scan_toolbar); + } + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK_STOP", TRUE); + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK_STOP", TRUE); + } + } - __FUNC_EXIT__; - return; + __FUNC_EXIT__; + return; } +/** + * This function let the ug make a callback for registering connection event + * @return void + * @param[in] error_code the returned error code + * @param[in] connection_state the state of connection + * @param[in] mac_address the mac address of peer + * @param[in] user_data the pointer to the main data structure + */ void _connection_cb(int error_code, wifi_direct_connection_state_e connection_state, const char *mac_address, void *user_data) { - __FUNC_ENTER__; - - struct ug_data *ugd = (struct ug_data*) user_data; - device_type_s *peer = NULL; - bool owner = FALSE; - int res = 0; - - DBG(LOG_VERBOSE, "Connection event [%d], error_code [%d]\n", connection_state, error_code); - - if(mac_address == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(peer mac is NULL)\n"); - return; - } - DBG(LOG_VERBOSE, "Connection event from %s", mac_address); - - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) - { - peer = wfd_client_find_peer_by_mac(ugd, mac_address); - if (peer != NULL) - { - switch(connection_state) - { - case WIFI_DIRECT_CONNECTION_RSP: - if(error_code == WIFI_DIRECT_ERROR_NONE) - { - ugd->wfd_status = WFD_LINK_STATUS_CONNECTED; - peer->conn_status = PEER_CONN_STATUS_CONNECTED; - } - else - { + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + device_type_s *peer = NULL; + bool owner = FALSE; + int res = 0; + + if (mac_address == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(peer mac is NULL)\n"); + return; + } + + DBG_SECURE(LOG_INFO, "Connection event [%d], error_code [%d], multi_connect_mode [%d] mac ["MACSECSTR"]\n", + connection_state, error_code, ugd->multi_connect_mode, MAC2SECSTR(mac_address)); + + /* when not in connection, mac_address is empty */ + if (connection_state <= WIFI_DIRECT_DISASSOCIATION_IND) { + peer = wfd_client_find_peer_by_mac(ugd, mac_address); + + if (NULL == peer || '\0' == peer->ssid[0]) { + DBG(LOG_ERROR, "invalid peer from connection !!\n"); + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; + goto refresh_button; + } + } + + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { + switch (connection_state) { + case WIFI_DIRECT_CONNECTION_RSP: + DBG(LOG_INFO, "MULTI: WIFI_DIRECT_CONNECTION_RSP\n"); + ugd->mac_addr_connecting = NULL; + if (error_code == WIFI_DIRECT_ERROR_NONE) { + peer->conn_status = PEER_CONN_STATUS_CONNECTED; + wfd_ug_get_connected_peers(ugd); + wfd_ug_update_connected_peers(ugd); + } else { + peer->conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; + peer = find_peer_in_glist(ugd->gl_mul_conn_peers_start, peer->mac_addr); + if ( peer != NULL) { peer->conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; + wfd_ug_view_refresh_glitem(peer->gl_item); } - ugd->g_source_multi_connect_next = g_timeout_add(1000, wfd_multi_connect_next_cb, ugd); - break; - default: - break; } + /* connect the next peer */ + ugd->g_source_multi_connect_next = g_timeout_add(500, wfd_multi_connect_next_cb, ugd); + break; + case WIFI_DIRECT_CONNECTION_IN_PROGRESS: + DBG(LOG_INFO, "MULTI: WIFI_DIRECT_CONNECTION_IN_PROGRESS\n"); + peer->conn_status = PEER_CONN_STATUS_CONNECTING; + peer = find_peer_in_glist(ugd->gl_mul_conn_peers_start, peer->mac_addr); + + if ( peer != NULL) { + peer->conn_status = PEER_CONN_STATUS_CONNECTING; + wfd_ug_view_refresh_glitem(peer->gl_item); + } + + wfd_ug_update_toolbar(ugd); + break; + case WIFI_DIRECT_GROUP_CREATED: + DBG(LOG_INFO, "MULTI: WIFI_DIRECT_GROUP_CREATED\n"); + wfd_cancel_progressbar_stop_timer(ugd); + wfd_delete_progressbar_cb(ugd); + + wfd_ug_view_init_genlist(ugd, true); + wfd_ug_view_update_multiconn_peers(ugd); + wfd_multi_connect_next_cb(ugd); + break; + default: + break; + } + } else { + switch (connection_state) { + case WIFI_DIRECT_CONNECTION_RSP: + DBG(LOG_INFO, "WIFI_DIRECT_CONNECTION_RSP\n"); + wfd_delete_progressbar_cb(ugd); + + if (ugd->act_popup) { + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } + ugd->mac_addr_connecting = NULL; + + if (error_code == WIFI_DIRECT_ERROR_NONE) { + peer->conn_status = PEER_CONN_STATUS_CONNECTED; + wfd_ug_get_connected_peers(ugd); + + /* when auto_exit and not multi-connect*/ + if ((ugd->is_auto_exit)&&(ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_NONE)) { + _wfd_ug_auto_exit(ugd); + } + + if(ugd->ctxpopup != NULL && ugd->more_btn_multiconnect_item) { + elm_object_item_disabled_set(ugd->more_btn_multiconnect_item, TRUE); + } + + wfd_ug_update_connected_peers(ugd); + } else { + peer->conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; + wfd_ug_update_failed_peers(ugd); + } + + wfd_ug_update_toolbar(ugd); + break; + case WIFI_DIRECT_DISASSOCIATION_IND: + DBG(LOG_INFO, "WIFI_DIRECT_DISASSOCIATION_IND\n"); + /* remove any possible popup */ + WFD_IF_DEL_OBJ(ugd->act_popup); + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", TRUE); + + /* change the multi connection mode, it can be connected now */ + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_COMPLETED) { + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; + } + + /* if other peer disconnected, get connected peers and update */ + peer->conn_status = PEER_CONN_STATUS_DISCONNECTED; wfd_ug_get_connected_peers(ugd); - wfd_ug_view_update_peers(ugd); - } - else - { - DBG(LOG_VERBOSE, "peer is not found [%s]", mac_address); - } - goto refresh_button; - } - - - peer = wfd_client_find_peer_by_mac(ugd, mac_address); - - if (NULL == peer || NULL == peer->ssid) { - DBG(LOG_ERROR, "SSID from connection is NULL !!\n"); - goto refresh_button; - } - - switch(connection_state) - { - case WIFI_DIRECT_CONNECTION_RSP: - DBG(LOG_VERBOSE, "WIFI_DIRECT_CONNECTION_RSP\n"); - - if(error_code == WIFI_DIRECT_ERROR_NONE) - { - ugd->wfd_status = WFD_LINK_STATUS_CONNECTED; - peer->conn_status = PEER_CONN_STATUS_CONNECTED; - } - else - { - peer->conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; - } - - wfd_ug_get_connected_peers(ugd); - wfd_ug_view_update_peers(ugd); - break; - case WIFI_DIRECT_DISCONNECTION_RSP: - case WIFI_DIRECT_DISCONNECTION_IND: - case WIFI_DIRECT_DISASSOCIATION_IND: - DBG(LOG_VERBOSE, "WIFI_DIRECT_DISCONNECTION_X\n"); - if(error_code != WIFI_DIRECT_ERROR_NONE) - { - // TODO: show disconnection error popup - return; - } - - if (peer!=NULL) - peer->conn_status = PEER_CONN_STATUS_DISCONNECTED; - else - { - // In case of disconnect_all(), no specific peer is found. - } - - wifi_direct_start_discovery(FALSE, 0); - ugd->wfd_status = WFD_LINK_STATUS_DISCOVERING; - ugd->head_text_mode = HEAD_TEXT_TYPE_SCANING; - - wfd_ug_view_refresh_glitem(ugd->head); - - wfd_ug_get_discovered_peers(ugd); - wfd_ug_get_connected_peers(ugd); - wfd_ug_view_update_peers(ugd); - break; - - case WIFI_DIRECT_CONNECTION_IN_PROGRESS: - DBG(LOG_VERBOSE, "WIFI_DIRECT_CONNECTION_IN_PROGRESS\n"); - peer->conn_status = PEER_CONN_STATUS_CONNECTING; - break; - case WIFI_DIRECT_CONNECTION_REQ: - case WIFI_DIRECT_CONNECTION_WPS_REQ: - DBG(LOG_VERBOSE, "WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ\n"); - break; - default: - break; - } - - if(peer != NULL) - wfd_ug_view_refresh_glitem(peer->gl_item); - - _change_multi_button_title(ugd); + wfd_ug_update_available_peers(ugd); + break; + case WIFI_DIRECT_DISCONNECTION_RSP: + case WIFI_DIRECT_DISCONNECTION_IND: + DBG(LOG_INFO, "WIFI_DIRECT_DISCONNECTION_X\n"); + WFD_IF_DEL_OBJ(ugd->act_popup); + + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + /* when disconnection, clear all the connected peers */ + if (ugd->raw_connected_peer_cnt > 0) { + memset(ugd->raw_connected_peers, 0x00, ugd->raw_connected_peer_cnt*sizeof(device_type_s)); + } -refresh_button: - /* refresh the scan button */ - wfd_refresh_wifi_direct_state(ugd); - if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status || - WIFI_DIRECT_STATE_DISCONNECTING == ugd->wfd_status) { + ugd->raw_connected_peer_cnt = 0; + wfd_ug_view_init_genlist(ugd, true); + if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_BACKGROUND) { + DBG(LOG_INFO, "Background mode\n"); + break; + } + + if (ugd->is_paused == false) { + /* start discovery again */ + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); + wifi_direct_cancel_discovery(); + } + } - res = wifi_direct_is_group_owner(&owner); - if (res == WIFI_DIRECT_ERROR_NONE) { - if (!owner) { - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE); + break; + case WIFI_DIRECT_CONNECTION_IN_PROGRESS: + DBG(LOG_INFO, "WIFI_DIRECT_CONNECTION_IN_PROGRESS\n"); + wfd_ug_update_toolbar(ugd); + wfd_cancel_progressbar_stop_timer(ugd); + wfd_delete_progressbar_cb(ugd); + + if (ugd->multi_navi_item) { + elm_naviframe_item_pop(ugd->naviframe); + } + + ugd->mac_addr_connecting = peer->mac_addr; + ugd->is_conn_incoming = FALSE; + peer->conn_status = PEER_CONN_STATUS_CONNECTING; + peer = find_peer_in_glist(ugd->gl_avlb_peers_start, peer->mac_addr); + if (peer != NULL) { + peer->conn_status = PEER_CONN_STATUS_CONNECTING; + wfd_ug_view_refresh_glitem(peer->gl_item); + } else { + wfd_ug_get_discovered_peers(ugd); + wfd_ug_update_available_peers(ugd); + } + + break; + case WIFI_DIRECT_CONNECTION_REQ: + case WIFI_DIRECT_CONNECTION_WPS_REQ: + ugd->mac_addr_connecting = peer->mac_addr; + ugd->is_conn_incoming = TRUE; + DBG(LOG_INFO, "WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ\n"); + break; + case WIFI_DIRECT_GROUP_DESTROYED: + wfd_ug_update_toolbar(ugd); + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_COMPLETED) { + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; + } else { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); + wifi_direct_cancel_discovery(); + } + } + + break; + default: + break; } + } - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE); +refresh_button: + /* refresh the scan button */ + wfd_refresh_wifi_direct_state(ugd); + if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status || + WIFI_DIRECT_STATE_DISCONNECTING == ugd->wfd_status) { + res = wifi_direct_is_group_owner(&owner); + if (res == WIFI_DIRECT_ERROR_NONE) { + if (!owner) { + if (ugd->scan_toolbar) { + evas_object_data_set(ugd->toolbar, "scan", "scan"); + } + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", FALSE); + } + } + } else { + DBG(LOG_ERROR, "Failed to get whether client is group owner. [%d]\n", res); } - } } else { - DBG(LOG_ERROR, "Failed to get whether client is group owner. [%d]\n", res); + if (ugd->scan_toolbar) { + evas_object_data_set(ugd->toolbar, "scan", "scan"); + } + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", TRUE); + } } - } else { - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); + + __FUNC_EXIT__; + return; +} + +/** + * This function let the ug make a callback for registering ip assigned event + * @return void + * @param[in] mac_address the mac address of peer + * @param[in] ip_address the ip address of peer + * @param[in] interface_address the interface address + * @param[in] user_data the pointer to the main data structure + */ +void _ip_assigned_cb(const char *mac_address, const char *ip_address, const char *interface_address, void *user_data) +{ + __FUNC_ENTER__; + + if (!user_data) { + DBG(LOG_ERROR, "The user_data is NULL\n"); + return; } - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); + struct ug_data *ugd = (struct ug_data *)user_data; + + if (!ip_address || 0 == strncmp(ip_address, "0.0.0.0", 7)) { + DBG(LOG_ERROR,"ip address is invalid.\n"); + return; } - } - __FUNC_EXIT__; - return; + ugd->peer_ip_address = strdup(ip_address); + + + /* to send ip_addr*/ + int ret = -1; + app_control_h control = NULL; + ret = app_control_create(&control); + if (ret) { + DBG(LOG_ERROR, "Failed to create control"); + return; + } + app_control_add_extra_data(control, "ip_address", ugd->peer_ip_address); + app_control_add_extra_data(control, "wfds", ugd->service_name); + ug_send_result(ugd->ug, control); + app_control_destroy(control); + + /* when auto_exit and not multi-connect*/ + if ((ugd->is_auto_exit)&&(ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_NONE)) { + _wfd_ug_auto_exit(ugd); + } + + __FUNC_EXIT__; } -int wfd_get_vconf_status(void *data) +/** + * This function let the ug get wi-fi direct status from vconf + * @return If success, return the wfd status, else return -1 + * @param[in] void + */ +int wfd_get_vconf_status() { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - char *dev_name; + __FUNC_ENTER__; + int wifi_direct_state = 0; - // TODO: get wifi direct status from vconf - // db/mobile_hotspot/wifi_key (string) + /* get wifi direct status from vconf */ + if (vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state) < 0) { + DBG(LOG_ERROR, "Error reading vconf (%s)\n", VCONFKEY_WIFI_DIRECT_STATE); + return -1; + } + DBG(LOG_INFO, "WiFi Direct State [%d]", wifi_direct_state); - dev_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR); // "db/setting/device_name" (VCONF_WFD_APNAME) - if (dev_name == NULL) - { - ugd->dev_name = strdup(DEFAULT_DEV_NAME); - DBG(LOG_ERROR, "The AP name is NULL(setting default value)\n"); - } - else - { - ugd->dev_name = strdup(dev_name); - free(dev_name); - } + __FUNC_EXIT__; + return wifi_direct_state; +} + +/** + * This function let the ug get device name from vconf + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int wfd_get_vconf_device_name(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + char *dev_name = NULL; + + /* get device name from vconf */ + dev_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR); + if (dev_name == NULL) { + ugd->dev_name = strdup(DEFAULT_DEV_NAME); + DBG(LOG_ERROR, "The AP name is NULL(setting default value)\n"); + return -1; + } - __FUNC_EXIT__; + ugd->dev_name = strdup(dev_name); + WFD_IF_FREE_MEM(dev_name); - return 0; + __FUNC_EXIT__; + return 0; } +/** + * This function let the ug refresh current status of wi-fi direct + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ int wfd_refresh_wifi_direct_state(void *data) { - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; int res; wifi_direct_state_e wfd_status; - res = wifi_direct_get_state(&wfd_status); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to get link status. [%d]\n", res); - return -1; - } - DBG(LOG_VERBOSE, "WFD status [%d]", wfd_status); - ugd->wfd_status = wfd_status; - return 0; + + res = wifi_direct_get_state(&wfd_status); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to get link status. [%d]\n", res); + return -1; + } + + DBG(LOG_INFO, "WFD status [%d]", wfd_status); + ugd->wfd_status = wfd_status; + + __FUNC_EXIT__; + return 0; } -int init_wfd_client(void *data) +void wfd_init_ug_by_status(void *user_data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res = 0; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + int res = 0; - res = wifi_direct_initialize(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to initialize wifi direct. [%d]\n", res); - return -1; - } + if(ugd == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } - res = wifi_direct_set_device_state_changed_cb(_activation_cb, (void*) ugd); - res = wifi_direct_set_discovery_state_changed_cb(_discover_cb, (void*) ugd); - res = wifi_direct_set_connection_state_changed_cb(_connection_cb, (void*) ugd); + if (ugd->wfd_status >= WIFI_DIRECT_STATE_ACTIVATED) { + //wfd_ug_get_discovered_peers(ugd); + ugd->title_content_mode = TITLE_CONTENT_TYPE_NONE; + } - /* update WFD status */ - wfd_refresh_wifi_direct_state(ugd); - if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) - ugd->wfd_onoff = 1; - else - ugd->wfd_onoff = 0; + if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) { + wfd_ug_get_connected_peers(ugd); + wfd_ug_update_connected_peers(ugd); + ugd->title_content_mode = TITLE_CONTENT_TYPE_NONE; + wfd_ug_get_discovered_peers(ugd); + wfd_ug_update_available_peers(ugd); + wfd_ug_update_toolbar(ugd); + } - DBG(LOG_VERBOSE, "WFD link status. [%d]\n", ugd->wfd_status); + if (ugd->wfd_status == WIFI_DIRECT_STATE_CONNECTING) { + ugd->title_content_mode = TITLE_CONTENT_TYPE_NONE; + wfd_ug_get_discovered_peers(ugd); + wfd_ug_get_connecting_peer(ugd); + wfd_ug_update_available_peers(ugd); + wfd_ug_update_toolbar(ugd); + } - __FUNC_EXIT__; + if (ugd->wfd_status == WIFI_DIRECT_STATE_ACTIVATED || + ugd->wfd_status == WIFI_DIRECT_STATE_DISCOVERING) { + /* start discovery */ + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); + wifi_direct_cancel_discovery(); + } + } - return 0; + __FUNC_EXIT__; } -int deinit_wfd_client(void *data) +/** + * This function let the ug do initialization + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int init_wfd_client(void* data) { __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + WFD_RETV_IF(data == NULL, -1, "Incorrect parameter(NULL)\n"); + struct ug_data *ugd = (struct ug_data *)data; int res = 0; + + res = wifi_direct_initialize(); + if (res != WIFI_DIRECT_ERROR_NONE) { + if (res != WIFI_DIRECT_ERROR_ALREADY_INITIALIZED) { + DBG(LOG_ERROR, "Failed to initialize wifi direct. [%d]\n", res); + return -1; + } else { + DBG(LOG_ERROR, "Already registered\n"); + } + } + + res = wifi_direct_set_device_state_changed_cb(_activation_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to register _cb_activation. error code = [%d]\n", res); + return -1; + } + + res = wifi_direct_set_discovery_state_changed_cb(discover_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to register _cb_discover. error code = [%d]\n", res); + return -1; + } + + res = wifi_direct_set_connection_state_changed_cb(_connection_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to register _cb_connection. error code = [%d]\n", res); + return -1; + } + + res = wifi_direct_set_client_ip_address_assigned_cb(_ip_assigned_cb, (void *)ugd); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to register _ip_assigned_cb. error code = [%d]\n", res); + return -1; + } + + /* update WFD status */ + wfd_refresh_wifi_direct_state(ugd); +#ifdef WFD_ON_OFF_GENLIST + if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) { + ugd->wfd_onoff = 1; + wfd_ug_refresh_on_off_check(ugd); + } else { + ugd->wfd_onoff = 0; + } +#endif + + DBG(LOG_INFO, "WFD link status. [%d]\n", ugd->wfd_status); + ugd->is_init_ok = TRUE; + wfd_init_ug_by_status(ugd); + + __FUNC_EXIT__; + return 0; +} + +#ifdef WFD_DBUS_LAUNCH +void wfd_gdbus_callback(GObject *source_object, GAsyncResult *result, gpointer user_data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)user_data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + int res = -1; + + GError *error = NULL; + GVariant *return_data; + + g_object_unref(ugd->dbus_cancellable); + ugd->dbus_cancellable = NULL; + ugd->conn = G_DBUS_CONNECTION (source_object); + return_data = g_dbus_connection_call_finish(ugd->conn, result, &error); + + if (error != NULL) { + DBG(LOG_ERROR,"DBus action failed. Error Msg [%s]\n", error->message); + g_clear_error(&error); + } else { + DBG(LOG_INFO, "error msg is NULL\n"); + } + + if (return_data) + g_variant_unref(return_data); + + if (ugd->conn) { + g_object_unref(ugd->conn); + ugd->conn = NULL; + } + + res = init_wfd_client(ugd); + WFD_RET_IF(res != 0, "Failed to initialize WFD client library\n"); + + /* Activate WiFi Direct */ + /* + DBG(LOG_INFO, "Activating WiFi Direct..."); + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + res = wfd_client_switch_on(ugd); + WFD_RET_IF(res != 0, "Failed to activate WFD\n"); + } + */ + + __FUNC_EXIT__; +} + +int launch_wifi_direct_manager(void *data) +{ + __FUNC_ENTER__; + + gchar *addr = NULL; + GError *error = NULL; + + struct ug_data *ugd = (struct ug_data *)data; + WFD_RETV_IF(ugd == NULL, -1, "Incorrect parameter(NULL)\n"); + + ugd->dbus_cancellable = g_cancellable_new(); + + addr = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &error); + WFD_RETV_IF(addr == NULL, -1, "Fail to get dbus addr.\n"); + + ugd->conn = g_dbus_connection_new_for_address_sync(addr,G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | + G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, NULL, NULL); + + if(ugd->conn == NULL) { + DBG(LOG_ERROR,"g_dbus_conn is NULL\n"); + return -1; + } else { + g_dbus_connection_call(ugd->conn, "net.netconfig", "/net/netconfig/wifi","net.netconfig.wifi", + "LaunchDirect", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, ugd->dbus_cancellable, wfd_gdbus_callback, data); + } + + __FUNC_EXIT__; + return 0; +} +#endif + +void wfd_client_destroy_tethering(struct ug_data *ugd) +{ + __FUNC_ENTER__; + tethering_error_e ret = TETHERING_ERROR_NONE; - tethering_h th = NULL; + + if (ugd->hotspot_handle != NULL) { + /* Deregister cbs */ + ret = tethering_unset_enabled_cb(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_enabled_cb is failed(%d)\n", ret); + } + + ret = tethering_unset_disabled_cb(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_disabled_cb is failed(%d)\n", ret); + } + + ret = tethering_unset_disabled_cb(ugd->hotspot_handle, TETHERING_TYPE_RESERVED); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_unset_disabled_cb is failed(%d)\n", ret); + } + + /* Destroy tethering handle */ + ret = tethering_destroy(ugd->hotspot_handle); + if (ret != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "tethering_destroy is failed(%d)\n", ret); + } + + ugd->hotspot_handle = NULL; + } + + __FUNC_EXIT__; +} + +/** + * This function let the ug do de-initialization + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int deinit_wfd_client(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res = 0; wfd_refresh_wifi_direct_state(ugd); - if(ugd->wfd_status == WIFI_DIRECT_STATE_DISCOVERING) - { - DBG(LOG_VERBOSE, "Stop discovery before deregister client\n"); - wifi_direct_cancel_discovery(); + if ((WIFI_DIRECT_STATE_DISCOVERING == ugd->wfd_status) && + (WIFI_DIRECT_ERROR_NONE != wifi_direct_cancel_discovery())) { + DBG(LOG_ERROR, "Failed to send cancel discovery state [%d]\n", ugd->wfd_status); + } + + wfd_cancel_progressbar_stop_timer(ugd); + wfd_cancel_not_alive_delete_timer(ugd); + + if(ugd->timer_multi_reset > 0) { + g_source_remove(ugd->timer_multi_reset); + } + ugd->timer_multi_reset = 0; + + if (ugd->g_source_multi_connect_next > 0) { + g_source_remove(ugd->g_source_multi_connect_next); + } + ugd->g_source_multi_connect_next = 0; + + res = wifi_direct_unset_discovery_state_changed_cb(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to unset discovery state changed cb. [%d]\n", res); + } + + wifi_direct_unset_device_state_changed_cb(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to unset device state changed cb. [%d]\n", res); + } + + wifi_direct_unset_connection_state_changed_cb(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to unset connection state changed cb. [%d]\n", res); + } + + wifi_direct_unset_client_ip_address_assigned_cb(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to unset client ip address assigned cb. [%d]\n", res); } + if (ugd->wfd_status == WIFI_DIRECT_STATE_CONNECTING && + NULL != ugd->mac_addr_connecting) { + if (ugd->is_conn_incoming) { + DBG(LOG_INFO, "Reject the incoming connection before client deregister \n"); + res = wifi_direct_reject_connection(ugd->mac_addr_connecting); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send reject request [%d]\n", res); + } + } else { + DBG(LOG_INFO, "Cancel the outgoing connection before client deregister \n"); + res = wifi_direct_cancel_connection(ugd->mac_addr_connecting); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send cancel request [%d]\n", res); + } + } + ugd->mac_addr_connecting = NULL; + } + + res = wifi_direct_deinitialize(); - if(res != WIFI_DIRECT_ERROR_NONE) - { + if (res != WIFI_DIRECT_ERROR_NONE) { DBG(LOG_ERROR, "Failed to deregister client. [%d]\n", res); } + /* release vconf, hotspot.. */ +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE res = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, _wifi_state_cb); - if(res == -1) - { + if (res == -1) { DBG(LOG_ERROR, "Failed to ignore vconf key callback for wifi state\n"); } res = net_deregister_client(); - if(res != NET_ERR_NONE) - { + if (res != NET_ERR_NONE) { DBG(LOG_ERROR, "Failed to deregister network client. [%d]\n", res); } +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ - __FUNC_EXIT__; + wfd_client_destroy_tethering(ugd); + + __FUNC_EXIT__; return 0; } +/** + * This function let the ug turn wi-fi direct on + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ int wfd_client_switch_on(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res; - - DBG(LOG_VERBOSE, "WFD status [%d]\n", ugd->wfd_status); - - if(ugd->wfd_status < WFD_LINK_STATUS_ACTIVATING) - { - ugd->wfd_status = WFD_LINK_STATUS_ACTIVATING; - - int wifi_state; - res = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state); - if (res != 0) - { - DBG(LOG_ERROR, "Failed to get wifi state from vconf. [%d]\n", res); - // TODO: set genlist head item as "WiFi Direct" - return -1; - } - - if(wifi_state > VCONFKEY_WIFI_OFF) - { - DBG(LOG_VERBOSE, "WiFi is connected, so have to turn off WiFi"); - wfd_ug_act_popup(ugd, _("IDS_WFD_POP_WIFI_OFF"), POPUP_TYPE_WIFI_OFF); // "This will turn off Wi-Fi client operation.<br>Continue?" - } - else // (wifi_state < VCONFKEY_WIFI_CONNECTED && !(hotspot_mode & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI)) - { - res = wifi_direct_activate(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to activate Wi-Fi Direct. error code = [%d]\n", res); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); - - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return -1; - } - } - } - else - { - DBG(LOG_VERBOSE, "Wi-Fi Direct is already activated\n"); - } - - __FUNC_EXIT__; - return 0; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res; + + bool is_wifi_enabled = false; + bool is_wifi_ap_enabled = false; + + + if(!ugd->is_init_ok) { + DBG(LOG_ERROR, "device is initializing, please wait\n"); + return -1; + } + + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "WFD status [%d]\n", ugd->wfd_status); + + if (ugd->wfd_status < WIFI_DIRECT_STATE_ACTIVATING) { + +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE + int wifi_state; + res = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state); + if (res != 0) { + DBG(LOG_ERROR, "Failed to get wifi state from vconf. [%d]\n", res); + return -1; + } +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + ugd->hotspot_handle = NULL; + res = tethering_create(&(ugd->hotspot_handle)); + if (res != TETHERING_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to tethering_create() [%d]\n", res); + return -1; + } else { + DBG(LOG_INFO, "Succeeded to tethering_create()\n"); + } + + is_wifi_enabled = tethering_is_enabled(ugd->hotspot_handle, TETHERING_TYPE_WIFI); + is_wifi_ap_enabled = tethering_is_enabled(ugd->hotspot_handle, TETHERING_TYPE_RESERVED); + +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE + if (wifi_state > VCONFKEY_WIFI_OFF) { + DBG(LOG_INFO, "WiFi is connected, so have to turn off WiFi"); + wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_USING_WI_FI_DIRECT_WILL_DISCONNECT_CURRENT_WI_FI_CONNECTION_CONTINUE_Q"), POPUP_TYPE_WIFI_OFF); + } else +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + if (is_wifi_enabled || is_wifi_ap_enabled) { + DBG(LOG_INFO, "WiFi is connected, so have to turn off WiFi"); + wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_USING_WI_FI_DIRECT_WILL_DISCONNECT_CURRENT_WI_FI_TETHERING_CONTINUE_Q"), POPUP_TYPE_HOTSPOT_OFF); + } else + + { + res = wifi_direct_activate(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to activate Wi-Fi Direct. error code = [%d]\n", res); + wfd_ug_warn_popup(ugd, _("IDS_COM_POP_FAILED"), POPUP_TYPE_TERMINATE); +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); +#endif + return -1; + } + +#ifdef WFD_ON_OFF_GENLIST + if (ugd->on_off_check) { + elm_check_state_set(ugd->on_off_check, TRUE); + elm_object_disabled_set(ugd->on_off_check, TRUE); + } +#endif + /* while activating, disable the buttons */ + if (ugd->scan_toolbar == NULL) { + scan_button_create(ugd); + } + + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->back_btn) { + elm_object_disabled_set(ugd->back_btn, TRUE); + } + } + } else { + DBG(LOG_INFO, "Wi-Fi Direct is already activated\n"); + } + + __FUNC_EXIT__; + return 0; } +/** + * This function let the ug turn wi-fi direct off + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ int wfd_client_switch_off(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res; - DBG(LOG_VERBOSE, "WFD status [%d]\n", ugd->wfd_status); + wfd_ug_view_free_peers(ugd); + wfd_free_nodivice_item(ugd); - if(ugd->wfd_status < WFD_LINK_STATUS_ACTIVATING) - { - DBG(LOG_VERBOSE, "Wi-Fi Direct is already deactivated\n"); - } - else - { - ugd->wfd_status = WFD_LINK_STATUS_DEACTIVATING; + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "WFD status [%d]\n", ugd->wfd_status); - res = wifi_direct_deactivate(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to deactivate Wi-Fi Direct. error code = [%d]\n", res); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); + if (ugd->wfd_status < WIFI_DIRECT_STATE_ACTIVATING) { + DBG(LOG_INFO, "Wi-Fi Direct is already deactivated\n"); + } else { - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return -1; - } - } + wfd_client_destroy_tethering(ugd); - __FUNC_EXIT__; - return 0; -} + wfd_cancel_progressbar_stop_timer(ugd); + wfd_cancel_not_alive_delete_timer(ugd); -int wfd_client_swtch_force(void *data, int onoff) -{ - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res; - - if(onoff) - { - res = wifi_direct_activate(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to activate Wi-Fi Direct. error code = [%d]\n", res); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); - - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return -1; - } - } - else - { - res = wifi_direct_deactivate(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to deactivate Wi-Fi Direct. error code = [%d]\n", res); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); - - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return -1; - } - } - __FUNC_EXIT__; - return 0; -} - -int wfd_client_start_discovery(void *data) -{ - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int res = -1; - -#if 0 - ret = wifi_direct_cancel_discovery(); -// ret = wifi_direct_cancel_discovery(); - if (ret != WIFI_DIRECT_ERROR_NONE) { - DBG(LOG_ERROR, "Failed wfd discover() : %d", ret); - return FALSE; - } - - - if(ugd->wfd_status >= WIFI_DIRECT_STATE_ACTIVATED) - { - res = wifi_direct_start_discovery(FALSE, 30); - if (res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to start wfd discovery. [%d]", res); - return -1; - } - } + if(ugd->timer_multi_reset > 0) { + g_source_remove(ugd->timer_multi_reset); + } + ugd->timer_multi_reset = 0; + + if (ugd->g_source_multi_connect_next > 0) { + g_source_remove(ugd->g_source_multi_connect_next); + } + ugd->g_source_multi_connect_next = 0; + + /*if connected, disconnect all devices*/ + if (WIFI_DIRECT_STATE_CONNECTED == ugd->wfd_status) { + res = wifi_direct_disconnect_all(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send disconnection request to all. [%d]\n", res); + return -1; + } + } + + res = wifi_direct_deactivate(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to deactivate Wi-Fi Direct. error code = [%d]\n", res); + wfd_ug_warn_popup(ugd, _("IDS_WIFI_POP_DEACTIVATION_FAILED"), POPUP_TYPE_TERMINATE_DEACTIVATE_FAIL); +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); #endif + return -1; + } - ugd->wfd_status = WIFI_DIRECT_DISCOVERY_STARTED; - wfd_refresh_wifi_direct_state(ugd); - ugd->head_text_mode = HEAD_TEXT_TYPE_SCANING; - wfd_ug_view_refresh_glitem(ugd->head); - wifi_direct_cancel_discovery(); + /* while deactivating, disable the buttons */ + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", FALSE); + evas_object_del(ugd->scan_toolbar); + ugd->scan_toolbar = NULL; + } - res = wifi_direct_start_discovery(FALSE, 0); - if (res != WIFI_DIRECT_ERROR_NONE) { - DBG(LOG_ERROR, "Fail to restart scanning. %d\n", res); - return -1; - } + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", FALSE); + } - ugd->wfd_status = WIFI_DIRECT_DISCOVERY_FOUND; - wfd_refresh_wifi_direct_state(ugd); + if (ugd->multi_connect_toolbar_item) { + elm_object_item_disabled_set(ugd->multi_connect_toolbar_item, TRUE); + } - __FUNC_EXIT__; - return 0; + if (ugd->back_btn) { + elm_object_disabled_set(ugd->back_btn, TRUE); + } + } + + __FUNC_EXIT__; + return 0; } -int wfd_client_connect(const char *mac_addr) +#ifdef WFD_ON_OFF_GENLIST +/** + * This function let the ug turn wi-fi direct on/off forcely + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + * @param[in] onoff whether to turn on/off wi-fi direct + */ +int wfd_client_swtch_force(void *data, int onoff) { - __FUNC_ENTER__; - int res; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int res; - DBG(LOG_ERROR, "connect to peer=[%s]\n", mac_addr); - res = wifi_direct_connect(mac_addr); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res); - return -1; - } - __FUNC_EXIT__; - return 0; + if (onoff) { + res = wifi_direct_activate(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to activate Wi-Fi Direct. error code = [%d]\n", res); + wfd_ug_warn_popup(ugd, _("IDS_COM_POP_FAILED"), POPUP_TYPE_TERMINATE); + wfd_ug_refresh_on_off_check(ugd); + return -1; + } + } else { + res = wifi_direct_deactivate(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to deactivate Wi-Fi Direct. error code = [%d]\n", res); + wfd_ug_warn_popup(ugd, _("IDS_WIFI_POP_DEACTIVATION_FAILED"), POPUP_TYPE_TERMINATE); + wfd_ug_refresh_on_off_check(ugd); + return -1; + } + } + + __FUNC_EXIT__; + return 0; } +#endif -int wfd_client_disconnect(const char *mac_addr) +/** + * This function let the ug create a group + * @return If success, return 0, else return -1 + */ +int wfd_client_group_add() { - __FUNC_ENTER__; - int res; - - if(mac_addr == NULL) - { - res = wifi_direct_disconnect_all(); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to send disconnection request to all. [%d]\n", res); - return -1; - } - } - else - { - res = wifi_direct_disconnect(mac_addr); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res); - return -1; - } - } - __FUNC_EXIT__; - return 0; + __FUNC_ENTER__; + int res; + + res = wifi_direct_create_group(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to add group"); + __FUNC_EXIT__; + return -1; + } + + __FUNC_EXIT__; + return 0; } -int wfd_client_set_p2p_group_owner_intent(int go_intent) +/** + * This function let the ug connect to the device by mac address + * @return If success, return 0, else return -1 + * @param[in] mac_addr the pointer to the mac address of device + */ +int wfd_client_connect(const char *mac_addr) { - __FUNC_ENTER__; - int res; + __FUNC_ENTER__; + int res; - res = wifi_direct_set_group_owner_intent(go_intent); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to wifi_direct_set_go_intent(%d). [%d]\n", go_intent, res); + DBG_SECURE(LOG_INFO, "connect to peer=["MACSECSTR"]\n", MAC2SECSTR(mac_addr)); + res = wifi_direct_connect((char *)mac_addr); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res); return -1; } - __FUNC_EXIT__; - return 0; + + __FUNC_EXIT__; + return 0; } -int wfd_client_get_peers(struct ug_data *ugd) +/** + * This function let the ug disconnect to the device by mac address + * @return If success, return 0, else return -1 + * @param[in] mac_addr the pointer to the mac address of device + */ +int wfd_client_disconnect(const char *mac_addr) { + __FUNC_ENTER__; + int res; - if(ugd->wfd_status < WFD_LINK_STATUS_ACTIVATED) - { - ugd->raw_discovered_peer_cnt = 0; - ugd->raw_connected_peer_cnt = 0; - return 0; + wifi_direct_cancel_discovery(); + /* + * No need to handle return in cancel discovery as there maybe case + * when framework can return failure. + */ + + if (mac_addr == NULL) { + res = wifi_direct_disconnect_all(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send disconnection request to all. [%d]\n", res); + return -1; + } + } else { + res = wifi_direct_disconnect((char *)mac_addr); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res); + return -1; + } } - if(ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) - { - wfd_ug_get_discovered_peers(ugd); - } + __FUNC_EXIT__; + return 0; +} - if(ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) - { - wfd_ug_get_connected_peers(ugd); - } +/** + * This function let the ug set the intent of a group owner + * @return If success, return 0, else return -1 + * @param[in] go_intent the intent parameter + */ +int wfd_client_set_p2p_group_owner_intent(int go_intent) +{ + __FUNC_ENTER__; + int res; + + res = wifi_direct_set_group_owner_intent(go_intent); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to wifi_direct_set_go_intent(%d). [%d]\n", go_intent, res); + return -1; + } - wfd_ug_view_update_peers(ugd); - _change_multi_button_title(ugd); - return 0; + __FUNC_EXIT__; + return 0; } diff --git a/ug-wifidirect/src/wfd_motion_control.c b/ug-wifidirect/src/wfd_motion_control.c new file mode 100755 index 0000000..385f557 --- /dev/null +++ b/ug-wifidirect/src/wfd_motion_control.c @@ -0,0 +1,204 @@ +/* + * Wi-Fi direct + * + * Copyright 2012 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.tizenopensource.org/license + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include <vconf.h> +#include <sensor_internal.h> +#include <vconf-keys.h> + +#include <libintl.h> +#include <glib.h> + +#include <Elementary.h> +#include <vconf.h> +#include <ui-gadget-module.h> +#include <wifi-direct.h> + +#include "wfd_motion_control.h" +#include "wfd_ug_view.h" +#include "wfd_client.h" + + +static int motion_handle = -1; + +static TARGET_VIEW_FOCUS __motion_target_view_focus_get(void *data) +{ + struct ug_data *ugd = (struct ug_data *)data; + + if ((ugd == NULL) || (ugd->naviframe == NULL)) { + return MOTION_TARGET_VIEW_FOCUS_OFF; + } + + if (elm_object_focus_get(ugd->naviframe)) { + return MOTION_TARGET_VIEW_FOCUS_ON; + } else { + return MOTION_TARGET_VIEW_FOCUS_OFF; + } +} + + +static void __motion_shake_cb(unsigned int event_type, sensor_event_data_t *event_data, void *data) +{ + __FUNC_ENTER__; + + gboolean motion_activated = FALSE; + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR,"NULL pointer!"); + return; + } + TARGET_VIEW_FOCUS focus_state = __motion_target_view_focus_get(ugd); + + DBG(LOG_DEBUG, "event type: %d, focus state: %d\n", event_type, focus_state); + + if (focus_state != MOTION_TARGET_VIEW_FOCUS_ON) { + return; + } + + if (vconf_get_bool(VCONFKEY_SETAPPL_MOTION_ACTIVATION, + (void *)&motion_activated)) { + DBG(LOG_ERROR,"Get motion activation status fail"); + return; + } + + if (FALSE == motion_activated) { + DBG(LOG_INFO,"Motion value is false"); + return; + } + + if (vconf_get_bool(VCONFKEY_SETAPPL_USE_SHAKE, + (void *)&motion_activated)) { + DBG(LOG_ERROR, "Get use shake status fail"); + return; + } + + if (FALSE == motion_activated) { + DBG(LOG_INFO,"Shake status is false"); + return; + } + + int ret = -1; + const char *btn_text = NULL; + + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } + + wfd_refresh_wifi_direct_state(ugd); + + if (NULL == ugd->scan_toolbar) { + DBG(LOG_ERROR, "NULL == ugd->scan_toolbar\n"); + return; + } + + btn_text = elm_object_part_text_get(ugd->scan_toolbar, "default"); + if (NULL == btn_text) { + DBG(LOG_ERROR, "Incorrect button text(NULL)\n"); + return; + } + + GList *iterator = NULL; + + if (0 == strcmp(btn_text, _("IDS_WIFI_SK4_SCAN"))) { + if (WIFI_DIRECT_STATE_CONNECTED == ugd->wfd_status) { + ret = wfd_client_disconnect(NULL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed wfd_client_disconnect() [%d]\n", ret); + __FUNC_EXIT__; + return; + } + + if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE) { + wfd_free_multi_selected_peers(ugd); + } else { + /* update the connecting icon */ + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + ((device_type_s *)iterator->data)->conn_status = PEER_CONN_STATUS_DISCONNECTED; + wfd_ug_view_refresh_glitem(((device_type_s *)iterator->data)->gl_item); + } + } + } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) { + wfd_client_switch_on(ugd); + } else if ((WIFI_DIRECT_STATE_DISCOVERING == ugd->wfd_status) || (WIFI_DIRECT_STATE_ACTIVATED == ugd->wfd_status)) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } + } + + __FUNC_EXIT__; +} + +void motion_create(struct ug_data *ugd) +{ + int ret = -1; + + motion_handle = sf_connect(MOTION_SENSOR); + if (motion_handle < 0) { + DBG(LOG_ERROR, "Failed Operation sf_connect.\n"); + return; + } + ret = sf_register_event(motion_handle, MOTION_ENGINE_EVENT_SHAKE, NULL, + __motion_shake_cb, ugd); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_register_event. [%d]\n", ret); + goto fail; + } + ret = sf_start(motion_handle, 0); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_start. [%d]\n", ret); + goto fail; + } + + DBG(LOG_INFO, "Succesfully, Init Sensor Handle\n"); + return; + +fail: + ret = sf_disconnect(motion_handle); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_disconnect. [%d]\n", ret); + } +} + +void motion_destroy(void) +{ + int ret = -1; + + if (motion_handle < 0) { + DBG(LOG_ERROR, "Motion Handle Not valid !!!"); + return; + } + + ret = sf_stop(motion_handle); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_stop. [%d]\n", ret); + } + ret = sf_unregister_event(motion_handle, MOTION_ENGINE_EVENT_SHAKE); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_unregister_event. [%d]\n", ret); + } + ret = sf_disconnect(motion_handle); + if (ret < 0) { + DBG(LOG_ERROR, "Failed Operation sf_disconnect. [%d]\n", ret); + } +} diff --git a/ug-wifidirect/src/wfd_ug.c b/ug-wifidirect/src/wfd_ug.c index 9c43fca..de5db8c 100755..100644 --- a/ug-wifidirect/src/wfd_ug.c +++ b/ug-wifidirect/src/wfd_ug.c @@ -27,13 +27,18 @@ #include <libintl.h> #include <sys/utsname.h> +#include <vconf.h> #include <Elementary.h> #include <ui-gadget-module.h> -#include <wifi-direct.h> +#include <app_control.h> +#include <wifi-direct.h> #include "wfd_ug.h" #include "wfd_ug_view.h" #include "wfd_client.h" +#ifdef MOTION_CONTROL_ENABLE +#include "wfd_motion_control.h" +#endif void initialize_gen_item_class(); @@ -44,386 +49,837 @@ struct ug_data *wfd_get_ug_data() return global_ugd; } +static void __wfd_main_vconf_change_cb(keynode_t *key, void *data) +{ + __FUNC_ENTER__; + WFD_RET_IF(NULL == key, "ERROR : key is NULL !!\n"); + WFD_RET_IF(NULL == data, "ERROR : data is NULL"); + struct ug_data *ugd = (struct ug_data *) data; + + char *vconf_name = vconf_keynode_get_name(key); + + if (!g_strcmp0(vconf_name, VCONFKEY_SETAPPL_DEVICE_NAME_STR)){ + char *name_value = NULL; + name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR); + WFD_RET_IF (!name_value, "Get string is failed"); + DBG(LOG_INFO,"name : %s", name_value); + + if (ugd->device_name_item && g_strcmp0(ugd->dev_name, name_value)) + wfd_ug_view_refresh_glitem(ugd->device_name_item); + + free(name_value); + } else { + DBG(LOG_ERROR, "vconf_name is error"); + } + __FUNC_EXIT__; +} + +#ifdef WIFI_STATE_CB +static void _wifi_on_state_cb(keynode_t *key, void *data) +{ + WFD_RET_IF(NULL == key, "ERROR : key is NULL !!\n"); + WFD_RET_IF(NULL == data, "ERROR : data is NULL"); + + struct ug_data *ugd = (struct ug_data *)data; + int wifi_state = 0; + + if (vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state) < 0) { + DBG(LOG_ERROR, "Failed to get vconf VCONFKEY_WIFI_STATE\n"); + return; + } + + DBG(LOG_INFO, "WiFi State [%d]\n", wifi_state); + if (wifi_state > VCONFKEY_WIFI_OFF && wifi_state < VCONFKEY_WIFI_STATE_MAX) { + if (WIFI_DIRECT_ERROR_NONE != wifi_direct_get_state(&ugd->wfd_status)) { + DBG(LOG_ERROR, "Failed to Get WiFi Direct State"); + return; + } + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + DBG(LOG_INFO, "Activate WiFi Direct..."); + if (FALSE != wfd_client_switch_on(ugd)) { + DBG(LOG_ERROR, "Failed to Activate WiFi Direct"); + } + } + } +} +#endif + + +static void __wfd_hotspot_mode_vconf_change_cb(keynode_t *key, void *data) +{ + DBG(LOG_INFO, "__wfd_hotspot_mode_vconf_change_cb"); + if (NULL == key || NULL == data) { + DBG(LOG_INFO, "Invalid parameters \n"); + return; + } + struct ug_data *ugd = (struct ug_data *) data; + int hotspot_mode = 0; + int res = 0; + + res = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_mode); + if (res) { + WDS_LOGE("Failed to get vconf value for PLMN(%d)", res); + return; + } + DBG(LOG_INFO, "__wfd_hotspot_mode_vconf_change_cb mode %d", hotspot_mode); + + if (VCONFKEY_MOBILE_HOTSPOT_MODE_NONE == hotspot_mode) { + if (NULL != ugd->act_popup) { + evas_object_del(ugd->act_popup); + } +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); +#endif + } else if (hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI || + hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP) { + if (NULL != ugd->warn_popup) { + evas_object_del(ugd->warn_popup); + ugd->warn_popup = NULL; + } + } + +} + +Ea_Theme_Color_Table *_color_table_set(void) +{ + Ea_Theme_Color_Table *table; + + table = ea_theme_color_table_new(COLOR_TABLE); + DBG(LOG_INFO, "Wi-Fi direct color table : %p", table); + ea_theme_colors_set(table, EA_THEME_STYLE_DEFAULT); + return table; +} + +Ea_Theme_Font_Table *_font_table_set(void) +{ + Ea_Theme_Font_Table *table; + + table = ea_theme_color_table_new(FONT_TABLE); + DBG(LOG_INFO, "Wi-Fi direct font table : %p", table); + ea_theme_fonts_set(table); + + return table; +} + +/** + * This function let the ug create backgroud + * @return backgroud + * @param[in] ugd the pointer to the parent object + * @param[in] ugd the pointer to the main data structure + */ static Evas_Object *_create_bg(Evas_Object *parent, char *style) { - __FUNC_ENTER__; - Evas_Object *bg; + __FUNC_ENTER__; + Evas_Object *bg; - bg = elm_bg_add(parent); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_object_style_set(bg, style); - elm_win_resize_object_add(parent, bg); - evas_object_show(bg); + bg = elm_bg_add(parent); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_object_style_set(bg, style); + evas_object_show(bg); - __FUNC_EXIT__; - return bg; + __FUNC_EXIT__; + return bg; } +/** + * This function let the ug create full view + * @return full view + * @param[in] ugd the pointer to the parent object + * @param[in] ugd the pointer to the main data structure + */ static Evas_Object *_create_fullview(Evas_Object *parent, struct ug_data *ugd) { - __FUNC_ENTER__; - Evas_Object *base; - - if(parent == NULL) - { - DBG(LOG_ERROR, "Incorrenct parameter"); - return NULL; - } - - /* Create Full view */ - base = elm_layout_add(parent); - if(!base) - { - DBG(LOG_ERROR, "Failed to add layout"); - return NULL; - } - - elm_layout_theme_set(base, "layout", "application", "default"); - evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL); - - __FUNC_EXIT__; - return base; + __FUNC_ENTER__; + Evas_Object *base; + + if (parent == NULL) { + DBG(LOG_ERROR, "Incorrenct parameter"); + return NULL; + } + + /* Create Full view */ + base = elm_layout_add(parent); + if (!base) { + DBG(LOG_ERROR, "Failed to add layout"); + return NULL; + } + + elm_layout_theme_set(base, "layout", "application", "default"); + evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL); + + __FUNC_EXIT__; + return base; } +/** + * This function let the ug create frame view + * @return frame view + * @param[in] ugd the pointer to the parent object + * @param[in] ugd the pointer to the main data structure + */ static Evas_Object *_create_frameview(Evas_Object *parent, struct ug_data *ugd) { - __FUNC_ENTER__; - Evas_Object *base; - - if(parent == NULL) - { - DBG(LOG_ERROR, "Incorrenct parameter"); - return NULL; - } - - /* Create Frame view */ - base = elm_layout_add(parent); - if(!base) - { - DBG(LOG_ERROR, "Failed to add layout"); - return NULL; - } - - elm_layout_theme_set(base, "layout", "application", "default"); - evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL); - - __FUNC_EXIT__; - return base; + __FUNC_ENTER__; + Evas_Object *base; + + if (parent == NULL) { + DBG(LOG_ERROR, "Incorrenct parameter"); + return NULL; + } + + /* Create Frame view */ + base = elm_layout_add(parent); + if (!base) { + DBG(LOG_ERROR, "Failed to add layout"); + return NULL; + } + + elm_layout_theme_set(base, "layout", "application", "default"); + evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL); + + __FUNC_EXIT__; + return base; } +/** + * This function let the ug destroy the ug + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_destroy_ug(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + +#ifdef WFD_DBUS_LAUNCH + if (ugd->dbus_cancellable != NULL) { + g_cancellable_cancel(ugd->dbus_cancellable); + g_object_unref(ugd->dbus_cancellable); + ugd->dbus_cancellable = NULL; + if (ugd->conn) { + g_object_unref(ugd->conn); + ugd->conn = NULL; + } + DBG(LOG_INFO, "Cancelled dbus call"); + return; + } else +#endif + { + DBG(LOG_INFO, "dbus_cancellable is NULL"); + ug_destroy_me(ugd->ug); + } -void destroy_wfd_ug_view(void *data) + __FUNC_EXIT__; + return; +} + +static void wfd_ug_layout_del_cb(void *data , Evas *e, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + if (ugd == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)"); + return; + } + + wfd_client_free_raw_discovered_peers(ugd); + wfd_ug_view_free_peers(ugd); + destroy_wfd_ug_view(ugd); - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_EXIT__; +} + +#ifdef WFD_DBUS_LAUNCH +/** + * This function let the ug initialize wfd + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] evas the pointer to the evas canvas + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_init_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + int res = -1; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RET_IF(ugd == NULL || ugd->base == NULL, "Incorrect parameter(NULL)\n"); - if(ugd->genlist) - { - evas_object_del(ugd->genlist); - ugd->genlist = NULL; - } + evas_object_event_callback_del(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb); - if(ugd->naviframe) - { - evas_object_del(ugd->naviframe); - ugd->naviframe = NULL; - } + res = launch_wifi_direct_manager(ugd); + if (res != 0) { + DBG(LOG_ERROR, "Failed to launch wifi direct manager\n"); + } - __FUNC_EXIT__; + __FUNC_EXIT__; + return; } +#endif -static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h service, - void *priv) +static void *on_create(ui_gadget_h ug, enum ug_mode mode, app_control_h control, void *priv) { - __FUNC_ENTER__; - struct ug_data *ugd; - int res = 0; - - if (!ug || !priv) - return NULL; - - ugd = priv; - ugd->ug = ug; - - bindtextdomain(PACKAGE, LOCALEDIR); - - ugd->win = ug_get_window(); - if (!ugd->win) - return NULL; - - if (mode == UG_MODE_FULLVIEW) - ugd->base = _create_fullview(ugd->win, ugd); - else - ugd->base = _create_frameview(ugd->win, ugd); - - if(ugd->base) - { - ugd->bg = _create_bg(ugd->win, "group_list"); - elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg); - } - else - { - DBG(LOG_ERROR, "Failed to create base layout\n"); - return NULL; - } - - wfd_get_vconf_status(ugd); - - initialize_gen_item_class(); - - res = init_wfd_client(ugd); - if(res != 0) - { - DBG(LOG_ERROR, "Failed to initialize WFD client library\n"); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_PROBLEM_WITH_WFD"), POPUP_TYPE_TERMINATE); - } - - create_wfd_ug_view(ugd); - - wfd_ug_view_refresh_glitem(ugd->head); - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE); - } - - if(ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) - { - wfd_ug_get_discovered_peers(ugd); - } - - if(ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) - { - wfd_ug_get_connected_peers(ugd); - } - - wfd_ug_view_update_peers(ugd); - - if (ugd->wfd_status == WIFI_DIRECT_STATE_ACTIVATED) - { - res = wifi_direct_start_discovery(FALSE, 0); - if(res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); - } - DBG(LOG_VERBOSE, "Discovery is started\n"); - } - - evas_object_show(ugd->base); - - __FUNC_EXIT__; - return ugd->base; + __FUNC_ENTER__; + struct ug_data *ugd; + int wfd_status = -1; + int rots[4] = { 0, 90, 180, 270 }; + int ret; + + if (!ug || !priv) { + return NULL; + } + + ugd = priv; + ugd->ug = ug; + + bindtextdomain(PACKAGE, LOCALEDIR); + + ugd->win = ug_get_window(); + if (!ugd->win) { + return NULL; + } + + elm_win_wm_rotation_available_rotations_set(ugd->win, rots, 1); + + + /* check the input parameters from app at first */ + ugd->wfds = NULL; + ugd->device_filter = -1; /* show all devices */ + ugd->is_auto_exit = false; + ugd->is_multi_connect = true; + ugd->is_init_ok = false; + ugd->title = strdup(_("IDS_WIFI_BODY_WI_FI_DIRECT_ABB")); + + if (control) { + char *wfds = NULL; + char *device_filter = NULL; + char *auto_exit = NULL; + char *multi_connect = NULL; + char *title = NULL; + char* viewtype = NULL; + + /* + * get the control name + * default value: Wi-Fi Direct + */ + ret = app_control_get_extra_data(control, "wfds", &wfds); + if (ret == APP_CONTROL_ERROR_NONE && wfds) { + DBG_SECURE(LOG_INFO, "Wfds name: %s", wfds); + ugd->wfds = strdup(wfds); + WFD_IF_FREE_MEM(wfds); + } + + ret = app_control_get_extra_data(control, "viewtype", &viewtype); + if(ret == APP_CONTROL_ERROR_NONE && viewtype) { + DBG(LOG_INFO, "viewtype: %s\n", viewtype); + ugd->view_type = strdup(viewtype); + WFD_IF_FREE_MEM(viewtype); + } + + /* + * get the device filter + * default value: NULL + */ + ret = app_control_get_extra_data(control, "device_filter", &device_filter); + if (ret == APP_CONTROL_ERROR_NONE && device_filter) { + DBG(LOG_INFO, "Device filter: %s", device_filter); + if (0 == strncmp(device_filter, "computer", 8)) { + ugd->device_filter = WFD_DEVICE_TYPE_COMPUTER; + } else if (0 == strncmp(device_filter, "input_device", 12)) { + ugd->device_filter = WFD_DEVICE_TYPE_INPUT_DEVICE; + } else if (0 == strncmp(device_filter, "printer", 6)) { + ugd->device_filter = WFD_DEVICE_TYPE_PRINTER; + } else if (0 == strncmp(device_filter, "camera", 6)) { + ugd->device_filter = WFD_DEVICE_TYPE_CAMERA; + } else if (0 == strncmp(device_filter, "storage", 7)) { + ugd->device_filter = WFD_DEVICE_TYPE_STORAGE; + } else if (0 == strncmp(device_filter, "network_infra", 13)) { + ugd->device_filter = WFD_DEVICE_TYPE_NW_INFRA; + } else if (0 == strncmp(device_filter, "display", 7)) { + ugd->device_filter = WFD_DEVICE_TYPE_DISPLAYS; + } else if (0 == strncmp(device_filter, "multimedia_device", 17)) { + ugd->device_filter = WFD_DEVICE_TYPE_MM_DEVICES; + } else if (0 == strncmp(device_filter, "game_device", 11)) { + ugd->device_filter = WFD_DEVICE_TYPE_GAME_DEVICES; + } else if (0 == strncmp(device_filter, "telephone", 9)) { + ugd->device_filter = WFD_DEVICE_TYPE_TELEPHONE; + } else if (0 == strncmp(device_filter, "audio", 5)) { + ugd->device_filter = WFD_DEVICE_TYPE_AUDIO; + } else { + ugd->device_filter = WFD_DEVICE_TYPE_OTHER; + } + WFD_IF_FREE_MEM(device_filter); + } + + /* + * get whether support auto exit after connection + * default value: false + */ + ret = app_control_get_extra_data(control, "auto_exit", &auto_exit); + if (ret == APP_CONTROL_ERROR_NONE && auto_exit) { + DBG(LOG_INFO, "Auto exit: %s", auto_exit); + if (0 == strncmp(auto_exit, "on", 2)) { + ugd->is_auto_exit = true; + } else { + ugd->is_auto_exit = false; + } + WFD_IF_FREE_MEM(auto_exit); + } + + /* + * get whether support multi connection, + * default value: true + */ + ret = app_control_get_extra_data(control, "multi_connect", &multi_connect); + if (ret == APP_CONTROL_ERROR_NONE && multi_connect) { + DBG(LOG_INFO, "Multi connection: %s", multi_connect); + if (0 == strncmp(multi_connect, "off", 2)) { + ugd->is_multi_connect = false; + } else { + ugd->is_multi_connect = true; + } + WFD_IF_FREE_MEM(multi_connect); + } + + /* + * get the title of UG + * default value: Wi-Fi Direct + */ + ret = app_control_get_extra_data(control, "title_string", &title); + if (ret == APP_CONTROL_ERROR_NONE && title) { + DBG(LOG_INFO, "Title of UG: %s", title); + WFD_IF_FREE_MEM(ugd->title); + ugd->title = strdup(title); + WFD_IF_FREE_MEM(title); + } + } + + if (mode == UG_MODE_FULLVIEW) { + ugd->base = _create_fullview(ugd->win, ugd); + } else { + ugd->base = _create_frameview(ugd->win, ugd); + } + + if (ugd->base) { + evas_object_event_callback_add(ugd->base, EVAS_CALLBACK_DEL, wfd_ug_layout_del_cb, ugd); + ugd->bg = _create_bg(ugd->win, "group_list"); + elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg); + } else { + DBG(LOG_ERROR, "Failed to create base layout\n"); + return NULL; + } + + /* check status of wifi-direct from vconf */ + wfd_status = wfd_get_vconf_status(); + if (wfd_status < 0) { + return NULL; + } + + /* Enablee Changeable UI feature */ + ea_theme_changeable_ui_enabled_set(EINA_TRUE); + + ugd->color_table = _color_table_set(); + ugd->font_table = _font_table_set(); + + /* draw UI */ + initialize_gen_item_class(); + create_wfd_ug_view(ugd); + wfd_ug_view_init_genlist(ugd, true); +#ifdef MOTION_CONTROL_ENABLE + motion_create(ugd); +#endif + + /* + * if not deactivated, do initialization at once; + * otherwise, do initialization later + */ + if (wfd_status != VCONFKEY_WIFI_DIRECT_DEACTIVATED) { + init_wfd_client(ugd); + } else { + ugd->wfd_status = WIFI_DIRECT_STATE_DEACTIVATED; + +#ifdef WFD_DBUS_LAUNCH + evas_object_event_callback_add(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb, ugd); +#else + ret = init_wfd_client(ugd); + WFD_RETV_IF(ret != 0, NULL, "Failed to initialize WFD client library\n"); + + /* Activate WiFi Direct */ + DBG(LOG_INFO, "Activating WiFi Direct..."); + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + ret = wfd_client_switch_on(ugd); + WFD_RETV_IF(ret != 0, NULL, "Failed to activate WFD\n"); + } +#endif + } + ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, + __wfd_main_vconf_change_cb, ugd); + if (ret) { + DBG(LOG_ERROR, "Failed to set vconf notification callback(VCONFKEY_SETAPPL_DEVICE_NAME_STR)"); + } + +#ifdef WIFI_STATE_CB + ret = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, _wifi_on_state_cb, ugd); + if (ret) { + DBG(LOG_ERROR, "Failed to set vconf notification callback(VCONFKEY_WIFI_STATE)"); + + } +#endif + + ret = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_MODE, + __wfd_hotspot_mode_vconf_change_cb, ugd); + if (ret) { + DBG(LOG_ERROR, "Failed to set vconf notification callback(MOBILE_HOTSPOT_MODE)"); + } + + __FUNC_EXIT__; + return ugd->base; } -static void on_start(ui_gadget_h ug, service_h service, void *priv) +static void on_start(ui_gadget_h ug, app_control_h control, void *priv) { - __FUNC_ENTER__; - struct ug_data *ugd; - int res; - - if (!ug || !priv) - return; - - ugd = priv; - - struct utsname kernel_info; - res = uname(&kernel_info); - if(res != 0) - { - DBG(LOG_ERROR, "Failed to detect target type\n"); - } - else - { - DBG(LOG_VERBOSE, "HW ID of this device [%s]\n", kernel_info.machine); - if(strncmp(kernel_info.machine, "arm", 3) != 0) - { - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_NOT_SUPPORTED_DEVICE"), POPUP_TYPE_TERMINATE); - return; - } - } - __FUNC_EXIT__; + __FUNC_ENTER__; + struct ug_data *ugd; + int res; + + if (!ug || !priv) { + return; + } + + ugd = priv; + + struct utsname kernel_info; + res = uname(&kernel_info); + if (res != 0) { + DBG(LOG_ERROR, "Failed to detect target type\n"); + } else { + DBG_SECURE(LOG_INFO, "HW ID of this device [%s]\n", kernel_info.machine); + if (strncmp(kernel_info.machine, "arm", 3) != 0) { + wfd_ug_warn_popup(ugd, _("IDS_ST_POP_NOT_SUPPORTED"), POPUP_TYPE_TERMINATE_NOT_SUPPORT); + return; + } + } + + __FUNC_EXIT__; } -static void on_pause(ui_gadget_h ug, service_h service, void *priv) +static void on_pause(ui_gadget_h ug, app_control_h control, void *priv) { - __FUNC_ENTER__; - __FUNC_EXIT__; + __FUNC_ENTER__; + + WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n"); + struct ug_data *ugd = priv; + ugd->is_paused = true; + + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "on pause, wfd status: %d\n", ugd->wfd_status); + + if ((WIFI_DIRECT_STATE_DISCOVERING == ugd->wfd_status) && + (WIFI_DIRECT_ERROR_NONE != wifi_direct_cancel_discovery())) { + DBG(LOG_ERROR, "Failed to send cancel discovery state [%d]\n", ugd->wfd_status); + __FUNC_EXIT__; + return; + } + + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED; + + __FUNC_EXIT__; } -static void on_resume(ui_gadget_h ug, service_h service, void *priv) +static void on_resume(ui_gadget_h ug, app_control_h control, void *priv) { - __FUNC_ENTER__; - __FUNC_EXIT__; + __FUNC_ENTER__; + + WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n"); + struct ug_data *ugd = priv; + ugd->is_paused = false; + int ret; + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "on resume, status: %d\n", ugd->wfd_status); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED; + + elm_genlist_realized_items_update(ugd->genlist); + + if (ugd->wfd_status > WIFI_DIRECT_STATE_DEACTIVATED && ugd->wfd_status < WIFI_DIRECT_STATE_CONNECTED) { + DBG(LOG_INFO, "Start discovery again\n"); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } + + __FUNC_EXIT__; } -static void on_destroy(ui_gadget_h ug, service_h service, void *priv) +static void on_destroy(ui_gadget_h ug, app_control_h control, void *priv) { - __FUNC_ENTER__; - - if (!ug || !priv) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - struct ug_data *ugd = priv; - if (ugd == NULL || ugd->base == NULL) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - deinit_wfd_client(ugd); - DBG(LOG_VERBOSE, "WFD client deregistered"); - - destroy_wfd_ug_view(ugd); - DBG(LOG_VERBOSE, "Destroying About item"); - - wfd_ug_view_free_peers(ugd); - - DBG(LOG_VERBOSE, "WFD client deregistered"); - if(ugd->bg) - { - evas_object_del(ugd->bg); - ugd->bg = NULL; - } - DBG(LOG_VERBOSE, "WFD client deregistered"); - - if(ugd->base) - { - evas_object_del(ugd->base); - ugd->base = NULL; - } - - __FUNC_EXIT__; - return; + __FUNC_ENTER__; + + WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n"); + + struct ug_data *ugd = priv; + int ret; + WFD_RET_IF(ugd->base == NULL, "The param is NULL\n"); + +#ifdef MOTION_CONTROL_ENABLE + motion_destroy(); +#endif + + /* DeInit WiFi Direct */ + ret = deinit_wfd_client(ugd); + if (ret) { + DBG(LOG_ERROR,"Failed to DeInit WiFi Direct"); + } + + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, + _("IDS_WIFI_SK4_SCAN"), FALSE); + } + + ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, + __wfd_main_vconf_change_cb); + if (ret == -1) { + DBG(LOG_ERROR,"Failed to ignore vconf key callback\n"); + } + +#ifdef WIFI_STATE_CB + ret = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, _wifi_on_state_cb); + if (ret == -1) { + DBG(LOG_ERROR,"Failed to ignore vconf key callback\n"); + } +#endif + + ret = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_MODE, + __wfd_hotspot_mode_vconf_change_cb); + if (ret == -1) { + DBG(LOG_ERROR,"Failed to ignore vconf key callback MOBILE_HOTSPOT_MODE\n"); + } + + wfd_ug_view_free_peers(ugd); + WFD_IF_FREE_MEM(ugd->title); + WFD_IF_FREE_MEM(ugd->wfds); + WFD_IF_FREE_MEM(ugd->view_type); + + WFD_IF_DEL_OBJ(ugd->bg); + +#ifdef WFD_DBUS_LAUNCH + if (ugd->base) + evas_object_event_callback_del(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb); +#endif + WFD_IF_DEL_OBJ(ugd->base); + DBG(LOG_INFO, "WFD client deregistered"); + + __FUNC_EXIT__; + return; } -static void on_message(ui_gadget_h ug, service_h msg, service_h service, - void *priv) +static void on_message(ui_gadget_h ug, app_control_h msg, app_control_h control, void *priv) { - __FUNC_ENTER__; - __FUNC_EXIT__; + __FUNC_ENTER__; + char* app_msg = NULL; + struct ug_data *ugd = priv; + + if (!ug || !priv) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } + + if (msg) { + app_control_get_extra_data(msg, "msg", &app_msg); + DBG(LOG_DEBUG, "Msg from app: %s", app_msg); + + if (!strcmp(app_msg, "destroy")) { + if(!ugd->rename_popup) { + DBG(LOG_INFO, "Destroying UG."); + wfd_ug_view_free_peers(ugd); + wfd_destroy_ug(ugd); + } + } + WFD_IF_FREE_MEM(app_msg); + } + __FUNC_EXIT__; } -static void on_event(ui_gadget_h ug, enum ug_event event, service_h service, - void *priv) +static void on_event(ui_gadget_h ug, enum ug_event event, app_control_h control, void *priv) { - __FUNC_ENTER__; - - if (!ug || !priv) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - switch (event) - { - case UG_EVENT_LOW_MEMORY: - DBG(LOG_VERBOSE, "UG_EVENT_LOW_MEMORY\n"); - break; - case UG_EVENT_LOW_BATTERY: - DBG(LOG_VERBOSE, "UG_EVENT_LOW_BATTERY\n"); - break; - case UG_EVENT_LANG_CHANGE: - DBG(LOG_VERBOSE, "UG_EVENT_LANG_CHANGE\n"); - break; - case UG_EVENT_ROTATE_PORTRAIT: - DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT\n"); - break; - case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN: - DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN\n"); - break; - case UG_EVENT_ROTATE_LANDSCAPE: - DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE\n"); - break; - case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN: - DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN\n"); - break; - default: - DBG(LOG_VERBOSE, "default\n"); - break; - } - - __FUNC_EXIT__; + __FUNC_ENTER__; + + if (!ug || !priv) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } + + switch (event) { + case UG_EVENT_LOW_MEMORY: + DBG(LOG_INFO, "UG_EVENT_LOW_MEMORY\n"); + break; + case UG_EVENT_LOW_BATTERY: + DBG(LOG_INFO, "UG_EVENT_LOW_BATTERY\n"); + break; + case UG_EVENT_LANG_CHANGE: + DBG(LOG_INFO, "UG_EVENT_LANG_CHANGE\n"); + break; + case UG_EVENT_ROTATE_PORTRAIT: + _ctxpopup_move(); + DBG(LOG_INFO, "UG_EVENT_ROTATE_PORTRAIT\n"); + break; + case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN: + DBG(LOG_INFO, "UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN\n"); + break; + case UG_EVENT_ROTATE_LANDSCAPE: + _ctxpopup_move(); + DBG(LOG_INFO, "UG_EVENT_ROTATE_LANDSCAPE\n"); + break; + case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN: + _ctxpopup_move(); + DBG(LOG_INFO, "UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN\n"); + break; + default: + DBG(LOG_INFO, "default\n"); + break; + } + + __FUNC_EXIT__; } -static void on_key_event(ui_gadget_h ug, enum ug_key_event event, - service_h service, void *priv) +static void on_key_event(ui_gadget_h ug, enum ug_key_event event, app_control_h control, void *priv) { - __FUNC_ENTER__; - - if (!ug || !priv) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - switch (event) - { - case UG_KEY_EVENT_END: - DBG(LOG_VERBOSE, "UG_KEY_EVENT_END\n"); - break; - default: - break; - } - - __FUNC_EXIT__; + __FUNC_ENTER__; + + if (!ug || !priv) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } + + switch (event) { + case UG_KEY_EVENT_END: + DBG(LOG_INFO, "UG_KEY_EVENT_END\n"); + break; + default: + break; + } + + __FUNC_EXIT__; } UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops) { - __FUNC_ENTER__; - struct ug_data *ugd; - - if (!ops) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return -1; - } - - ugd = calloc(1, sizeof(struct ug_data)); - if (ugd == NULL) - { - DBG(LOG_ERROR, "Failed to allocate memory for UG data\n"); - return -1; - } - - global_ugd = ugd; - - ops->create = on_create; - ops->start = on_start; - ops->pause = on_pause; - ops->resume = on_resume; - ops->destroy = on_destroy; - ops->message = on_message; - ops->event = on_event; - ops->key_event = on_key_event; - ops->priv = ugd; - ops->opt = UG_OPT_INDICATOR_ENABLE; - - __FUNC_EXIT__; - return 0; + __FUNC_ENTER__; + struct ug_data *ugd; + + if (!ops) { + DBG(LOG_ERROR, "The param is NULL\n"); + return -1; + } + + ugd = calloc(1, sizeof(struct ug_data)); + if (ugd == NULL) { + DBG(LOG_ERROR, "Failed to allocate memory for UG data\n"); + return -1; + } + + global_ugd = ugd; + + ops->create = on_create; + ops->start = on_start; + ops->pause = on_pause; + ops->resume = on_resume; + ops->destroy = on_destroy; + ops->message = on_message; + ops->event = on_event; + ops->key_event = on_key_event; + ops->priv = ugd; + ops->opt = UG_OPT_INDICATOR_ENABLE; + + __FUNC_EXIT__; + return 0; } UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops) { - __FUNC_ENTER__; + __FUNC_ENTER__; + + struct ug_data *ugd; - struct ug_data *ugd; + if (!ops) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } - if (!ops) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } + ugd = ops->priv; - ugd = ops->priv; + WFD_IF_FREE_MEM(ugd); - if (ugd) - free(ugd); + __FUNC_EXIT__; +} - __FUNC_EXIT__; +UG_MODULE_API int setting_plugin_reset(app_control_h control, void *priv) +{ + __FUNC_ENTER__; + int res = -1; + wifi_direct_state_e state; + + res = wifi_direct_initialize(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to initialize wifi direct. [%d]\n", res); + return -1; + } + + res = wifi_direct_get_state(&state); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to get link status. [%d]\n", res); + return -1; + } + + if (state < WIFI_DIRECT_STATE_ACTIVATING) { + DBG(LOG_INFO, "No need to reset Wi-Fi Direct.\n"); + } else { + /*if connected, disconnect all devices*/ + if (WIFI_DIRECT_STATE_CONNECTED == state) { + res = wifi_direct_disconnect_all(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send disconnection request to all. [%d]\n", res); + return -1; + } + } + + res = wifi_direct_deactivate(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to reset Wi-Fi Direct. [%d]\n", res); + return -1; + } + } + + res = wifi_direct_deinitialize(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to deinitialize wifi direct. [%d]\n", res); + return -1; + } + + __FUNC_EXIT__; + return 0; } + +UG_MODULE_API int setting_plugin_search_init(app_control_h control, void *priv, char** applocale) +{ + __FUNC_ENTER__; + + *applocale = strdup("ug-setting-wifidirect-efl"); + void *node = NULL; + + Eina_List **pplist = (Eina_List**)priv; + + node = setting_plugin_search_item_add("IDS_WIFI_BUTTON_MULTI_CONNECT", "viewtype:IDS_WIFI_BUTTON_MULTI_CONNECT", NULL, 5, NULL); + *pplist = eina_list_append(*pplist, node); + + __FUNC_EXIT__; + return 0; +} + diff --git a/ug-wifidirect/src/wfd_ug_about_view.c b/ug-wifidirect/src/wfd_ug_about_view.c deleted file mode 100644 index 5c1f7d2..0000000 --- a/ug-wifidirect/src/wfd_ug_about_view.c +++ /dev/null @@ -1,128 +0,0 @@ -/* -* WiFi-Direct UG -* -* Copyright 2012 Samsung Electronics Co., Ltd - -* Licensed under the Flora License, Version 1.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at - -* http://www.tizenopensource.org/license - -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -* -*/ - -#include <libintl.h> - -#include <assert.h> -#include <glib.h> - -#include <Elementary.h> -#include <vconf.h> -#include <ui-gadget-module.h> -#include <wifi-direct.h> - -#include "wfd_ug.h" -#include "wfd_ug_view.h" -#include "wfd_client.h" - -static Elm_Genlist_Item_Class itc; - -static char *_wfd_gl_label_help_dialogue_get(void *data, Evas_Object *obj, const char *part) -{ - DBG(LOG_VERBOSE, "Adding text"); - - if (!strcmp(part, "elm.text.2")) { - return strdup(_("IDS_WFD_BODY_ABOUT_WIFI")); - } - return NULL; -} - -static Evas_Object *_wfd_gl_help_icon_get(void *data, Evas_Object * obj, const char *part) -{ - __FUNC_ENTER__; - - DBG(LOG_VERBOSE, "Current part: %s\n", part); - Evas_Object *label = NULL; - char content[1024] = {0}; - - label = elm_label_add(obj); - snprintf(content, 1024, "<color=#7C7C7CFF><font_size=32>%s</font_size></color>", _("IDS_WFD_BODY_ABOUT_WIFI")); - elm_label_line_wrap_set(label, ELM_WRAP_WORD); - elm_object_text_set(label, content); - evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0); - evas_object_size_hint_align_set(label, EVAS_HINT_FILL, 0.0); - evas_object_show(label); - - __FUNC_EXIT__; - return label; -} - -void _about_view_back_btn_cb(void *data, Evas_Object * obj, void *event_info) -{ - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - if(!ugd) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - elm_naviframe_item_pop(ugd->naviframe); - - __FUNC_EXIT__; - return; -} - -void _wifid_create_about_view(struct ug_data *ugd) -{ - - Evas_Object *back_btn = NULL; - Elm_Object_Item *navi_item = NULL; - Evas_Object *control_bar = NULL; - Elm_Object_Item *item = NULL; - Evas_Object *genlist = NULL; - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)"); - return; - } - - genlist = elm_genlist_add(ugd->naviframe); - elm_object_style_set(genlist, "dialogue"); - - DBG(LOG_VERBOSE, "creating about view"); - elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS); -#if 0 - itc.item_style = "multiline/1text"; - itc.func.text_get = _wfd_gl_label_help_dialogue_get; - itc.func.content_get = NULL; -#else - itc.item_style = "1icon"; - itc.func.text_get = NULL; - itc.func.content_get = _wfd_gl_help_icon_get; -#endif - itc.func.state_get = NULL; - itc.func.del = NULL; - back_btn = elm_button_add(ugd->naviframe); - elm_object_style_set(back_btn, "naviframe/back_btn/default"); - evas_object_smart_callback_add(back_btn, "clicked", _about_view_back_btn_cb, (void*) ugd); - elm_object_focus_allow_set(back_btn, EINA_FALSE); - - item = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - evas_object_show(genlist); - navi_item = elm_naviframe_item_push(ugd->naviframe, _("IDS_WFD_TITLE_ABOUT_WIFI"), back_btn, NULL, genlist, NULL); - - control_bar = elm_toolbar_add(ugd->naviframe); - elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND); - evas_object_show(control_bar); - elm_object_item_part_content_set(navi_item, "controlbar", control_bar); - -} diff --git a/ug-wifidirect/src/wfd_ug_genlist.c b/ug-wifidirect/src/wfd_ug_genlist.c index 836c5b3..0a0a025 100755 --- a/ug-wifidirect/src/wfd_ug_genlist.c +++ b/ug-wifidirect/src/wfd_ug_genlist.c @@ -18,8 +18,6 @@ */ #include <libintl.h> - -#include <assert.h> #include <glib.h> #include <Elementary.h> @@ -31,15 +29,17 @@ #include "wfd_ug_view.h" #include "wfd_client.h" -Elm_Gen_Item_Class sep_itc; -Elm_Gen_Item_Class sep_itc_end; -Elm_Gen_Item_Class head_itc; -Elm_Gen_Item_Class name_itc; +Elm_Gen_Item_Class device_name_title_itc; +#ifdef WFD_ON_OFF_GENLIST +Elm_Gen_Item_Class wfd_onoff_itc; +#endif +Elm_Gen_Item_Class device_name_itc; Elm_Gen_Item_Class title_itc; +Elm_Gen_Item_Class multi_view_title_itc; Elm_Gen_Item_Class peer_itc; +Elm_Gen_Item_Class title_no_device_itc; Elm_Gen_Item_Class noitem_itc; -Elm_Gen_Item_Class help_itc; -Elm_Gen_Item_Class button_itc; +Elm_Gen_Item_Class title_available_itc; Elm_Gen_Item_Class title_conn_itc; Elm_Gen_Item_Class peer_conn_itc; @@ -49,163 +49,226 @@ Elm_Gen_Item_Class peer_busy_itc; Elm_Gen_Item_Class title_multi_connect_itc; Elm_Gen_Item_Class peer_multi_connect_itc; +Elm_Gen_Item_Class select_all_multi_connect_itc; Elm_Gen_Item_Class title_conn_failed_itc; Elm_Gen_Item_Class peer_conn_failed_itc; +#ifdef WFD_ON_OFF_GENLIST +static char *_gl_wfd_onoff_text_get(void *data, Evas_Object *obj, + const char *part) +{ + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + DBG(LOG_INFO, "%s", part); + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); + wfd_get_vconf_device_name(ugd); + char *dev_name; + + if (!g_strcmp0(part,"elm.text.main.left.bottom")) { + DBG(LOG_INFO, "%s", ugd->dev_name); + if (ugd->dev_name) { + dev_name = elm_entry_utf8_to_markup(ugd->dev_name); + if (NULL == dev_name) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return dev_name; + } + } else if (!g_strcmp0(part, "elm.text.sub.left.top")) { + return g_strdup(_("IDS_ST_HEADER_MY_DEVICE_NAME")); + } + __FUNC_EXIT__; + return NULL; +} -static char *_gl_header_label_get(void *data, Evas_Object * obj, const char *part) +static Evas_Object *_gl_wfd_onoff_content_get(void *data,Evas_Object *obj, + const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - DBG(LOG_VERBOSE, "%s", part); - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if(!strcmp(part, "elm.text.1")) - { - DBG(LOG_VERBOSE, "Current text mode [%d]\n", ugd->head_text_mode); - switch(ugd->head_text_mode) - { - case HEAD_TEXT_TYPE_DIRECT: - case HEAD_TEXT_TYPE_ACTIVATED: - case HEAD_TEXT_TYPE_SCANING: - return strdup(dgettext("sys_string", "IDS_COM_OPT1_WI_FI_DIRECT")); - break; - case HEAD_TEXT_TYPE_DEACTIVATING: - return strdup(_("IDS_WFD_BODY_DEACTIVATING")); // "Deactivating Wi-Fi Direct..." - break; - case HEAD_TEXT_TYPE_ACTIVATING: - return strdup(_("IDS_WFD_BODY_ACTIVATING")); //"Activating Wi-Fi Direct..." - break; - default: - break; - } - } - else if(!strcmp(part, "elm.text.1")) - { - return strdup(dgettext("sys_string", "IDS_COM_OPT1_WI_FI_DIRECT")); - } else if(!strcmp(part, "elm.text.2")) - { - return strdup(ugd->dev_name); - } - - __FUNC_EXIT__; - return NULL; + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); + Evas_Object *btn = NULL; + Evas_Object *icon = NULL; + icon = elm_layout_add(obj); + + if (g_strcmp0(part, "elm.icon.2")) { + return NULL; + } + elm_layout_theme_set(icon, "layout", "list/C/type.3", "default"); + btn = elm_check_add(icon); + /* Wi-Fi on indication button */ + btn= elm_check_add(icon); + elm_object_style_set(btn, "on&off"); + evas_object_propagate_events_set(btn, EINA_FALSE); + elm_check_state_set(btn, ugd->wfd_onoff); + evas_object_propagate_events_set(btn, EINA_FALSE); + evas_object_smart_callback_add(btn, "changed",_onoff_changed_cb, ugd); + ugd->on_off_check = btn; + evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + elm_layout_content_set(icon, "elm.swallow.content", btn); + __FUNC_EXIT__; + return icon; } +#endif -static Evas_Object *_gl_header_icon_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the label of header + * @return the label of header + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_device_name_label_get(void *data, Evas_Object *obj, + const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - Evas_Object *onoff = NULL; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if(ugd->head_text_mode == HEAD_TEXT_TYPE_ACTIVATING || - ugd->head_text_mode == HEAD_TEXT_TYPE_DEACTIVATING) - return NULL; - - DBG(LOG_VERBOSE, "%s", part); - onoff = elm_check_add(obj); - elm_object_style_set(onoff, "on&off"); - elm_check_state_set(onoff, ugd->wfd_onoff); - evas_object_smart_callback_add(onoff, "changed", _wfd_onoff_btn_cb, ugd); - evas_object_show(onoff); - - __FUNC_EXIT__; - - return onoff; + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + DBG(LOG_INFO, "%s", part); + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); + wfd_get_vconf_device_name(ugd); + char *dev_name; + + if (!g_strcmp0(part,"elm.text.main.left.bottom")) { + DBG(LOG_INFO, "%s", ugd->dev_name); + if (ugd->dev_name) { + dev_name = elm_entry_utf8_to_markup(ugd->dev_name); + if (NULL == dev_name) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return dev_name; + } + } else if (!g_strcmp0(part, "elm.text.sub.left.top")) { + return g_strdup(_("IDS_ST_HEADER_MY_DEVICE_NAME")); + } + __FUNC_EXIT__; + return NULL; +} + +/** + * This function let the ug get the label of title + * @return the label of titile + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_title_label_get(void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; + + WFD_RETV_IF(data == NULL, NULL, "Incorrect parameter(NULL)\n"); + DBG(LOG_INFO, "%s", part); + if (!g_strcmp0(part, "elm.text.main")) { + return g_strdup(_("IDS_WIFI_HEADER_AVAILABLE_DEVICES_ABB")); + } + __FUNC_EXIT__; + return NULL; } -static char *_gl_name_label_get(void *data, Evas_Object *obj, const char *part) +static char *_gl_title_no_device_label_get(void *data, Evas_Object *obj, + const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + WFD_RETV_IF(data == NULL, NULL, "Incorrect parameter(NULL)\n"); + DBG(LOG_INFO, "%s", part); + if (!g_strcmp0(part, "elm.text.main")) { + return g_strdup(_("IDS_WIFI_HEADER_AVAILABLE_DEVICES_ABB")); + } - DBG(LOG_VERBOSE, "%s", part); + __FUNC_EXIT__; + return NULL; +} - if(!strcmp(part, "elm.text")) - { - return strdup(_("IDS_WFD_TITLE_ABOUT_WIFI")); // "Device name" - } - else if(!strcmp(part, "elm.text.2")) - { - return strdup(ugd->dev_name); - } +static char *_gl_multi_title_label_get(void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; - __FUNC_EXIT__; + WFD_RETV_IF(data == NULL, NULL, "Incorrect parameter(NULL)\n"); + if (!g_strcmp0(part, "elm.text.main")) { + return g_strdup(_("IDS_WIFI_HEADER_AVAILABLE_DEVICES_ABB")); + } - return NULL; + __FUNC_EXIT__; + return NULL; } +static Evas_Object *_gl_multi_title_content_get(void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; + + Evas_Object *progressbar = NULL; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); -static char *_gl_title_label_get(void *data, Evas_Object *obj, - const char *part) + if (!g_strcmp0(part, "elm.icon")) { + if (TITLE_CONTENT_TYPE_SCANNING == ugd->title_content_mode) { + progressbar = elm_progressbar_add(obj); + elm_object_style_set(progressbar, "process_small"); + elm_progressbar_horizontal_set(progressbar, EINA_TRUE); + elm_progressbar_pulse(progressbar, EINA_TRUE); + evas_object_show(progressbar); + return progressbar; + } + } + + __FUNC_EXIT__; + return NULL; +} + +static char *_gl_available_title_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if (!strcmp(part, "elm.text")) - { - if (ugd->multiconn_view_genlist != NULL) - { - // It's called at Multi connect view... - if(ugd->gl_available_dev_cnt_at_multiconn_view > 0) - return strdup(_("IDS_WFD_BODY_AVAILABLE_DEVICES")); // "Available devices" - else - return strdup(_("IDS_WFD_BODY_WIFI_DIRECT_DEVICES")); // "Wi-Fi Direct devices" - } - else - { - // It's called at Main View - if(ugd->gl_available_peer_cnt > 0) - return strdup(_("IDS_WFD_BODY_AVAILABLE_DEVICES")); // "Available devices" - else - return strdup(_("IDS_WFD_BODY_WIFI_DIRECT_DEVICES")); // "Wi-Fi Direct devices" - } - } - - __FUNC_EXIT__; - - return NULL; + __FUNC_ENTER__; + + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO, "available- %s", part); + if (!g_strcmp0(part, "elm.text.main")) { + return g_strdup(_("IDS_WIFI_HEADER_AVAILABLE_DEVICES_ABB")); + } + + __FUNC_EXIT__; + return NULL; } +/** + * This function let the ug get the content of titile + * @return the content of titile + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ static Evas_Object *_gl_title_content_get(void *data, Evas_Object *obj, const char *part) { + __FUNC_ENTER__; + Evas_Object *progressbar = NULL; - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) data; if (data == NULL) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return NULL; } - if (!strcmp(part, "elm.icon")) { - if (HEAD_TEXT_TYPE_SCANING == ugd->head_text_mode) { + DBG(LOG_INFO, "Title content- %s", part); + + if (!g_strcmp0(part, "elm.icon")) { + if (TITLE_CONTENT_TYPE_SCANNING == ugd->title_content_mode) { progressbar = elm_progressbar_add(obj); - elm_object_style_set(progressbar, "list_process_small"); + elm_object_style_set(progressbar, "process_small"); elm_progressbar_horizontal_set(progressbar, EINA_TRUE); elm_progressbar_pulse(progressbar, EINA_TRUE); evas_object_show(progressbar); @@ -214,589 +277,756 @@ static Evas_Object *_gl_title_content_get(void *data, Evas_Object *obj, const ch } } + __FUNC_EXIT__; return progressbar; } -static char *_gl_peer_label_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the label of peer item + * @return the label of peer item + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_peer_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - assertm_if(NULL == obj, "NULL!!"); - assertm_if(NULL == part, "NULL!!"); - - device_type_s *peer = (device_type_s*) data; - char buf[WFD_GLOBALIZATION_STR_LENGTH] = { 0, }; - DBG(LOG_VERBOSE, "%s", part); - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if (!strcmp(part, "elm.text.1")) - { - __FUNC_EXIT__; - return strdup(peer->ssid); - } - else if (!strcmp(part, "elm.text.2")) - { - switch (peer->conn_status) { - case PEER_CONN_STATUS_DISCONNECTED: - g_strlcpy(buf, _("IDS_WFD_TAP_TO_CONNECT"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - - case PEER_CONN_STATUS_CONNECTING: - g_strlcpy(buf, _("IDS_WFD_CONNECTING"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - - case PEER_CONN_STATUS_CONNECTED: - g_strlcpy(buf, _("IDS_WFD_CONNECTED"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - - case PEER_CONN_STATUS_FAILED_TO_CONNECT: - g_strlcpy(buf, _("IDS_WFD_FAILED_TO_CONNECT"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - - case PEER_CONN_STATUS_WAIT_FOR_CONNECT: - g_strlcpy(buf, _("IDS_WFD_WAITING_FOR_CONNECT"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - - default: - g_strlcpy(buf, _("IDS_WFD_TAP_TO_CONNECT"), - WFD_GLOBALIZATION_STR_LENGTH); - break; - } - } - else - { - __FUNC_EXIT__; - return NULL; - } - - __FUNC_EXIT__; - return strdup(buf); + __FUNC_ENTER__; + + assertm_if(NULL == obj, "NULL!!"); + assertm_if(NULL == part, "NULL!!"); + device_type_s *peer = (device_type_s *) data; + char buf[WFD_GLOBALIZATION_STR_LENGTH] = { 0, }; + char *ssid; + + DBG(LOG_INFO, "%s", part); + + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + + if (!g_strcmp0(part, "elm.text.main.left.top")) { + if (strlen(peer->ssid) != 0) { + ssid = elm_entry_utf8_to_markup(peer->ssid); + if (NULL == ssid) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return ssid; + } + } else if (!g_strcmp0(part, "elm.text.sub.left.bottom")) { + switch (peer->conn_status) { + case PEER_CONN_STATUS_DISCONNECTED: + g_strlcpy(buf, _("IDS_CHATON_BODY_AVAILABLE"), WFD_GLOBALIZATION_STR_LENGTH); + break; + case PEER_CONN_STATUS_CONNECTING: + g_strlcpy(buf, _("IDS_WIFI_BODY_CONNECTING_ING"), WFD_GLOBALIZATION_STR_LENGTH); + break; + case PEER_CONN_STATUS_CONNECTED: + if (peer->is_group_owner == FALSE) { + g_strlcpy(buf, _("IDS_COM_BODY_CONNECTED_M_STATUS"), WFD_GLOBALIZATION_STR_LENGTH); + } else { + g_strlcpy(buf, _("IDS_CHATON_BODY_AVAILABLE"), WFD_GLOBALIZATION_STR_LENGTH); + } + break; + case PEER_CONN_STATUS_FAILED_TO_CONNECT: + g_strlcpy(buf, _("IDS_CHATON_HEADER_CONNECTION_FAILED_ABB2"), WFD_GLOBALIZATION_STR_LENGTH); + break; + case PEER_CONN_STATUS_WAIT_FOR_CONNECT: + g_strlcpy(buf, _("IDS_WIFI_BODY_WAITING_FOR_CONNECTION_M_STATUS_ABB"), WFD_GLOBALIZATION_STR_LENGTH); + break; + default: + g_strlcpy(buf, _("IDS_CHATON_BODY_AVAILABLE"), WFD_GLOBALIZATION_STR_LENGTH); + break; + } + } else { + __FUNC_EXIT__; + return NULL; + } + + __FUNC_EXIT__; + return g_strdup(buf); } -static Evas_Object *_gl_peer_icon_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the icon of peer item + * @return the icon of peer item + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static Evas_Object *_gl_peer_icon_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - assertm_if(NULL == obj, "NULL!!"); - assertm_if(NULL == part, "NULL!!"); - - device_type_s *peer = (device_type_s*) data; - Evas_Object *icon = NULL; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if(!strcmp(part, "elm.icon.2")) - { - DBG(LOG_VERBOSE, "elm.icon.2 - connection status [%d]\n", peer->conn_status); - if(peer->conn_status == PEER_CONN_STATUS_CONNECTING) - { - icon = elm_progressbar_add(obj); - elm_object_style_set(icon, "list_process"); - elm_progressbar_pulse(icon, EINA_TRUE); - } - else if(peer->conn_status == PEER_CONN_STATUS_CONNECTED) - { -#if 0 - icon = elm_icon_add(obj); - elm_icon_file_set(icon, WFD_ICON_CONNECTED, NULL); -#endif - return NULL; - } - - evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1); - elm_icon_resizable_set(icon, 1, 1); - evas_object_show(icon); - } - else if(!strcmp(part, "elm.icon.1")) - { - DBG(LOG_VERBOSE, "elm.icon.1 - category [%d]\n", peer->category); - char *img_path = NULL; - switch(peer->category) - { + __FUNC_ENTER__; + + assertm_if(NULL == obj, "NULL!!"); + assertm_if(NULL == part, "NULL!!"); + device_type_s *peer = (device_type_s *) data; + Evas_Object *icon = NULL; + Evas_Object *layout = NULL; + + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO, "part = %s", part); + if (!g_strcmp0(part, "elm.icon.2")) { + DBG(LOG_INFO, "elm.icon.2 - connection status [%d]\n", peer->conn_status); + if (peer->conn_status == PEER_CONN_STATUS_CONNECTING) { + layout = elm_layout_add(obj); + elm_layout_theme_set(layout, "layout", "list/C/type.2", "default"); + icon = elm_progressbar_add(layout); + elm_object_style_set(icon, "process_medium"); + elm_progressbar_pulse(icon, EINA_TRUE); + } else if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { + return NULL; + } + evas_object_show(icon); + elm_layout_content_set(layout, "elm.swallow.content", icon); + } else if (!g_strcmp0(part, "elm.icon.1")) { + DBG(LOG_INFO, "elm.icon.1 - category [%d]\n", peer->category); + char *img_name = NULL; + layout = elm_layout_add(obj); + elm_layout_theme_set(layout, "layout", "list/B/type.3", "default"); + /* + * the icon of connected device is + * different from available and busy device + */ + switch (peer->category) { case WFD_DEVICE_TYPE_COMPUTER: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_COMPUTER_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_COMPUTER; - } + img_name = WFD_ICON_DEVICE_COMPUTER; break; case WFD_DEVICE_TYPE_INPUT_DEVICE: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_INPUT_DEVICE_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_INPUT_DEVICE; - } + img_name = WFD_ICON_DEVICE_INPUT_DEVICE; break; case WFD_DEVICE_TYPE_PRINTER: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_PRINTER_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_PRINTER; - } + img_name = WFD_ICON_DEVICE_PRINTER; break; case WFD_DEVICE_TYPE_CAMERA: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_CAMERA_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_CAMERA; - } + img_name = WFD_ICON_DEVICE_CAMERA; break; case WFD_DEVICE_TYPE_STORAGE: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_STORAGE_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_STORAGE; - } + img_name = WFD_ICON_DEVICE_STORAGE; break; case WFD_DEVICE_TYPE_NW_INFRA: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_NETWORK_INFRA_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_NETWORK_INFRA; - } + img_name = WFD_ICON_DEVICE_NETWORK_INFRA; break; case WFD_DEVICE_TYPE_DISPLAYS: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_DISPLAY_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_DISPLAY; - } + img_name = WFD_ICON_DEVICE_DISPLAY; break; case WFD_DEVICE_TYPE_MM_DEVICES: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_MULTIMEDIA_DEVICE_CONNECT; + if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_STB) { + img_name = WFD_ICON_DEVICE_STB; + } else if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_MS_MA_ME) { + img_name = WFD_ICON_DEVICE_DONGLE; + } else if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_PVP) { + img_name = WFD_ICON_DEVICE_BD; } else { - img_path = WFD_ICON_DEVICE_MULTIMEDIA_DEVICE; + img_name = WFD_ICON_DEVICE_MULTIMEDIA; } break; case WFD_DEVICE_TYPE_GAME_DEVICES: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_GAMING_DEVICE_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_GAMING_DEVICE; - } + img_name = WFD_ICON_DEVICE_GAMING; break; case WFD_DEVICE_TYPE_TELEPHONE: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_TELEPHONE_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_TELEPHONE; - } + img_name = WFD_ICON_DEVICE_TELEPHONE; break; case WFD_DEVICE_TYPE_AUDIO: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_AUDIO_DEVICE_CONNECT; + if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_TUNER) { + img_name = WFD_ICON_DEVICE_HOME_THEATER; } else { - img_path = WFD_ICON_DEVICE_AUDIO_DEVICE; + img_name = WFD_ICON_DEVICE_HEADSET; } break; default: - if (peer->conn_status == PEER_CONN_STATUS_CONNECTED) { - img_path = WFD_ICON_DEVICE_COMPUTER_CONNECT; - } else { - img_path = WFD_ICON_DEVICE_COMPUTER; - } + img_name = WFD_ICON_DEVICE_UNKNOWN; break; - } - - if(img_path != NULL) - { - icon = elm_icon_add(obj); - elm_icon_file_set(icon, img_path, NULL); - evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1); - elm_icon_resizable_set(icon, 1, 1); - evas_object_show(icon); - } - else - { - return NULL; - } - } - - __FUNC_EXIT__; - return icon; -} + } + + icon = elm_image_add(layout); + elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name); + evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + ea_theme_object_color_set(icon, "AO001"); + evas_object_show(icon); + evas_object_propagate_events_set(icon, EINA_FALSE); + elm_layout_content_set(layout, "elm.swallow.content", icon); + } + if (layout) + evas_object_show(layout); + __FUNC_EXIT__; + return layout; +} -static char *_gl_noitem_text_get(void *data, Evas_Object * obj, - const char *part) +/** + * This function let the ug get the icon of peer item + * @return the icon of peer item + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static Evas_Object *_gl_conn_peer_icon_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; + __FUNC_ENTER__; + assertm_if(NULL == obj, "NULL!!"); + assertm_if(NULL == part, "NULL!!"); + device_type_s *peer = (device_type_s *) data; + Evas_Object *icon = NULL; + Evas_Object *layout = NULL; - if(data == NULL) - { + if (data == NULL) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return NULL; } + DBG(LOG_INFO, "part[%s]\n", part); + if (!g_strcmp0(part, "elm.icon.1")) { + DBG(LOG_INFO, "elm.icon.1 - category [%d]\n", peer->category); + char *img_name = NULL; + layout = elm_layout_add(obj); + elm_layout_theme_set(layout, "layout", "list/B/type.3", "default"); + /* + * the icon of connected device is + * different from available and busy device + */ + switch (peer->category) { + case WFD_DEVICE_TYPE_COMPUTER: + img_name = WFD_ICON_DEVICE_COMPUTER; + break; + case WFD_DEVICE_TYPE_INPUT_DEVICE: + img_name = WFD_ICON_DEVICE_INPUT_DEVICE; + break; + case WFD_DEVICE_TYPE_PRINTER: + img_name = WFD_ICON_DEVICE_PRINTER; + break; + case WFD_DEVICE_TYPE_CAMERA: + img_name = WFD_ICON_DEVICE_CAMERA; + break; + case WFD_DEVICE_TYPE_STORAGE: + img_name = WFD_ICON_DEVICE_STORAGE; + break; + case WFD_DEVICE_TYPE_NW_INFRA: + img_name = WFD_ICON_DEVICE_NETWORK_INFRA; + break; + case WFD_DEVICE_TYPE_DISPLAYS: + img_name = WFD_ICON_DEVICE_DISPLAY; + break; + case WFD_DEVICE_TYPE_MM_DEVICES: + if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_STB) { + img_name = WFD_ICON_DEVICE_STB; + } else if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_MS_MA_ME) { + img_name = WFD_ICON_DEVICE_DONGLE; + } else if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_PVP) { + img_name = WFD_ICON_DEVICE_BD; + } else { + img_name = WFD_ICON_DEVICE_MULTIMEDIA; + } + break; + case WFD_DEVICE_TYPE_GAME_DEVICES: + img_name = WFD_ICON_DEVICE_GAMING; + break; + case WFD_DEVICE_TYPE_TELEPHONE: + img_name = WFD_ICON_DEVICE_TELEPHONE; + break; + case WFD_DEVICE_TYPE_AUDIO: + if (peer->sub_category == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_TUNER) { + img_name = WFD_ICON_DEVICE_HOME_THEATER; + } else { + img_name = WFD_ICON_DEVICE_HEADSET; + } + break; + default: + img_name = WFD_ICON_DEVICE_UNKNOWN; + break; + } + icon = elm_image_add(layout); + elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name); + evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + ea_theme_object_color_set(icon, "AO001"); + evas_object_show(icon); + evas_object_propagate_events_set(icon, EINA_FALSE); + elm_layout_content_set(layout, "elm.swallow.content", icon); + } + if (layout) + evas_object_show(layout); __FUNC_EXIT__; - return strdup(_("IDS_WFD_NOCONTENT")); + return layout; } - -static char *_gl_help_label_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the text of no device item + * @return the text of no device item + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_noitem_text_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - DBG(LOG_VERBOSE, "%s", part); - __FUNC_EXIT__; - return strdup("Help"); -} + __FUNC_ENTER__; + + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO,"part = %s",part); + if (!g_strcmp0(part, "elm.text.main.left")) { + return g_strdup(_("IDS_BT_BODY_NO_DEVICES_FOUND_ABB")); + } + __FUNC_EXIT__; + return NULL; +} -static Evas_Object *_gl_button_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the title label of connected device list + * @return the title label of connected device list + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_conn_dev_title_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO,"part = %s",part); + if (!g_strcmp0(part, "elm.text.main")) { + return g_strdup(_("IDS_ST_HEADER_CONNECTED_DEVICES")); + } - DBG(LOG_VERBOSE, "%s", part); + __FUNC_EXIT__; + return NULL; +} - ugd->multi_btn = elm_button_add(obj); +char* ConvertRGBAtoHex(int r, int g, int b, int a) +{ + int hexcolor = 0; + char *string = NULL; + string = g_try_malloc0(sizeof(char )* 255); + if (string == NULL) { + return string; + } + hexcolor = (r << 24) + (g << 16) + (b << 8) + a; + sprintf(string, "%08x", hexcolor ); + return string; +} - wfd_refresh_wifi_direct_state(ugd); +/** + * This function let the ug get the label of connected device + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_peer_conn_dev_label_get(void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_COMPLETED) - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT")); - DBG(LOG_VERBOSE, "button: Disconnect\n"); + assertm_if(NULL == obj, "NULL!!"); + assertm_if(NULL == part, "NULL!!"); + device_type_s *peer = (device_type_s *) data; + DBG(LOG_INFO, "%s", part); + char *det = NULL; + char *buf = NULL; + char *str = NULL; + char *ssid; + int r = 0, g = 0, b = 0, a = 0; - // Don't connect "clicked" callback. - return ugd->multi_btn; + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; } - if (ugd->wfd_status == WFD_LINK_STATUS_CONNECTING) - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_CANCEL")); - DBG(LOG_VERBOSE, "button: Cancel connect\n"); - } - else if (ugd->wfd_status >= WFD_LINK_STATUS_CONNECTED) - { - if (ugd->gl_connected_peer_cnt > 1) - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT_ALL")); - DBG(LOG_VERBOSE, "button: Disconnect All\n"); + if (!g_strcmp0(part, "elm.text.main.left.top")) { + if (strlen(peer->ssid) != 0) { + ssid = elm_entry_utf8_to_markup(peer->ssid); + if (NULL == ssid) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return ssid; } - else - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT")); - DBG(LOG_VERBOSE, "button: Disconnect\n"); + } else if(!g_strcmp0(part, "elm.text.sub.left.bottom")){ + det = elm_entry_utf8_to_markup(_("IDS_COM_BODY_CONNECTED_M_STATUS")); + ea_theme_color_get("T024S",&r, &g, &b, &a, + NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL); + str = ConvertRGBAtoHex(r, g, b, a); + buf = g_strdup_printf("<color=#%s>%s</color>", + str, det); + if (det != NULL) { + g_free(det); } + if (str != NULL) { + g_free(str); + } + __FUNC_EXIT__; + return buf; } - else - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_MULTI")); - DBG(LOG_VERBOSE, "button: Multi connect\n"); - } - - evas_object_smart_callback_add(ugd->multi_btn, "clicked", _wifid_create_multibutton_cb, ugd); - evas_object_show(ugd->multi_btn); - - __FUNC_EXIT__; - - return ugd->multi_btn; + __FUNC_EXIT__; + return NULL; } - -static char *_gl_conn_dev_title_label_get(void *data, Evas_Object *obj, +/** + * This function let the ug get the title label of connected failed device list + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_conn_failed_dev_title_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + __FUNC_ENTER__; - if (!strcmp(part, "elm.text")) - { - return strdup(_("IDS_WFD_BODY_CONNECTED_DEVICES")); - } + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } - __FUNC_EXIT__; + if (!g_strcmp0(part, "elm.text")) { + return g_strdup(_("IDS_WIFI_SBODY_NOT_CONNECTED_M_STATUS_ABB")); + } - return NULL; + __FUNC_EXIT__; + return NULL; } - -static char *_gl_peer_conn_dev_label_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the label of connected failed device + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_peer_conn_failed_dev_label_get(void *data, Evas_Object *obj, const char *part) { __FUNC_ENTER__; + assertm_if(NULL == obj, "NULL!!"); assertm_if(NULL == part, "NULL!!"); - - device_type_s *peer = (device_type_s*) data; - + device_type_s *peer = (device_type_s *) data; char buf[WFD_GLOBALIZATION_STR_LENGTH] = { 0, }; - DBG(LOG_VERBOSE, "%s", part); - if(data == NULL) - { + char *ssid; + DBG(LOG_INFO, "%s", part); + + if (data == NULL) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return NULL; } - if (!strcmp(part, "elm.text.1")) - { - return strdup(peer->ssid); - } - else - { - g_strlcpy(buf, _("IDS_WFD_CONNECTED"), - WFD_GLOBALIZATION_STR_LENGTH); + if (!g_strcmp0(part, "elm.text.1")) { + if (strlen(peer->ssid) != 0) { + ssid = elm_entry_utf8_to_markup(peer->ssid); + if (NULL == ssid) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return ssid; + } + } else { + g_strlcpy(buf, _("IDS_CHATON_HEADER_CONNECTION_FAILED_ABB2"), + WFD_GLOBALIZATION_STR_LENGTH); __FUNC_EXIT__; - return strdup(buf); + return g_strdup(buf); } + return NULL; } -static char *_gl_conn_failed_dev_title_label_get(void *data, Evas_Object *obj, - const char *part) +/** + * This function let the ug get the title label of multi connect list + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_multi_connect_dev_title_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + __FUNC_ENTER__; + struct ug_data *ugd = wfd_get_ug_data(); - if (!strcmp(part, "elm.text")) - { - return strdup(IDS_WFD_BODY_FAILED_DEVICES); - } + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO, "%s", part); - __FUNC_EXIT__; + if (!g_strcmp0(part, "elm.text.main")) { + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { + return g_strdup(_("IDS_WIFI_HEADER_AVAILABLE_DEVICES_ABB")); + } else if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_COMPLETED) { + return g_strdup(_("IDS_WIFI_SBODY_NOT_CONNECTED_M_STATUS_ABB")); + } + } - return NULL; + __FUNC_EXIT__; + return NULL; } - -static char *_gl_peer_conn_failed_dev_label_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the title label of select all in multi connect + * @return the label of select all string + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_multi_connect_select_all_title_label_get(void *data, Evas_Object *obj, const char *part) { __FUNC_ENTER__; - assertm_if(NULL == obj, "NULL!!"); - assertm_if(NULL == part, "NULL!!"); - - device_type_s *peer = (device_type_s*) data; - char buf[WFD_GLOBALIZATION_STR_LENGTH] = { 0, }; - DBG(LOG_VERBOSE, "%s", part); - if(data == NULL) - { + if (data == NULL) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return NULL; } + DBG(LOG_INFO, "%s", part); - if (!strcmp(part, "elm.text.1")) - { - return strdup(peer->ssid); - } - else - { - g_strlcpy(buf, _("IDS_WFD_FAILED_TO_CONNECT"), - WFD_GLOBALIZATION_STR_LENGTH); + if (!g_strcmp0(part, "elm.text.main.left")) { __FUNC_EXIT__; - return strdup(buf); + return g_strdup(_("IDS_WIFI_BODY_SELECT_ALL")); } + __FUNC_EXIT__; + return NULL; } -static char *_gl_multi_connect_dev_title_label_get(void *data, Evas_Object *obj, - const char *part) +/** + * This function let the ug get the icon of select all genlist + * @return the icon of select all genlist + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static Evas_Object *_wfd_gl_select_all_icon_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - struct ug_data *ugd = wfd_get_ug_data(); - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - - if (!strcmp(part, "elm.text")) - { - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) - return strdup(_("IDS_WFD_BODY_AVAILABLE_DEVICES")); // "Available devices" - else if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_COMPLETED) - return strdup(IDS_WFD_BODY_FAILED_DEVICES); // "Available devices" - } - - __FUNC_EXIT__; - - return NULL; -} + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + Evas_Object *check = NULL; + Evas_Object *icon_layout = NULL; + DBG(LOG_INFO, "Part %s", part); + + if (!g_strcmp0(part, "elm.icon.2")) { + icon_layout = elm_layout_add(obj); + elm_layout_theme_set(icon_layout, "layout", "list/C/type.2", "default"); + DBG(LOG_INFO, "Part %s", part); + check = elm_check_add(icon_layout); + ugd->select_all_icon = check; + if (ugd->is_select_all_checked == EINA_TRUE) { + elm_check_state_set(ugd->select_all_icon, TRUE); + } + elm_object_style_set(check, "default/genlist"); + evas_object_propagate_events_set(check, EINA_FALSE); + evas_object_smart_callback_add(check, "changed", + wfd_genlist_select_all_check_changed_cb, (void *)data); + elm_layout_content_set(icon_layout, "elm.swallow.content", check); + } + __FUNC_EXIT__; + return icon_layout; +} + +/** + * This function let the ug get the title label of busy device list + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ static char *_gl_busy_dev_title_label_get(void *data, Evas_Object *obj, const char *part) { - __FUNC_ENTER__; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } + __FUNC_ENTER__; - if (!strcmp(part, "elm.text")) - { - return strdup(_("IDS_WFD_BODY_BUSY_DEVICES")); - } + if (data == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return NULL; + } + DBG(LOG_INFO, "%s", part); - __FUNC_EXIT__; + if (!g_strcmp0(part,"elm.text.main")) { + return g_strdup(_("IDS_ST_HEADER_BUSY_DEVICES")); + } - return NULL; + __FUNC_EXIT__; + return NULL; } - -static char *_gl_peer_busy_dev_label_get(void *data, Evas_Object * obj, const char *part) +/** + * This function let the ug get the label of busy device + * @return the label of connected device + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_gl_peer_busy_dev_label_get(void *data, Evas_Object *obj, const char *part) { __FUNC_ENTER__; assertm_if(NULL == obj, "NULL!!"); assertm_if(NULL == part, "NULL!!"); - device_type_s *peer = (device_type_s*) data; + device_type_s *peer = (device_type_s *) data; char buf[WFD_GLOBALIZATION_STR_LENGTH] = { 0, }; - DBG(LOG_VERBOSE, "%s", part); - if(data == NULL) - { + char *ssid; + DBG(LOG_INFO, "%s", part); + + if (data == NULL) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return NULL; } - DBG(LOG_VERBOSE, "peer->ssid = %s", peer->ssid); - if (!strcmp(part, "elm.text.1")) - { - return strdup(peer->ssid); - } - else - { - g_strlcpy(buf, _("IDS_WFD_CONNECTED_WITH_OTHER_DEVICE"), - WFD_GLOBALIZATION_STR_LENGTH); + + DBG(LOG_INFO, "peer->ssid = %s", peer->ssid); + + if (!g_strcmp0(part, "elm.text.main.left.top")) { + if (strlen(peer->ssid) != 0) { + ssid = elm_entry_utf8_to_markup(peer->ssid); + if (NULL == ssid) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return ssid; + } + } else if (!g_strcmp0(part, "elm.text.sub.left.bottom")) { + g_strlcpy(buf, _("IDS_ST_BODY_CONNECTED_WITH_ANOTHER_DEVICE_ABB"), + WFD_GLOBALIZATION_STR_LENGTH); __FUNC_EXIT__; - return strdup(buf); + return g_strdup(buf); } + return NULL; + } -static void _gl_peer_del(void *data, Evas_Object * obj) +/** + * This function let the ug delete the peer item + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + */ +static void _gl_peer_del(void *data, Evas_Object *obj) { - __FUNC_ENTER__; - assertm_if(NULL == obj, "NULL!!"); - assertm_if(NULL == data, "NULL!!"); + __FUNC_ENTER__; + + assertm_if(NULL == obj, "NULL!!"); + assertm_if(NULL == data, "NULL!!"); - __FUNC_EXIT__; - return; + __FUNC_EXIT__; + return; } +/** + * This function let the ug initialize the items of genlist + * @return void + */ void initialize_gen_item_class() { - sep_itc.item_style = "dialogue/separator"; - sep_itc.func.text_get = NULL; - sep_itc.func.content_get = NULL; - sep_itc.func.state_get = NULL; - sep_itc.func.del = NULL; - - sep_itc_end.item_style = "dialogue/separator/end"; - sep_itc_end.func.text_get = NULL; - sep_itc_end.func.content_get = NULL; - sep_itc_end.func.state_get = NULL; - sep_itc_end.func.del = NULL; - - head_itc.item_style = "dialogue/2text.1icon.6"; - head_itc.func.text_get = _gl_header_label_get; - head_itc.func.content_get = _gl_header_icon_get; - head_itc.func.state_get = NULL; - - name_itc.item_style = "dialogue/1text"; - name_itc.func.text_get = _gl_name_label_get; - name_itc.func.content_get = NULL; - name_itc.func.state_get = NULL; - name_itc.func.del = NULL; - - title_itc.item_style = "dialogue/title"; - title_itc.func.text_get = _gl_title_label_get; - title_itc.func.content_get = _gl_title_content_get; - title_itc.func.state_get = NULL; - title_itc.func.del = NULL; - - peer_itc.item_style = "dialogue/2text.2icon.3"; - peer_itc.func.text_get = _gl_peer_label_get; - peer_itc.func.content_get = _gl_peer_icon_get; - peer_itc.func.state_get = NULL; - peer_itc.func.del = _gl_peer_del; - - noitem_itc.item_style ="dialogue/1text"; - noitem_itc.func.text_get = _gl_noitem_text_get; - noitem_itc.func.content_get = NULL; - noitem_itc.func.state_get = NULL; - noitem_itc.func.del = NULL; - - help_itc.item_style = "dialogue/1text"; - help_itc.func.text_get = _gl_help_label_get; - help_itc.func.content_get = NULL; - help_itc.func.state_get = NULL; - help_itc.func.del = NULL; - - button_itc.item_style = "1icon"; - button_itc.func.text_get = NULL; - button_itc.func.content_get = _gl_button_get; - button_itc.func.state_get = NULL; - button_itc.func.del = NULL; - - title_conn_itc.item_style = "dialogue/title"; - title_conn_itc.func.text_get = _gl_conn_dev_title_label_get; - title_conn_itc.func.content_get = NULL; - title_conn_itc.func.state_get = NULL; - title_conn_itc.func.del = NULL; - - peer_conn_itc.item_style = "dialogue/2text.2icon.3"; - peer_conn_itc.func.text_get = _gl_peer_conn_dev_label_get; - peer_conn_itc.func.content_get = _gl_peer_icon_get; - peer_conn_itc.func.state_get = NULL; - peer_conn_itc.func.del = _gl_peer_del; - - title_conn_failed_itc.item_style = "dialogue/title"; - title_conn_failed_itc.func.text_get = _gl_conn_failed_dev_title_label_get; - title_conn_failed_itc.func.content_get = NULL; - title_conn_failed_itc.func.state_get = NULL; - title_conn_failed_itc.func.del = NULL; - - peer_conn_failed_itc.item_style = "dialogue/2text.2icon.3"; - peer_conn_failed_itc.func.text_get = _gl_peer_conn_failed_dev_label_get; - peer_conn_failed_itc.func.content_get = _gl_peer_icon_get; - peer_conn_failed_itc.func.state_get = NULL; - peer_conn_failed_itc.func.del = _gl_peer_del; - - title_busy_itc.item_style = "dialogue/title"; - title_busy_itc.func.text_get = _gl_busy_dev_title_label_get; - title_busy_itc.func.content_get = NULL; - title_busy_itc.func.state_get = NULL; - title_busy_itc.func.del = NULL; - - peer_busy_itc.item_style = "dialogue/2text.2icon.3"; - peer_busy_itc.func.text_get = _gl_peer_busy_dev_label_get; - peer_busy_itc.func.content_get = _gl_peer_icon_get; - peer_busy_itc.func.state_get = NULL; - peer_busy_itc.func.del = _gl_peer_del; - - title_multi_connect_itc.item_style = "dialogue/title"; - title_multi_connect_itc.func.text_get = _gl_multi_connect_dev_title_label_get; - title_multi_connect_itc.func.content_get = NULL; - title_multi_connect_itc.func.state_get = NULL; - title_multi_connect_itc.func.del = NULL; - -#if 0 - peer_multi_connect_itc.item_style = "dialogue/2text.2icon.3"; - peer_multi_connect_itc.func.text_get = _gl_peer_label_get; - peer_multi_connect_itc.func.content_get = _gl_peer_icon_get; - peer_multi_connect_itc.func.state_get = NULL; - peer_multi_connect_itc.func.del = _gl_peer_del; + elm_theme_extension_add(NULL, WFD_UG_EDJ_PATH); + + device_name_itc.item_style = "dialogue/2text.2"; + device_name_itc.func.text_get = NULL; + device_name_itc.func.content_get = NULL; + device_name_itc.func.state_get = NULL; + +#ifdef WFD_ON_OFF_GENLIST + wfd_onoff_itc.item_style = "2line.bottom"; + wfd_onoff_itc.func.text_get = _gl_wfd_onoff_text_get; + wfd_onoff_itc.func.content_get = _gl_wfd_onoff_content_get; + wfd_onoff_itc.func.state_get = NULL; + wfd_onoff_itc.func.del = NULL; #endif + + + title_itc.item_style = "groupindex"; + title_itc.func.text_get = _gl_title_label_get; + title_itc.func.content_get = _gl_title_content_get; + title_itc.func.state_get = NULL; + title_itc.func.del = NULL; + + multi_view_title_itc.item_style = "groupindex"; + multi_view_title_itc.func.text_get = _gl_multi_title_label_get; + multi_view_title_itc.func.content_get = _gl_multi_title_content_get; + multi_view_title_itc.func.state_get = NULL; + multi_view_title_itc.func.del = NULL; + + title_no_device_itc.item_style = "groupindex"; + title_no_device_itc.func.text_get = _gl_title_no_device_label_get; + title_no_device_itc.func.content_get = NULL; + title_no_device_itc.func.state_get = NULL; + title_no_device_itc.func.del = NULL; + + title_available_itc.item_style = "groupindex"; + title_available_itc.func.text_get = _gl_available_title_label_get; + title_available_itc.func.content_get = _gl_title_content_get; + title_available_itc.func.state_get = NULL; + title_available_itc.func.del = NULL; + + peer_itc.item_style = "2line.top"; + peer_itc.func.text_get = _gl_peer_label_get; + peer_itc.func.content_get = _gl_peer_icon_get; + peer_itc.func.state_get = NULL; + peer_itc.func.del = _gl_peer_del; + + noitem_itc.item_style = "1line"; + noitem_itc.func.text_get = _gl_noitem_text_get; + noitem_itc.func.content_get = NULL; + noitem_itc.func.state_get = NULL; + noitem_itc.func.del = NULL; + + title_conn_itc.item_style = "groupindex"; + title_conn_itc.func.text_get = _gl_conn_dev_title_label_get; + title_conn_itc.func.content_get = NULL; + title_conn_itc.func.state_get = NULL; + title_conn_itc.func.del = NULL; + + peer_conn_itc.item_style = "2line.top"; + peer_conn_itc.func.text_get = _gl_peer_conn_dev_label_get; + peer_conn_itc.func.content_get = _gl_conn_peer_icon_get; + peer_conn_itc.func.state_get = NULL; + peer_conn_itc.func.del = _gl_peer_del; + + title_conn_failed_itc.item_style = "dialogue/title"; + title_conn_failed_itc.func.text_get = _gl_conn_failed_dev_title_label_get; + title_conn_failed_itc.func.content_get = NULL; + title_conn_failed_itc.func.state_get = NULL; + title_conn_failed_itc.func.del = NULL; + + peer_conn_failed_itc.item_style = "dialogue/2text.2icon.3"; + peer_conn_failed_itc.func.text_get = _gl_peer_conn_failed_dev_label_get; + peer_conn_failed_itc.func.content_get = _gl_peer_icon_get; + peer_conn_failed_itc.func.state_get = NULL; + peer_conn_failed_itc.func.del = _gl_peer_del; + + title_busy_itc.item_style = "groupindex"; + title_busy_itc.func.text_get = _gl_busy_dev_title_label_get; + title_busy_itc.func.content_get = NULL; + title_busy_itc.func.state_get = NULL; + title_busy_itc.func.del = NULL; + + peer_busy_itc.item_style = "2line.top"; + peer_busy_itc.func.text_get = _gl_peer_busy_dev_label_get; + peer_busy_itc.func.content_get = _gl_peer_icon_get; + peer_busy_itc.func.state_get = NULL; + peer_busy_itc.func.del = _gl_peer_del; + + title_multi_connect_itc.item_style = "groupindex"; + title_multi_connect_itc.func.text_get = _gl_multi_connect_dev_title_label_get; + title_multi_connect_itc.func.content_get = NULL; + title_multi_connect_itc.func.state_get = NULL; + title_multi_connect_itc.func.del = NULL; + + select_all_multi_connect_itc.item_style = "1line"; + select_all_multi_connect_itc.func.text_get = + _gl_multi_connect_select_all_title_label_get; + select_all_multi_connect_itc.func.content_get = _wfd_gl_select_all_icon_get; + select_all_multi_connect_itc.func.state_get = NULL; + select_all_multi_connect_itc.func.del = NULL; } diff --git a/ug-wifidirect/src/wfd_ug_main_view.c b/ug-wifidirect/src/wfd_ug_main_view.c index 1849e63..dfe5b73 100755..100644 --- a/ug-wifidirect/src/wfd_ug_main_view.c +++ b/ug-wifidirect/src/wfd_ug_main_view.c @@ -19,1135 +19,1955 @@ #include <libintl.h> - -#include <assert.h> #include <glib.h> #include <Elementary.h> #include <vconf.h> #include <ui-gadget-module.h> +#include <app_control.h> #include <wifi-direct.h> #include "wfd_ug.h" #include "wfd_ug_view.h" #include "wfd_client.h" -void _wfd_onoff_btn_cb(void *data, Evas_Object *obj, void *event_info); +void scan_button_create(struct ug_data *ugd) +{ + __FUNC_ENTER__; + Evas_Object *btn; + btn = elm_button_add(ugd->layout); + /* Use "bottom" style button */ + elm_object_style_set(btn, "bottom"); + elm_object_domain_translatable_text_set(btn, PACKAGE, "IDS_WIFI_SK4_SCAN"); + ugd->scan_toolbar = btn; + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", + FALSE); + } + evas_object_smart_callback_add(btn, "clicked",_scan_btn_cb, (void *)ugd); + /* Set button into "toolbar" swallow part */ + elm_object_part_content_set(ugd->layout, "button.big", btn); + evas_object_show(ugd->scan_toolbar); -void _back_btn_cb(void *data, Evas_Object * obj, void *event_info) + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when click 'back' button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +Eina_Bool _back_btn_cb(void *data, Elm_Object_Item *it) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - if(!ugd) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } - - wfd_ug_view_free_peers(ugd); -#if 0 - bundle *b; - b = bundle_create(); - if(!b) - { - DBG(LOG_ERROR, "Failed to create bundle"); - return; - } - - wfd_refresh_wifi_direct_state(ugd); - if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING) - bundle_add(b, "Connection", "TRUE"); - else - bundle_add(b, "Connection", "FALSE"); - - ug_send_result(ugd->ug, b); - - bundle_free(b); -#else + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RETV_IF(ugd == NULL, FALSE, "The param is NULL\n"); int ret = -1; - service_h service = NULL; - ret = service_create(&service); - if(ret) - { - DBG(LOG_ERROR, "Failed to create service"); - return; + bool owner = FALSE; + app_control_h control = NULL; + +#ifdef WFD_DBUS_LAUNCH + if (ugd->dbus_cancellable != NULL) { + g_cancellable_cancel(ugd->dbus_cancellable); + g_object_unref(ugd->dbus_cancellable); + ugd->dbus_cancellable = NULL; + if (ugd->conn) { + g_object_unref(ugd->conn); + ugd->conn = NULL; + } + DBG(LOG_INFO, "Cancel dbus call"); } +#endif wfd_refresh_wifi_direct_state(ugd); - if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING) - service_add_extra_data(service, "Connection", "TRUE"); - else - service_add_extra_data(service, "Connection", "FALSE"); + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + DBG(LOG_INFO, "WiFi direct is already deactivated\n"); + goto cleanup; + } - ug_send_result(ugd->ug, service); - service_destroy(service); -#endif - ug_destroy_me(ugd->ug); + if (NULL != ugd->mac_addr_connecting) { + if (ugd->is_conn_incoming) { + DBG(LOG_INFO, "Reject the incoming connection before client deregister \n"); + ret = wifi_direct_reject_connection(ugd->mac_addr_connecting); + if (ret != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send reject request [%d]\n", ret); + } + } else { + DBG(LOG_INFO, "Cancel the outgoing connection before client deregister \n"); + ret = wifi_direct_cancel_connection(ugd->mac_addr_connecting); + if (ret != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed to send cancel request [%d]\n", ret); + } + } + ugd->mac_addr_connecting = NULL; + } - __FUNC_EXIT__; - return; + if (ugd->raw_connected_peer_cnt == 0) { + ret = wifi_direct_is_group_owner(&owner); + if (ret == WIFI_DIRECT_ERROR_NONE) { + if (owner) { + wifi_direct_destroy_group(); + } + } + } + +cleanup: + wfd_ug_view_free_peers(ugd); + ret = app_control_create(&control); + if (ret) { + DBG(LOG_ERROR, "Failed to create control"); + } else { + if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING) { + app_control_add_extra_data(control, "Connection", "TRUE"); + } else { + app_control_add_extra_data(control, "Connection", "FALSE"); + } + + ug_send_result(ugd->ug, control); + app_control_destroy(control); + } + + ug_destroy_me(ugd->ug); + __FUNC_EXIT__; + return FALSE; } -void _scan_btn_cb(void *data, Evas_Object * obj, void *event_info) +void wfd_cancel_progressbar_stop_timer(struct ug_data *ugd) { - __FUNC_ENTER__; + __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - Elm_Object_Item *btn = event_info; - char *btn_text = NULL; + if(ugd->timer_stop_progress_bar > 0) { + g_source_remove(ugd->timer_stop_progress_bar); + } + ugd->timer_stop_progress_bar = 0; - if (NULL == ugd || NULL == btn) { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; - } + __FUNC_EXIT__; +} - btn_text = elm_object_item_text_get(btn); - if (0 == strcmp(btn_text, _("IDS_WFD_BUTTON_SCAN"))) { - wfd_refresh_wifi_direct_state(ugd); - DBG(LOG_VERBOSE, "Start discovery again, status: %d\n", ugd->wfd_status); +void wfd_cancel_not_alive_delete_timer(struct ug_data *ugd) +{ + __FUNC_ENTER__; - /* if connected, show the popup*/ - if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) { - wfd_ug_act_popup(ugd, IDS_WFD_POP_SCAN_AGAIN, POP_TYPE_SCAN_AGAIN); - } else if (WIFI_DIRECT_STATE_ACTIVATED == ugd->wfd_status) { - wfd_client_start_discovery(ugd); - } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) { - _wfd_onoff_btn_cb(ugd, NULL, NULL); - __FUNC_EXIT__; - return; + if(ugd->timer_delete_not_alive_peer > 0) { + g_source_remove(ugd->timer_delete_not_alive_peer); } + ugd->timer_delete_not_alive_peer = 0; + + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when click failed devices item + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _gl_failed_peer_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE); + struct ug_data *ugd = wfd_get_ug_data(); + int ret = -1; + + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; } - if (ugd->multi_scan_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE); + if (ugd->display_timer != NULL) { + ecore_timer_del(ugd->display_timer); + ugd->display_timer = NULL; } - } else if (0 == strcmp(btn_text, _("IDS_WFD_BUTTON_STOPSCAN"))) { - DBG(LOG_VERBOSE, "Stop discoverying.\n"); - ugd->wfd_status = WIFI_DIRECT_STATE_ACTIVATED; + wfd_refresh_wifi_direct_state(ugd); - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - wifi_direct_cancel_discovery(); - } + DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status); + + /* if connected, show the popup*/ + if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) { + wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN); + } else { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } - __FUNC_EXIT__; - return; + __FUNC_EXIT__; + return; } -Eina_Bool _is_wifi_on() +/** + * This function let the ug call it when click 'scan' button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _scan_btn_cb(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - int wifi_state; - - vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state); - - if (wifi_state >= VCONFKEY_WIFI_CONNECTED) - { - return TRUE; - } - else - { - return FALSE; - } - __FUNC_EXIT__; + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } + int ret = -1; + const char *btn_text = NULL; + btn_text = elm_object_part_text_get(ugd->scan_toolbar, "default"); + WFD_RET_IF(btn_text == NULL, "The btn_text is NULL\n"); + DBG(LOG_INFO, "Button text=%s",btn_text); + + if (!g_strcmp0(elm_object_text_get(obj), _("IDS_WIFI_SK4_SCAN"))) { + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status); + /* if connected, show the popup*/ + if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED || ugd->raw_connected_peer_cnt > 0) { + wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN); + } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) { + wfd_client_switch_on(ugd); + __FUNC_EXIT__; + return; + } else { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } + } else if (!g_strcmp0(elm_object_text_get(obj), _("IDS_WIFI_SK_STOP"))) { + DBG(LOG_INFO, "Stop pressed.\n"); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED; + wfd_cancel_progressbar_stop_timer(ugd); + wfd_delete_progressbar_cb(ugd); + wfd_cancel_not_alive_delete_timer(ugd); + } else if (0 == strcmp(_("IDS_WIFI_SK2_CANCEL_CONNECTION"), btn_text)) { + DBG(LOG_INFO, "Cancel Connection"); + wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_THIS_WI_FI_DIRECT_CONNECTION_WILL_BE_CANCELLED"), POP_TYPE_CANCEL_CONNECT); + } else { + DBG(LOG_INFO, "Invalid Case\n"); + } + __FUNC_EXIT__; + return; } -void _wfd_onoff_btn_cb(void *data, Evas_Object *obj, void *event_info) +void wfd_check_gl_busy_peers(struct ug_data *ugd) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - wfd_refresh_wifi_direct_state(ugd); - - if(!ugd->wfd_onoff) - { - if(ugd->wfd_status < 0) - { - DBG(LOG_VERBOSE, "bad wfd status\n"); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); - - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return; - } - DBG(LOG_VERBOSE, "wifi-direct switch on\n"); - ugd->head_text_mode = HEAD_TEXT_TYPE_ACTIVATING; - wfd_client_switch_on(ugd); - } - else - { - if(ugd->wfd_status < 0) - { - DBG(LOG_VERBOSE, "bad wfd status\n"); - wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_TERMINATE); - - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); - return; - } - DBG(LOG_VERBOSE, "wifi-direct switch off\n"); - ugd->head_text_mode = HEAD_TEXT_TYPE_DEACTIVATING; - wfd_client_switch_off(ugd); - } - - wfd_ug_view_refresh_glitem(ugd->head); - - if (ugd->scan_btn) { - wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE); - } - - if (ugd->multi_scan_btn) { - wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE); - } - - - __FUNC_EXIT__; + __FUNC_ENTER__; + if (ugd->gl_busy_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->busy_wfd_item); + } + __FUNC_EXIT__; } - -static void _gl_header_sel(void *data, Evas_Object *obj, void *event_info) +void wfd_check_gl_available_peers(struct ug_data *ugd) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - Elm_Object_Item *item = (Elm_Object_Item *)event_info; + __FUNC_ENTER__; + if (ugd->gl_available_peer_cnt == 0 && ugd->avlbl_wfd_item != NULL) { + WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item); + } + __FUNC_EXIT__; +} - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; - } +/** + * This function let the ug free some peer in genlist + * @return void + * @param[in] start_pos the start position of peers list + * @param[in] mac_addr the mac_addr of peer for free + * @param[in] cnt the count of gl peers in list + */ +void free_gl_peer(device_type_s **start_pos, const char *mac_addr, int *cnt) +{ + __FUNC_ENTER__; + device_type_s *peer = *start_pos; + device_type_s *peer_tmp = peer; - if(item != NULL) - elm_genlist_item_selected_set(item, EINA_FALSE); + if (peer == NULL) { + DBG(LOG_INFO, "no peer in genlist"); + return; + } - _wfd_onoff_btn_cb(ugd, NULL, NULL); + while (peer) { + if(strcmp(peer->mac_addr, mac_addr)) { + peer_tmp = peer; + peer = peer->next; + } else { + if(peer->next != NULL) { + peer_tmp->next = peer->next; + break; + } else { + peer_tmp->next = NULL; + break; + } + } + } - __FUNC_EXIT__; -} + if (peer == *start_pos) { + DBG(LOG_INFO, "the head is free"); + *start_pos = peer->next; + } -#if 0 -static Evas_Object *_gl_noitem_icon_get(void *data, Evas_Object * obj, - const char *part) -{ - __FUNC_ENTER__; - Evas_Object *nocontent; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return NULL; - } - -#if 1 // use nocontent - nocontent = elm_layout_add(obj); - if(nocontent == NULL) - { - DBG(LOG_ERROR, "Failed to add nocontent"); - return NULL; - } - elm_layout_theme_set(nocontent, "layout", "nocontents", "unnamed"); - elm_object_part_text_set(nocontent, "elm.text", _("IDS_WFD_BODY_NO_DEVICES")); - evas_object_size_hint_min_set(nocontent, 400, 200); - evas_object_size_hint_max_set(nocontent, 400, 200); - evas_object_resize(nocontent, 400, 200); - - __FUNC_EXIT__; - - return nocontent; -#else // use image - Evas_Object *icon; - icon = elm_icon_add(obj); - elm_icon_file_set(icon, "/opt/ug/res/images/ug-wifi-direct/A09_NoDevice.png", NULL); - evas_object_size_hint_min_set(icon, 400, 200); - evas_object_size_hint_max_set(icon, 400, 200); - evas_object_resize(icon, 400, 200); - - return icon; -#endif + (*cnt)--; + if (peer) { + WFD_IF_DEL_ITEM(peer->gl_item); + peer->next = NULL; + free(peer); + } + __FUNC_EXIT__; } -#endif +/** + * This function let the ug call it when click avaliable peer to connect + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ static void _gl_peer_sel(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - assertm_if(NULL == obj, "NULL!!"); - assertm_if(NULL == data, "NULL!!"); - device_type_s *peer = (device_type_s*) data; - Elm_Object_Item *item = (Elm_Object_Item *)event_info; - struct ug_data* ugd = wfd_get_ug_data(); - int res; - - if(data == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; - } - - if(item != NULL) - elm_genlist_item_selected_set(item, EINA_FALSE); - - if(peer->conn_status == PEER_CONN_STATUS_DISCONNECTED) - { -#if 0 // for new connection during link_status is CONNECTING - wfd_refresh_wifi_direct_state(ugd); - if(ugd->wfd_status == WFD_LINK_STATUS_CONNECTING) - { - res = wfd_client_disconnect(NULL); - if(res != 0) - { - DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res); - return; - } - } -#endif - DBG(LOG_VERBOSE, "Connect with peer [%s]\n", peer->mac_addr); - res = wfd_client_connect((const char*) peer->mac_addr); - if(res != 0) - { - DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res); - return; - } - peer->conn_status = PEER_CONN_STATUS_CONNECTING; - } - else // PEER_CONN_STATUS_CONNECTED or PEER_CONN_STATUS_CONNECTING) - { - res = wfd_client_disconnect((const char*) peer->mac_addr); - if(res != 0) - { - DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res); - return; - } - peer->conn_status = PEER_CONN_STATUS_DISCONNECTED; - } - - wfd_ug_view_refresh_glitem(peer->gl_item); - wfd_ug_view_refresh_glitem(ugd->multi_button_item); - - __FUNC_EXIT__; - return; + __FUNC_ENTER__; + + int res = -1; + char txt[MAX_POPUP_TEXT_SIZE] = {0,}; + char popup_text[MAX_POPUP_TEXT_SIZE] = {0, }; + bool is_peer_alive = false; + struct ug_data *ugd = wfd_get_ug_data(); + device_type_s *peer = (device_type_s *)data; + Elm_Object_Item *item = (Elm_Object_Item *)event_info; + + if (!ugd || !peer) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return; + } + + wfd_ug_get_connected_peers(ugd); + DBG(LOG_INFO, "No of connected peers= %d",ugd->raw_connected_peer_cnt); + + if (ugd->raw_connected_peer_cnt >= MAX_CONNECTED_PEER_NUM) { + 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); + wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP); + if (item) { + elm_genlist_item_selected_set(item, EINA_FALSE); + } + return; + } + + if (ugd->disconnect_btn) { + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + ugd->disconnect_btn = NULL; + elm_object_part_content_set(ugd->layout, "button.big", + ugd->scan_toolbar); + } + + if (item) { + elm_genlist_item_selected_set(item, EINA_FALSE); + } + + GList *iterator = NULL; + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if (!strncmp(peer->mac_addr, (const char *)((device_type_s *)iterator->data)->mac_addr, MAC_LENGTH)) { + /* peer is found in last discovery */ + is_peer_alive = true; + break; + } + } + + if (!is_peer_alive) { + /* peer exists only in genlist, waiting to be deleted */ + device_type_s *peer_start = ugd->gl_avlb_peers_start; + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if(!strncmp(peer_start->mac_addr, peer->mac_addr, MAC_LENGTH)) { + DBG(LOG_INFO, "Device [%s] found in genlist, but it is already lost", ((device_type_s *)iterator->data)->ssid); + sprintf(txt, "Cannot find device %s", ((device_type_s *)iterator->data)->ssid); + free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr, &ugd->gl_available_peer_cnt); + wfd_check_gl_available_peers(ugd); + wfd_ug_warn_popup(ugd, txt, POPUP_TYPE_INFO); + return; + } + } + } + + wfd_cancel_not_alive_delete_timer(ugd); + + /* get WFD status */ + wfd_refresh_wifi_direct_state(ugd); + + if (PEER_CONN_STATUS_DISCONNECTED == peer->conn_status || + peer->is_group_owner == TRUE) { + DBG_SECURE(LOG_DEBUG, "Connect with peer ["MACSECSTR"]\n", + MAC2SECSTR(peer->mac_addr)); + + if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status) { + DBG(LOG_DEBUG, "It's in connecting status now.\n"); + return; + } + + ugd->mac_addr_connecting = peer->mac_addr; + res = wfd_client_connect((const char *)peer->mac_addr); + if (res != 0) { + DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res); + return; + } + } + + __FUNC_EXIT__; + return; } +/** + * This function let the ug call it when click busy peer + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ static void _gl_busy_peer_sel(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data(); + Elm_Object_Item *item = (Elm_Object_Item *)event_info; - elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE); + if (item) { + elm_genlist_item_selected_set(item, EINA_FALSE); + } - DBG(LOG_VERBOSE, "Busy device is clicked"); + if (NULL == ugd) { + DBG(LOG_ERROR, "Data is NULL\n"); + return; + } - wfd_ug_warn_popup(ugd, IDS_WFD_POP_WARN_BUSY_DEVICE, POP_TYPE_BUSY_DEVICE_POPUP); + wfd_ug_warn_popup(ugd, _("IDS_ST_POP_DEVICE_CONNECTED_TO_ANOTHER_DEVICE"), POP_TYPE_BUSY_DEVICE_POPUP); - __FUNC_EXIT__; + __FUNC_EXIT__; } -static void _gl_about_wifi_sel(void *data, Evas_Object *obj, void *event_info) +void ctxpopup_dismissed_cb(void *data, Evas_Object *obj, void *event_info) { - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) data; - DBG(LOG_VERBOSE, "About wifi clicked"); + if (!ugd) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } - _wifid_create_about_view(ugd); - elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE); + if (ugd->ctxpopup) { + evas_object_del(ugd->ctxpopup); + ugd->ctxpopup = NULL; + } } -void _wifid_create_multibutton_cb(void *data, Evas_Object * obj, void *event_info) +void _ctxpopup_move() { - struct ug_data *ugd = (struct ug_data*) data; - const char *text_lbl = NULL; - - text_lbl = elm_object_text_get(ugd->multi_btn); - DBG(LOG_VERBOSE, "text_lbl = %s", text_lbl); - - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) - { - ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; - if (0 == strcmp(_("IDS_WFD_BUTTON_CANCEL"), text_lbl)) - { - wfd_ug_act_popup(ugd, _("IDS_WFD_POP_CANCEL_CONNECT"), POP_TYPE_DISCONNECT_ALL); - } - else - { - DBG(LOG_VERBOSE, "Invalid Case\n"); - } - } - else - { - if (0 == strcmp(_("IDS_WFD_BUTTON_MULTI"), text_lbl)) - { - _wifid_create_multiconnect_view(ugd); - } - else if (0 == strcmp(_("IDS_WFD_BUTTON_CANCEL"), text_lbl)) - { - wfd_ug_act_popup(ugd, _("IDS_WFD_POP_CANCEL_CONNECT"), POP_TYPE_DISCONNECT_ALL); - } - else if (0 == strcmp(_("IDS_WFD_BUTTON_DISCONNECT_ALL"), text_lbl)) - { - wfd_ug_act_popup(ugd, _("IDS_WFD_POP_DISCONNECT"), POP_TYPE_DISCONNECT_ALL); - } - else if (0 == strcmp(_("IDS_WFD_BUTTON_DISCONNECT"), text_lbl)) - { - wfd_ug_act_popup(ugd, _("IDS_WFD_POP_DISCONNECT"), POP_TYPE_DISCONNECT); - } - else - { - DBG(LOG_VERBOSE, "Invalid Case\n"); - } - } + __FUNC_ENTER__; + + int win_w = 0, win_h = 0; + int move_x = 0, move_y = 0; + int changed_ang = 0; + struct ug_data *ugd = wfd_get_ug_data(); + + if (!ugd || !ugd->win) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return; + } + + if (!ugd->ctxpopup) { + DBG(LOG_INFO, "NULL parameters.\n"); + return; + } + + elm_win_screen_size_get(ugd->win, NULL, NULL, &win_w, &win_h); + changed_ang = elm_win_rotation_get(ugd->win); + + switch (changed_ang) { + case 0: + case 180: + move_x = win_w/2; + move_y = win_h; + break; + + case 90: + move_x = win_h/2; + move_y = win_w; + break; + + case 270: + move_x = win_h/2; + move_y = win_w; + break; + + default: + move_x = 0; + move_y = 0; + break; + } + + evas_object_move(ugd->ctxpopup, move_x, move_y); + + __FUNC_EXIT__; } +void _create_mluti_connect_view(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RET_IF(ugd == NULL, "The param is NULL\n"); + WFD_IF_DEL_OBJ(ugd->ctxpopup); + int ret = 0; + + wfd_client_free_raw_discovered_peers(ugd); + ugd->raw_discovered_peer_cnt = 0; + wfd_create_multiconnect_view(ugd); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } -int _change_multi_button_title(void *data) + __FUNC_EXIT__; +} + +void _more_button_cb(void *data, Evas_Object *obj, void *event_info) { - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + + Evas_Object *naviframe = (Evas_Object *)data; + Elm_Object_Item *multi_connect_item = NULL; + Elm_Object_Item *rename_item = NULL; + struct ug_data *ugd = wfd_get_ug_data(); + + if (!naviframe || !ugd) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return; + } + + ugd->more_btn_multiconnect_item = NULL; + + if (ugd->ctxpopup) { + evas_object_del(ugd->ctxpopup); + } - if(ugd->multi_button_item == NULL) /*Needs to be check as the peer count is not getting updated*/ - { - return -1; - } + ugd->ctxpopup = elm_ctxpopup_add(naviframe); + elm_object_style_set(ugd->ctxpopup, "more/default"); + ea_object_event_callback_add(ugd->ctxpopup, EA_CALLBACK_BACK, ea_ctxpopup_back_cb, NULL); + ea_object_event_callback_add(ugd->ctxpopup, EA_CALLBACK_MORE, ea_ctxpopup_back_cb, NULL); + evas_object_smart_callback_add(ugd->ctxpopup, "dismissed", ctxpopup_dismissed_cb, ugd); + elm_ctxpopup_auto_hide_disabled_set(ugd->ctxpopup, EINA_TRUE); + + elm_ctxpopup_direction_priority_set(ugd->ctxpopup, ELM_CTXPOPUP_DIRECTION_UP, + ELM_CTXPOPUP_DIRECTION_LEFT, + ELM_CTXPOPUP_DIRECTION_RIGHT, + ELM_CTXPOPUP_DIRECTION_DOWN); + + _ctxpopup_move(); + + multi_connect_item = elm_ctxpopup_item_append(ugd->ctxpopup, "IDS_WIFI_BUTTON_MULTI_CONNECT", NULL, _create_mluti_connect_view, ugd); + elm_object_item_domain_text_translatable_set(multi_connect_item, PACKAGE, EINA_TRUE); + ugd->more_btn_multiconnect_item = multi_connect_item; wfd_refresh_wifi_direct_state(ugd); - if (ugd->wfd_status == WFD_LINK_STATUS_CONNECTING) - { - //if (conn_prog_count > 0) - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_CANCEL")); + if (WIFI_DIRECT_STATE_CONNECTING == ugd->wfd_status || + WIFI_DIRECT_STATE_CONNECTED == ugd->wfd_status || + WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status || + ugd->raw_connected_peer_cnt > 0) { + elm_object_item_disabled_set(multi_connect_item, TRUE); + } + + rename_item = elm_ctxpopup_item_append(ugd->ctxpopup, "IDS_ST_BODY_RENAME_DEVICE_ABB", NULL, _gl_rename_device_sel, ugd); + elm_object_item_domain_text_translatable_set(rename_item, PACKAGE, EINA_TRUE); + evas_object_show(ugd->ctxpopup); + + __FUNC_EXIT__; +} + +/** + * This function make items into group +*/ +void _wfd_realize_item(Elm_Object_Item *pre_item, int count) +{ + __FUNC_ENTER__; + int i = 0; + if (count < 1 || pre_item == NULL) { + return; + } + + Elm_Object_Item *item = elm_genlist_item_next_get(pre_item); + if (item == NULL) { + return; + } + + if (count == 1) { + elm_object_item_signal_emit(item, "elm,state,normal", ""); + return; } - else if (ugd->wfd_status > WFD_LINK_STATUS_CONNECTING) - { - if (ugd->gl_connected_peer_cnt > 1) - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT_ALL")); - else - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT")); + + for (i = 0; i < count; i++) { + if (i == 0) { + elm_object_item_signal_emit(item, "elm,state,top", ""); + } else if (i == count - 1) { + elm_object_item_signal_emit(item, "elm,state,bottom", ""); + } else { + elm_object_item_signal_emit(item, "elm,state,center", ""); + } + + item = elm_genlist_item_next_get(item); + } + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when unresized event is received +*/ +static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + + _wfd_realize_item(ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt); + _wfd_realize_item(ugd->conn_wfd_item, ugd->gl_connected_peer_cnt); + _wfd_realize_item(ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt); + _wfd_realize_item(ugd->busy_wfd_item, ugd->gl_busy_peer_cnt); + _wfd_realize_item(ugd->conn_failed_wfd_item, ugd->gl_connected_failed_peer_cnt); + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when resized event is received + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _gl_realized(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + + if (!data || !event_info) { + DBG(LOG_ERROR, "Invalid parameters"); + return; } - else - { - elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_MULTI")); + + struct ug_data *ugd = (struct ug_data *)data; +#ifdef ACCESSIBILITY_FEATURE + Elm_Object_Item *item = (Elm_Object_Item *)event_info; + int index = elm_genlist_item_index_get(item); + char *sr_msg = NULL; +#endif + + _wfd_realize_item(ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt); + _wfd_realize_item(ugd->conn_wfd_item, ugd->gl_connected_peer_cnt); + _wfd_realize_item(ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt); + _wfd_realize_item(ugd->busy_wfd_item, ugd->gl_busy_peer_cnt); + _wfd_realize_item(ugd->conn_failed_wfd_item, ugd->gl_connected_failed_peer_cnt); + +#ifdef ACCESSIBILITY_FEATURE + /* screen reader */ + if (GENLIST_HEADER_POS == index && item != NULL) { + Evas_Object *check = elm_object_item_part_content_get(item, "elm.icon"); + if (check) { + Eina_Bool state = elm_check_state_get(check); + if (state) { + sr_msg = strdup(SR_CHECKBOX_ON_MSG); + } else { + sr_msg = strdup(SR_CHECKBOX_OFF_MSG); + } + + if (sr_msg) { + Evas_Object *ao = NULL; + ao = elm_object_item_access_object_get(item); + elm_access_info_set(ao, ELM_ACCESS_CONTEXT_INFO, sr_msg); + free(sr_msg); + } else { + DBG(LOG_ERROR, "index = %d, screen reader message create fail!", index); + } + } else { + DBG(LOG_ERROR, "index = %d, get check box fail!", index); + } } +#endif + + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when click 'disconnect' button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _wfd_ug_disconnect_button_cb(void *data, Evas_Object * obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); - evas_object_show(ugd->multi_btn); + wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_CONTINUE_Q"), POP_TYPE_DISCONNECT); - return 0; + __FUNC_EXIT__; } +/** + * This function let the ug call it when click "cancel connection" button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _wfd_ug_cancel_connection_button_cb(void *data, Evas_Object * obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); -void wfd_ug_view_refresh_glitem(void *obj) + wfd_ug_act_popup(ugd, _("IDS_WIFI_POP_THIS_WI_FI_DIRECT_CONNECTION_WILL_BE_CANCELLED"), POP_TYPE_CANCEL_CONNECT); + + __FUNC_EXIT__; +} + + +/** + * This function let the ug update the genlist item + * @return void + * @param[in] gl_item the pointer to genlist item + */ +void wfd_ug_view_refresh_glitem(Elm_Object_Item *gl_item) { - __FUNC_ENTER__; - elm_genlist_item_update(obj); - __FUNC_EXIT__; + __FUNC_ENTER__; + if (gl_item != NULL) { + elm_genlist_item_update(gl_item); + } + __FUNC_EXIT__; } -void wfd_ug_view_refresh_button(void *obj, const char *text, int enable) +/** + * This function let the ug refresh the attributes of button + * @return void + * @param[in] tb_item the pointer to the toolbar button + * @param[in] text the pointer to the text of button + * @param[in] enable whether the button is disabled + */ +void wfd_ug_view_refresh_button(Evas_Object *tb_item, const char *text, + int enable) { __FUNC_ENTER__; - if (NULL == obj || NULL == text) { + if (NULL == tb_item || NULL == text) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return; } - DBG(LOG_VERBOSE, "Set the attributes of button: text[%s], enabled[%d]\n", text, enable); - elm_object_item_text_set(obj, text); - elm_object_item_disabled_set(obj, !enable); + DBG(LOG_INFO, "Set the attributes of button: text[%s], enabled[%d]\n", text, enable); + elm_object_domain_translatable_part_text_set(tb_item, "default", + PACKAGE, text); + elm_object_disabled_set(tb_item, !enable); __FUNC_EXIT__; } +/** + * This function let the ug know whether current device is connected by me + * @return If connected, return TRUE, else return FALSE + * @param[in] ugd the pointer to the main data structure + * @param[in] dev the pointer to the device + */ static bool __wfd_is_device_connected_with_me(struct ug_data *ugd, device_type_s *dev) { - int i; + __FUNC_ENTER__; + int i = 0; - for(i=0; i<ugd->raw_connected_peer_cnt; i++) - { - if (strncmp(ugd->raw_connected_peers[i].mac_addr, dev->mac_addr, strlen(ugd->raw_connected_peers[i].mac_addr)) == 0) + for (i = 0; i < ugd->raw_connected_peer_cnt; i++) { + if (strncmp(ugd->raw_connected_peers[i].mac_addr, + dev->mac_addr, strlen(ugd->raw_connected_peers[i].mac_addr)) == 0) { return TRUE; + } } + + __FUNC_EXIT__; return FALSE; } +/** + * This function let the ug know whether current device is connected by other peer + * @return If connected, return TRUE, else return FALSE + * @param[in] ugd the pointer to the main data structure + * @param[in] dev the pointer to the device + */ static bool __wfd_is_device_busy(struct ug_data *ugd, device_type_s *dev) { - if (__wfd_is_device_connected_with_me(ugd, dev) == TRUE) - return FALSE; + __FUNC_ENTER__; - if (ugd->I_am_group_owner == TRUE) - { - if (dev->is_connected || dev->is_group_owner) + if (ugd->I_am_group_owner == TRUE) { + if (dev->is_connected || dev->is_group_owner) { return TRUE; - else + } else { return FALSE; - } - else - { - if (dev->is_connected == TRUE && dev->is_group_owner == TRUE) + } + } else { + if (dev->is_connected == TRUE && dev->is_group_owner == TRUE) { return FALSE; - if (dev->is_connected == TRUE && dev->is_group_owner == FALSE) + } + + if (dev->is_connected == TRUE && dev->is_group_owner == FALSE) { return TRUE; - if (dev->is_connected == FALSE) + } + + if (dev->is_connected == FALSE) { return FALSE; + } } + __FUNC_EXIT__; return FALSE; } +/** + * This function let the ug calculate how many devices are avaliable + * @return TRUE + * @param[in] ugd the pointer to the main data structure + * @param[in] dev the pointer to the number of avaliable devices + */ static bool __wfd_is_any_device_available(struct ug_data *ugd, int* no_of_available_dev) { - int i =0 ; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) && - ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_DISCONNECTED) - (*no_of_available_dev)++; - } - return TRUE; + __FUNC_ENTER__; + GList *iterator = NULL; + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + /* Not include the device which is connected with me */ + if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) { + continue; + } + if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) && + ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_FAILED_TO_CONNECT) { + (*no_of_available_dev)++; + } + } + + __FUNC_EXIT__; + return TRUE; } +/** + * This function let the ug calculate how many devices are busy + * @return TRUE + * @param[in] ugd the pointer to the main data structure + * @param[in] dev the pointer to the number of busy devices + */ static bool __wfd_is_any_device_busy(struct ug_data *ugd, int* no_of_busy_dev) { - int i =0 ; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i])) - (*no_of_busy_dev)++; - } - return TRUE; + __FUNC_ENTER__; + GList *iterator = NULL; + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + /* Not include the device which is connected with me */ + if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) { + continue; + } + if (__wfd_is_device_busy(ugd, (device_type_s *)iterator->data)) { + (*no_of_busy_dev)++; + } + } + + __FUNC_EXIT__; + return TRUE; } +/** + * This function let the ug calculate how many devices are connected failed + * @return TRUE + * @param[in] ugd the pointer to the main data structure + * @param[in] dev the pointer to the number of connected failed devices + */ static bool __wfd_is_any_device_connect_failed(struct ug_data *ugd, int* no_of_connect_failed_dev) { - int i =0 ; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) && - ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) - (*no_of_connect_failed_dev)++; - - } - return TRUE; + __FUNC_ENTER__; + GList *iterator = NULL; + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + /* Not include the device which is connected with me */ + if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) { + continue; + } + if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) && + ((device_type_s *)iterator->data)->conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) { + (*no_of_connect_failed_dev)++; + } + } + + __FUNC_EXIT__; + return TRUE; } +/** + * This function let the ug create the main genlist + * @return the main genlist + * @param[in] data the pointer to the main data structure + */ static Evas_Object *_create_basic_genlist(void *data) { __FUNC_ENTER__; - - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) data; Evas_Object *genlist; - Elm_Object_Item *separator_item; + genlist = elm_genlist_add(ugd->layout); + elm_genlist_homogeneous_set(genlist, EINA_TRUE); + elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS); + evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL); + + /* Wifi ON/OFF toggle button */ +#ifdef WFD_ON_OFF_GENLIST + ugd->item_wifi_onoff = elm_genlist_item_append(genlist, &wfd_onoff_itc, ugd, + NULL, ELM_GENLIST_ITEM_NONE,_onoff_changed_cb, ugd); + elm_genlist_item_selected_set(ugd->item_wifi_onoff, + EINA_FALSE); +#endif + evas_object_smart_callback_add(genlist, "realized", _gl_realized, ugd); + evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd); + ugd->device_name_item = elm_genlist_item_append(genlist, &device_name_itc, ugd, NULL, + ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->device_name_item != NULL) + elm_genlist_item_select_mode_set(ugd->device_name_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + + __FUNC_EXIT__; + return genlist; +} + +/** + * This function let the ug create no device item to append the genlist + * @return the main item + * @param[in] data the pointer to the main data structure + */ +Evas_Object *_create_no_device_genlist(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + Elm_Object_Item *last_item = NULL; + int i = 0; - genlist = elm_genlist_add(ugd->naviframe); + WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item); + if (ugd->conn_wfd_item != NULL) { + last_item = ugd->conn_wfd_item; + for (i = 0; i < ugd->gl_connected_peer_cnt; i++) { + last_item = elm_genlist_item_next_get(last_item); + } + } else { + last_item = ugd->device_name_item; + } - separator_item = elm_genlist_item_append(genlist, &sep_itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(separator_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + ugd->nodevice_title_item = elm_genlist_item_insert_after(ugd->genlist, + &title_no_device_itc, (void *)ugd, NULL, last_item, + ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->nodevice_title_item != NULL) + elm_genlist_item_select_mode_set(ugd->nodevice_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - ugd->head = elm_genlist_item_append(genlist, &head_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _gl_header_sel, (void*) ugd); + ugd->nodevice_item = elm_genlist_item_insert_after(ugd->genlist, &noitem_itc, (void *)ugd, NULL, + ugd->nodevice_title_item, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->nodevice_item != NULL) + elm_genlist_item_select_mode_set(ugd->nodevice_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - //elm_genlist_item_select_mode_set(ugd->head, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + __FUNC_EXIT__; + return ugd->genlist; +} +/** + * This function let the ug create busy device list + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int _create_busy_dev_list(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + + ugd->busy_wfd_item = elm_genlist_item_append(ugd->genlist, &title_busy_itc, (void *)ugd, + NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->busy_wfd_item != NULL) + elm_genlist_item_select_mode_set(ugd->busy_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); __FUNC_EXIT__; + return 0; +} - return genlist; +void wfd_free_nodivice_item(struct ug_data *ugd) +{ + __FUNC_ENTER__; + WFD_IF_DEL_ITEM(ugd->nodevice_title_item); + WFD_IF_DEL_ITEM(ugd->nodevice_item); + __FUNC_EXIT__; } -static Evas_Object *_create_about_genlist(void *data) +/** + * This function let the ug create avaliable device list + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int _create_available_dev_genlist(void *data) { - __FUNC_ENTER__; + __FUNC_ENTER__; + int i = 0; + struct ug_data *ugd = (struct ug_data *) data; + Elm_Object_Item *last_item = NULL; + + wfd_free_nodivice_item(ugd); + + if (ugd->conn_wfd_item != NULL) { + last_item = ugd->conn_wfd_item; + for (i=0; i<ugd->gl_connected_peer_cnt; i++) { + last_item = elm_genlist_item_next_get(last_item); + } + } else { + last_item = ugd->device_name_item; + } + + ugd->avlbl_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_available_itc, (void *)ugd, NULL, + last_item, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->avlbl_wfd_item != NULL) { + elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + elm_genlist_item_update(ugd->avlbl_wfd_item); + } + __FUNC_EXIT__; + return 0; +} - struct ug_data *ugd = (struct ug_data*) data; +/** + * This function let the ug create multi connect device list + * @return 0 + * @param[in] data the pointer to the main data structure + */ +static int _create_multi_connect_dev_genlist(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + + ugd->multi_connect_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_multi_connect_itc, (void *)ugd, + NULL, ugd->device_name_item, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->multi_connect_wfd_item != NULL) + elm_genlist_item_select_mode_set(ugd->multi_connect_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + __FUNC_EXIT__; + return 0; +} + +/** + * This function let the ug create connected device list + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int _create_connected_dev_genlist(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; - ugd->about_wfd_item = elm_genlist_item_append(ugd->genlist, &name_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _gl_about_wifi_sel, (void*) ugd); + ugd->conn_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_conn_itc, (void *)ugd, NULL, + ugd->device_name_item, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->conn_wfd_item != NULL) { + elm_genlist_item_select_mode_set(ugd->conn_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + elm_genlist_item_update(ugd->conn_wfd_item); + } - /* add end separator */ - ugd->about_wfdsp_sep_end_item = elm_genlist_item_append(ugd->genlist, &sep_itc_end, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(ugd->about_wfdsp_sep_end_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + __FUNC_EXIT__; + return 0; +} - __FUNC_EXIT__; +/** + * This function let the ug create connected falied device list + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int _create_connected_failed_dev_genlist(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + Elm_Object_Item *last_item = NULL; + int i = 0; + + if (ugd->avlbl_wfd_item != NULL) { + last_item = ugd->avlbl_wfd_item; + for (i=0; i<ugd->gl_available_peer_cnt; i++) { + last_item = elm_genlist_item_next_get(last_item); + } + } else if (ugd->conn_wfd_item != NULL) { + last_item = ugd->conn_wfd_item; + for (i=0; i<ugd->gl_connected_peer_cnt; i++) { + last_item = elm_genlist_item_next_get(last_item); + } + } else { + last_item = ugd->device_name_item; + } - return ugd->genlist; + ugd->conn_failed_wfd_item = elm_genlist_item_insert_after(ugd->genlist, &title_conn_failed_itc, (void *)ugd, + NULL, last_item, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->conn_failed_wfd_item != NULL) + elm_genlist_item_select_mode_set(ugd->conn_failed_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + __FUNC_EXIT__; + return 0; } -static Evas_Object *_create_no_device_genlist(void *data) +/** + * This function let the ug make the display callback for connect failed peers + * @return if stop the timer, return ECORE_CALLBACK_CANCEL, else return ECORE_CALLBACK_RENEW + * @param[in] data the pointer to the user data + */ +static Eina_Bool _connect_failed_peers_display_cb(void *user_data) { - __FUNC_ENTER__; + __FUNC_ENTER__; + int interval = 0; + int res = -1; + struct ug_data *ugd = (struct ug_data *) user_data; + + if (NULL == ugd) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return ECORE_CALLBACK_CANCEL; + } - struct ug_data *ugd = (struct ug_data*) data; + if (ugd->avlbl_wfd_item == NULL) { + _create_available_dev_genlist(ugd); + } - ugd->nodevice_title_item = elm_genlist_item_append(ugd->genlist, &title_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + if (ugd->wfd_discovery_status == WIFI_DIRECT_DISCOVERY_BACKGROUND) { + DBG(LOG_INFO, "Background mode\n"); + ugd->display_timer = NULL; + return ECORE_CALLBACK_CANCEL; + } - ugd->nodevice_item = elm_genlist_item_append(ugd->genlist, &noitem_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + /* check the timeout, if not timeout, keep the cb */ + interval = time(NULL) - ugd->last_display_time; + if (interval < MAX_DISPLAY_TIME_OUT) { + return ECORE_CALLBACK_RENEW; + } + + if (ugd->is_paused == false) { + DBG(LOG_INFO, "Not Paused"); + /* start discovery again */ + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + res = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (res != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res); + wifi_direct_cancel_discovery(); + } + } - ugd->nodevice_sep_low_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + ugd->display_timer = NULL; + __FUNC_EXIT__; + return ECORE_CALLBACK_CANCEL; +} - elm_genlist_item_select_mode_set(ugd->nodevice_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); +void wfd_ug_view_free_peer(device_type_s *gl_peers_start) +{ + __FUNC_ENTER__; + device_type_s *peer_for_free = NULL; + device_type_s *peer = gl_peers_start; + + while (peer != NULL && peer->gl_item != NULL) { + DBG(LOG_INFO, "Deleted item, ssid:%s\n", peer->ssid); + elm_object_item_del(peer->gl_item); + peer->gl_item = NULL; + peer_for_free = peer; + peer = peer->next; + free(peer_for_free); + } + __FUNC_EXIT__; +} - __FUNC_EXIT__; - return ugd->genlist; +void wfd_check_gl_conn_peers(struct ug_data *ugd) +{ + __FUNC_ENTER__; + if (ugd->gl_connected_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->conn_wfd_item); + } + __FUNC_EXIT__; } -int _create_multi_button_genlist(void *data) +/** + * This function let the ug free the peers + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_ug_view_free_peers(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + + ugd->gl_connected_peer_cnt = 0; + + if (ugd->gl_conn_peers_start != NULL) { + wfd_ug_view_free_peer(ugd->gl_conn_peers_start); + ugd->gl_conn_peers_start = NULL; + } + + ugd->gl_available_peer_cnt = 0; - ugd->multi_button_sep_high_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + if (ugd->gl_avlb_peers_start != NULL) { + wfd_ug_view_free_peer(ugd->gl_avlb_peers_start); + ugd->gl_avlb_peers_start = NULL; + } - /* if not connected and number of devices is less than 2, don't show the button */ - if (ugd->raw_multi_selected_peer_cnt > 1 || - ugd->gl_available_peer_cnt > 1 || - ugd->gl_connected_peer_cnt > 0) { - ugd->multi_button_item = elm_genlist_item_append(ugd->genlist, &button_itc, ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); - ugd->multi_button_sep_low_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + ugd->gl_busy_peer_cnt = 0; + + if (ugd->gl_busy_peers_start != NULL) { + wfd_ug_view_free_peer(ugd->gl_busy_peers_start); + ugd->gl_busy_peers_start = NULL; } - evas_object_show(ugd->multi_btn); - __FUNC_EXIT__; - return 0; + ugd->gl_multi_connect_peer_cnt = 0; + + if (ugd->gl_mul_conn_peers_start != NULL) { + wfd_ug_view_free_peer(ugd->gl_mul_conn_peers_start); + ugd->gl_mul_conn_peers_start = NULL; + } + + if (ugd->gl_connected_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->conn_wfd_item); + } + + if (ugd->display_timer != NULL) { + ecore_timer_del(ugd->display_timer); + ugd->display_timer = NULL; + } + + WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item); + WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item); + WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item); + WFD_IF_DEL_ITEM(ugd->busy_wfd_item); + + __FUNC_EXIT__; } +void wfd_ug_update_toolbar(struct ug_data *ugd) +{ + __FUNC_ENTER__; + int no_of_conn_dev = ugd->raw_connected_peer_cnt; + Evas_Object *btn; -int _create_busy_dev_list(void *data) + wfd_refresh_wifi_direct_state(ugd); + if (ugd->wfd_status == WIFI_DIRECT_STATE_CONNECTING) { + DBG(LOG_INFO, "WIFI_DIRECT_STATE_CONNECTING\n"); + if( ugd->multi_connect_wfd_item != NULL) { + DBG(LOG_INFO, "multi_connect_toolbar_item\n"); + btn = elm_button_add(ugd->layout); + /* Use "bottom" style button */ + elm_object_style_set(btn, "bottom"); + elm_object_domain_translatable_text_set(btn, PACKAGE, + "IDS_WIFI_SK2_CANCEL_CONNECTION"); + evas_object_smart_callback_add(btn, "clicked", + _wfd_ug_cancel_connection_button_cb, (void *)ugd); + /* Set button into "toolbar" swallow part */ + elm_object_part_content_set(ugd->layout, "button.next", btn); + ugd->disconnect_btn = btn; + evas_object_show(ugd->disconnect_btn); + elm_object_part_content_set(ugd->layout, "button.prev", + ugd->scan_toolbar); + wfd_ug_view_refresh_button(ugd->scan_toolbar, + "IDS_WIFI_SK4_SCAN", FALSE); + evas_object_data_set(ugd->disconnect_btn, "multi", "disconnect"); + DBG(LOG_INFO, "button: disconnect button added\n"); + } else { + DBG(LOG_INFO, "scan_toolbar\n"); + WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item); + wfd_ug_view_refresh_button(ugd->scan_toolbar, + "IDS_WIFI_SK2_CANCEL_CONNECTION", TRUE); + evas_object_data_set(ugd->scan_btn, "multi", "cancel"); + DBG(LOG_INFO, "button: stop connect button added\n"); + } + } else if (no_of_conn_dev > 0) { + if (!ugd->multi_connect_toolbar_item) { + btn = elm_button_add(ugd->layout); + /* Use "bottom" style button */ + elm_object_style_set(btn, "bottom"); + elm_object_domain_translatable_text_set(btn, PACKAGE, + "IDS_WIFI_SK_DISCONNECT"); + evas_object_smart_callback_add(btn, "clicked", + _wfd_ug_disconnect_button_cb, (void *)ugd); + /* Set button into "toolbar" swallow part */ + elm_object_part_content_set(ugd->layout, "button.next", btn); + ugd->disconnect_btn = btn; + evas_object_show(ugd->disconnect_btn); + } + elm_object_part_content_set(ugd->layout, "button.prev", + ugd->scan_toolbar); + wfd_ug_view_refresh_button(ugd->scan_toolbar, + "IDS_WIFI_SK4_SCAN", TRUE); + evas_object_data_set(ugd->disconnect_btn, "multi", "disconnect"); + DBG(LOG_INFO, "button: disconnect button added\n"); + }else { + if (no_of_conn_dev == 0 && ugd->disconnect_btn != NULL) { + DBG(LOG_INFO, "disconnect btn removed when conn failed\n"); + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + ugd->disconnect_btn = NULL; + elm_object_part_content_set(ugd->layout, "button.big", + ugd->scan_toolbar); + } + wfd_ug_view_refresh_button(ugd->scan_toolbar, + "IDS_WIFI_SK4_SCAN", TRUE); + evas_object_data_set(ugd->scan_toolbar, "multi", "connect"); + DBG(LOG_INFO, "button: scan button added\n"); + } + __FUNC_EXIT__; +} + +/** + * This function let the ug init the genlist + */ +void wfd_ug_view_init_genlist(void *data, bool is_free_all_peers) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + int no_of_busy_dev = 0; + int no_of_available_dev = 0; + int no_of_conn_failed_dev = 0; - ugd->busy_wfd_item = elm_genlist_item_append(ugd->genlist, &title_busy_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + if (is_free_all_peers) { + wfd_ug_view_free_peers(ugd); + } + + if (ugd->gl_failed_peers_start != NULL) { + DBG(LOG_INFO, "These are failed peers, must clear them"); + ugd->gl_connected_failed_peer_cnt = 0; + wfd_ug_view_free_peer(ugd->gl_failed_peers_start); + ugd->gl_failed_peers_start = NULL; + WFD_IF_DEL_ITEM(ugd->conn_failed_wfd_item); + } - elm_genlist_item_select_mode_set(ugd->busy_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + if (ugd->avlbl_wfd_item != NULL) { + DBG(LOG_INFO, "There are available peers in genlist"); + wfd_ug_view_refresh_glitem(ugd->avlbl_wfd_item); + return; + } + __wfd_is_any_device_busy(ugd, &no_of_busy_dev); + __wfd_is_any_device_available(ugd, &no_of_available_dev); + __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev); - __FUNC_EXIT__; - return 0; + __FUNC_EXIT__; } -static int _create_available_dev_genlist(void *data) +/** + * This function let the ug find a peer in genlist + */ +device_type_s *find_peer_in_glist(device_type_s *start_pos, const char *mac_addr) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + + if (start_pos == NULL) { + DBG(LOG_INFO, "no peer in genlist"); + return NULL; + } - ugd->avlbl_wfd_item = elm_genlist_item_append(ugd->genlist, &title_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + device_type_s *peer = start_pos; - // elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + while (peer != NULL) { + if (!strncmp(peer->mac_addr, mac_addr, MAC_LENGTH - 1)) { + peer->is_alive = true; + DBG(LOG_INFO, "device [%s] found in genlist", peer->ssid); + __FUNC_EXIT__; + return peer; + } + peer = peer->next; + } - __FUNC_EXIT__; - return 0; + __FUNC_EXIT__; + return NULL; } -static int _create_multi_connect_dev_genlist(void *data) +void delete_not_alive_peers(struct ug_data *ugd, device_type_s **start_pos, int *cnt) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - ugd->multi_connect_wfd_item = elm_genlist_item_append(ugd->genlist, &title_multi_connect_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + __FUNC_ENTER__; + if (*start_pos == NULL) { + DBG(LOG_INFO, "no peer in genlist"); + return; + } - // elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + device_type_s *peer = *start_pos; + device_type_s *peer_tmp = NULL; + while (peer != NULL) { + peer_tmp = peer->next; + if(peer->is_alive == false) { + free_gl_peer(start_pos, peer->mac_addr, cnt); + } + peer = peer_tmp; + } - __FUNC_EXIT__; - return 0; +// wfd_check_gl_available_peers(ugd); + if (ugd->gl_busy_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->busy_wfd_item); + } + __FUNC_EXIT__; + return; } -int _create_connected_dev_genlist(void *data) +void set_not_alive_peers(device_type_s *start_pos) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + if (start_pos == NULL) { + DBG(LOG_INFO, "no peer in genlist"); + return; + } - ugd->conn_wfd_item = elm_genlist_item_append(ugd->genlist, &title_conn_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + device_type_s *peer = start_pos; + while (peer != NULL) { + peer->is_alive = false; + peer = peer->next; + } - elm_genlist_item_select_mode_set(ugd->conn_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - __FUNC_EXIT__; - return 0; + __FUNC_EXIT__; + return; } -int _create_connected_failed_dev_genlist(void *data) +/** + * This function let the ug get the insert position for next item + */ +Elm_Object_Item *get_insert_postion(device_type_s *peer, Elm_Object_Item *pre_item, int peer_cnt) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + int i = 0; + device_type_s *peer_ite = NULL; + Elm_Object_Item *head = elm_genlist_item_next_get(pre_item); + Elm_Object_Item *item = NULL; + + if(peer_cnt == 0) { + DBG(LOG_INFO, "first peer [%s] would be added", peer->ssid); + return pre_item; + } - ugd->conn_failed_wfd_item = elm_genlist_item_append(ugd->genlist, &title_conn_failed_itc, (void*)ugd, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); + peer_ite = (device_type_s *)elm_object_item_data_get(head); + WFD_RETV_IF(peer_ite == NULL, NULL, "peer_ite is NULL\n"); + + if(peer_ite->gl_item != NULL) { + for(i=0; i < peer_cnt; i++) { + if (strcasecmp(peer_ite->ssid, peer->ssid) > 0) { + /* if peer_ite is greater than peer, return previous item */ + __FUNC_EXIT__; + return elm_genlist_item_prev_get(head); + } else { + item = elm_genlist_item_next_get(head); + if (item == NULL) { + /* return the last item */ + return head; + } else { + head = item; + peer_ite = (device_type_s *)elm_object_item_data_get(head); + } + } + } + } + __FUNC_EXIT__; + return elm_genlist_item_prev_get(head); +} + +/** + * This function let the ug insert peer item to genlist + */ +int insert_gl_item(Evas_Object *genlist, Elm_Object_Item *item, Elm_Gen_Item_Class *itc, device_type_s **start_pos, + device_type_s *peer_for_insert, void *callback) +{ + __FUNC_ENTER__; + WFD_RETV_IF(item == NULL, -1, "Item is NULL\n"); + device_type_s *peer = NULL; + device_type_s *peer_ite = NULL; + + peer = (device_type_s *)malloc(sizeof(device_type_s)); + WFD_RETV_IF(peer == NULL, -1, "malloc failed\n"); + + memcpy(peer, peer_for_insert, sizeof(device_type_s)); + peer->next = NULL; + + if(*start_pos == NULL) { + *start_pos = peer; + } else { + peer_ite = *start_pos; + while(peer_ite->next != NULL) { + /* move pointer to the last peer */ + peer_ite = peer_ite->next; + } + peer_ite->next = peer; + } - elm_genlist_item_select_mode_set(ugd->conn_failed_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - __FUNC_EXIT__; - return 0; + peer->is_alive = true; + peer->gl_item = elm_genlist_item_insert_after(genlist, itc, (void *)peer, NULL, item, + ELM_GENLIST_ITEM_NONE, callback, (void *)peer); + if (callback == NULL && peer->gl_item != NULL) { + elm_genlist_item_select_mode_set(peer->gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + } + __FUNC_EXIT__; + return 0; } -static Eina_Bool _connect_failed_peers_display_cb(void *user_data) +/** + * This function let the ug update connected peers + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_ug_update_connected_peers(void *data) { - int interval = 0; - struct ug_data *ugd = (struct ug_data*) user_data; + __FUNC_ENTER__; - if (NULL == ugd) { - DBG(LOG_ERROR, "NULL parameters.\n"); - return ECORE_CALLBACK_CANCEL; + struct ug_data *ugd = (struct ug_data *) data; + int i = 0 ; + int res; + bool is_group_owner = FALSE; + Elm_Object_Item *item = NULL; + + res = wifi_direct_is_group_owner(&is_group_owner); + if (res == WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_INFO, "is_group_owner=[%d]", is_group_owner); } - /* check the timeout, if not timeout, keep the cb */ - interval = time(NULL) - ugd->last_display_time; - if (interval < MAX_DISPLAY_TIME_OUT) { - return ECORE_CALLBACK_RENEW; + if (!ugd->conn_wfd_item) { + _create_connected_dev_genlist(ugd); } - /* re-discovery */ - wfd_client_start_discovery(ugd); + for (i = 0; i < ugd->raw_connected_peer_cnt; i++) { + if (find_peer_in_glist(ugd->gl_conn_peers_start, ugd->raw_connected_peers[i].mac_addr) == NULL) { + if (find_peer_in_glist(ugd->gl_avlb_peers_start, ugd->raw_connected_peers[i].mac_addr) != NULL) { + free_gl_peer(&ugd->gl_avlb_peers_start, ugd->raw_connected_peers[i].mac_addr, + &ugd->gl_available_peer_cnt); + wfd_check_gl_available_peers(ugd); + } - /* get peers and update the view */ - wfd_ug_get_discovered_peers(ugd); - wfd_ug_get_connected_peers(ugd); - wfd_ug_view_update_peers(ugd); + if (find_peer_in_glist(ugd->gl_mul_conn_peers_start, ugd->raw_connected_peers[i].mac_addr) != NULL) { + free_gl_peer(&ugd->gl_mul_conn_peers_start, ugd->raw_connected_peers[i].mac_addr, + &ugd->gl_multi_connect_peer_cnt); + if (ugd->gl_multi_connect_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item); + WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item); + } + } - return ECORE_CALLBACK_CANCEL; + item = get_insert_postion(&(ugd->raw_connected_peers[i]), ugd->conn_wfd_item, + ugd->gl_connected_peer_cnt); + res = insert_gl_item(ugd->genlist, item, &peer_conn_itc, &ugd->gl_conn_peers_start, + &ugd->raw_connected_peers[i], NULL); + if (res != 0) { + break; + } + ugd->gl_connected_peer_cnt++; + } + } + + /* if is not GO, free all available peers */ + if (is_group_owner == FALSE) { + ugd->gl_available_peer_cnt = 0; + WFD_IF_DEL_ITEM(ugd->avlbl_wfd_item); + + if (ugd->gl_avlb_peers_start != NULL) { + wfd_ug_view_free_peer(ugd->gl_avlb_peers_start); + ugd->gl_avlb_peers_start = NULL; + } + } + + /* free busy peers */ + if (ugd->gl_busy_peers_start != NULL) { + ugd->gl_busy_peer_cnt = 0; + WFD_IF_DEL_ITEM(ugd->busy_wfd_item); + + wfd_ug_view_free_peer(ugd->gl_busy_peers_start); + ugd->gl_busy_peers_start = NULL; + + } + + __FUNC_EXIT__; } -void wfd_ug_view_free_peers(void *data) +/** + * This function let the ug update the multi-connect peers + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_ug_view_update_multiconn_peers(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int i; - - for(i = 0; i < ugd->gl_connected_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "%dth connected peer = %x is deleted\n", i, ugd->gl_connected_peers[i]); - if (ugd->gl_connected_peers[i].gl_item != NULL) - { - elm_object_item_del(ugd->gl_connected_peers[i].gl_item); - ugd->gl_connected_peers[i].gl_item = NULL; - DBG(LOG_VERBOSE, "Deleted item\n"); - } - } - ugd->gl_connected_peer_cnt = 0; + __FUNC_ENTER__; - for(i = 0; i < ugd->gl_connected_failed_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "%dth connected failed peer = %x is deleted\n", i, ugd->gl_connected_failed_peers[i]); - if (ugd->gl_connected_failed_peers[i].gl_item != NULL) - { - elm_object_item_del(ugd->gl_connected_failed_peers[i].gl_item); - ugd->gl_connected_failed_peers[i].gl_item = NULL; - DBG(LOG_VERBOSE, "Deleted item\n"); - } - } - - ugd->gl_connected_failed_peer_cnt = 0; - - for(i = 0; i < ugd->gl_available_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "%dth discovered peer = %x is deleted\n", i, ugd->gl_available_peers[i]); - if (ugd->gl_available_peers[i].gl_item != NULL) - { - elm_object_item_del(ugd->gl_available_peers[i].gl_item); - ugd->gl_available_peers[i].gl_item = NULL; - DBG(LOG_VERBOSE, "Deleted item\n"); - } - } - ugd->gl_available_peer_cnt = 0; + struct ug_data *ugd = (struct ug_data *) data; + int i; + int res; + Elm_Object_Item *item = NULL; - for(i = 0; i < ugd->gl_busy_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "%dth busy peer = %x is deleted\n", i, ugd->gl_busy_peers[i]); - if (ugd->gl_busy_peers[i].gl_item != NULL) - { - elm_object_item_del(ugd->gl_busy_peers[i].gl_item); - ugd->gl_busy_peers[i].gl_item = NULL; - DBG(LOG_VERBOSE, "Deleted item\n"); - } - } - ugd->gl_busy_peer_cnt = 0; + if (ugd->raw_multi_selected_peer_cnt > 0) { + if (ugd->raw_connected_peer_cnt < ugd->raw_multi_selected_peer_cnt && + ugd->multi_connect_wfd_item == NULL) { + _create_multi_connect_dev_genlist(ugd); + } - for(i = 0; i < ugd->gl_multi_connect_peer_cnt; i++) - { - DBG(LOG_VERBOSE, "%dth busy peer = %x is deleted\n", i, ugd->gl_multi_connect_peers[i]); - if (ugd->gl_multi_connect_peers[i].gl_item != NULL) - { - elm_object_item_del(ugd->gl_multi_connect_peers[i].gl_item); - ugd->gl_multi_connect_peers[i].gl_item = NULL; - DBG(LOG_VERBOSE, "Deleted item\n"); - } - } - ugd->gl_multi_connect_peer_cnt = 0; + for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) { + if (ugd->raw_multi_selected_peers[i].conn_status != PEER_CONN_STATUS_CONNECTED) { + item = get_insert_postion(&(ugd->raw_multi_selected_peers[i]), + ugd->multi_connect_wfd_item, ugd->gl_multi_connect_peer_cnt); + res = insert_gl_item(ugd->genlist, item, &peer_itc, &ugd->gl_mul_conn_peers_start, + &ugd->raw_multi_selected_peers[i], NULL); + if (res != 0) { + break; + } + ugd->gl_multi_connect_peer_cnt++; + } + } + } - if(ugd->nodevice_title_item != NULL) - { - elm_object_item_del(ugd->nodevice_title_item); - ugd->nodevice_title_item = NULL; - } - if(ugd->nodevice_item != NULL) - { - elm_object_item_del(ugd->nodevice_item); - ugd->nodevice_item = NULL; - } - if(ugd->nodevice_sep_low_item != NULL) - { - elm_object_item_del(ugd->nodevice_sep_low_item); - ugd->nodevice_sep_low_item = NULL; - } - if(ugd->about_wfd_item != NULL) - { - elm_object_item_del(ugd->about_wfd_item); - ugd->about_wfd_item = NULL; - } - - if(ugd->conn_wfd_item != NULL) - { - elm_object_item_del(ugd->conn_wfd_item); - ugd->conn_wfd_item = NULL; - } - if(ugd->conn_failed_wfd_item != NULL) - { - elm_object_item_del(ugd->conn_failed_wfd_item); - ugd->conn_failed_wfd_item = NULL; - } - if(ugd->conn_failed_wfd_sep_item != NULL) - { - elm_object_item_del(ugd->conn_failed_wfd_sep_item); - ugd->conn_failed_wfd_sep_item = NULL; - } - if(ugd->display_timer != NULL) - { - elm_object_item_del(ugd->display_timer); - ugd->display_timer = NULL; - } - if(ugd->multi_connect_wfd_item != NULL) - { - elm_object_item_del(ugd->multi_connect_wfd_item); - ugd->multi_connect_wfd_item = NULL; - } - if(ugd->avlbl_wfd_item != NULL) - { - elm_object_item_del(ugd->avlbl_wfd_item); - ugd->avlbl_wfd_item = NULL; - } - if(ugd->busy_wfd_item != NULL) - { - elm_object_item_del(ugd->busy_wfd_item); - ugd->busy_wfd_item = NULL; - } - if(ugd->busy_wfd_sep_item != NULL) - { - elm_object_item_del(ugd->busy_wfd_sep_item); - ugd->busy_wfd_sep_item = NULL; - } - - if(ugd->multi_button_item != NULL) - { - elm_object_item_del(ugd->multi_button_item); - ugd->multi_button_item = NULL; - } - if(ugd->multi_button_sep_high_item != NULL) - { - elm_object_item_del(ugd->multi_button_sep_high_item); - ugd->multi_button_sep_high_item = NULL; - } - if(ugd->multi_button_sep_low_item != NULL) - { - elm_object_item_del(ugd->multi_button_sep_low_item); - ugd->multi_button_sep_low_item = NULL; - } - if(ugd->about_wfdsp_sep_end_item != NULL) - { - elm_object_item_del(ugd->about_wfdsp_sep_end_item); - ugd->about_wfdsp_sep_end_item = NULL; - } - - __FUNC_EXIT__; + __FUNC_EXIT__; } - -void wfd_ug_view_update_peers(void *data) +/** + * This function let the ug update the available and busy peers + */ +void wfd_ug_update_available_peers(void *data) { - __FUNC_ENTER__; - - struct ug_data *ugd = (struct ug_data*) data; - int no_of_busy_dev = 0; - int no_of_available_dev = 0; - int no_of_conn_dev = 0; - int no_of_conn_failed_dev = 0; - int i = 0 ; - int res = 0; - bool is_group_owner = FALSE; - int count = 0; - - wfd_ug_view_free_peers(ugd); - - if(ugd->wfd_status == WFD_LINK_STATUS_DEACTIVATED) - { - DBG(LOG_VERBOSE, "Device is deactivated, no need to update UI."); - // Add seperator... - ugd->multi_button_sep_high_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); - _create_about_genlist(ugd); - return; - } - - res = wifi_direct_is_group_owner(&is_group_owner); - if (res != WIFI_DIRECT_ERROR_NONE) - { - DBG(LOG_VERBOSE, "Fail to get group_owner_state. ret=[%d]", res); - ugd->I_am_group_owner = FALSE; - // continue... - } - else - { - ugd->I_am_group_owner = is_group_owner; - } - - __wfd_is_any_device_busy(ugd, &no_of_busy_dev); - __wfd_is_any_device_available(ugd, &no_of_available_dev); - __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev); - no_of_conn_dev = ugd->raw_connected_peer_cnt; - - ugd->gl_available_peer_cnt = no_of_available_dev; - ugd->gl_connected_peer_cnt = no_of_conn_dev; - ugd->gl_connected_failed_peer_cnt = no_of_conn_failed_dev; - ugd->gl_busy_peer_cnt = no_of_busy_dev; - - DBG(LOG_VERBOSE, "conn_dev=[%d], conn_failed_dev=[%d], avail_dev=[%d], busy_dev=[%d], GO=[%d]\n", - no_of_conn_dev, no_of_conn_failed_dev, no_of_available_dev, no_of_busy_dev, is_group_owner); - - if (no_of_conn_dev == 0 && no_of_conn_failed_dev == 0 && - no_of_available_dev == 0 && no_of_busy_dev == 0) - { - DBG(LOG_ERROR, "There are No peers\n"); - _create_no_device_genlist(ugd); - _create_about_genlist(ugd); - return; - } - - if (no_of_conn_dev > 0) - { - if (!ugd->conn_wfd_item) - _create_connected_dev_genlist(ugd); - - count = 0; - for(i = 0; i < ugd->raw_connected_peer_cnt; i++) - { - if (ugd->gl_connected_peers[count].gl_item) - elm_object_item_del(ugd->gl_connected_peers[count].gl_item); - - memcpy(&ugd->gl_connected_peers[count], &ugd->raw_connected_peers[i], sizeof(device_type_s)); - - ugd->gl_connected_peers[count].gl_item = - elm_genlist_item_append(ugd->genlist, &peer_conn_itc, (void*) &(ugd->gl_connected_peers[i]), NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(ugd->gl_connected_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - count++; - } - } - - if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE) - { - if (ugd->raw_multi_selected_peer_cnt > 0) - { - if (ugd->avlbl_wfd_item == NULL) - _create_multi_connect_dev_genlist(ugd); - - count = 0; - for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) - { - if (ugd->raw_multi_selected_peers[i].conn_status != PEER_CONN_STATUS_CONNECTED) - { - if (ugd->gl_multi_connect_peers[count].gl_item) - elm_object_item_del(ugd->gl_multi_connect_peers[count].gl_item); - - memcpy(&ugd->gl_multi_connect_peers[count], &ugd->raw_multi_selected_peers[i], sizeof(device_type_s)); - - ugd->gl_multi_connect_peers[count].gl_item = - elm_genlist_item_append(ugd->genlist, &peer_itc, (void*) &(ugd->gl_multi_connect_peers[count]), NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); - count++; - } - else - { - // device is connected.. - // skip it... - } + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + int no_of_busy_dev = 0; + int no_of_available_dev = 0; + int no_of_conn_dev = 0; + bool is_group_owner = FALSE; + int res = 0; + Elm_Object_Item *item = NULL; + device_type_s *peer = NULL; + GList *iterator = NULL; + + __wfd_is_any_device_busy(ugd, &no_of_busy_dev); + __wfd_is_any_device_available(ugd, &no_of_available_dev); + no_of_conn_dev = ugd->raw_connected_peer_cnt; + + res = wifi_direct_is_group_owner(&is_group_owner); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_INFO, "Fail to get group_owner_state. ret=[%d]", res); + ugd->I_am_group_owner = FALSE; + } else { + ugd->I_am_group_owner = is_group_owner; + } + + DBG(LOG_INFO, "avail_dev=[%d], busy_dev=[%d], GO=[%d]\n", no_of_available_dev, no_of_busy_dev, is_group_owner); + if (no_of_available_dev != 0 || no_of_busy_dev != 0) { + DBG(LOG_INFO, "There are available or busy peers\n"); + wfd_free_nodivice_item(ugd); + } + + if (no_of_conn_dev == 0 || is_group_owner == TRUE) { + if (ugd->avlbl_wfd_item == NULL) { + _create_available_dev_genlist(ugd); + } + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + /* Not include the device which is connected with me */ + if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) { + continue; } - ugd->gl_multi_connect_peer_cnt = count; - } - - _create_multi_button_genlist(ugd); - } - else - { - // Note that - // If GC, no display available peers - // Otherwise, display available peers -#if 0 - if (no_of_available_dev > 0 && (no_of_conn_dev == 0 || is_group_owner==TRUE)) -#else - // display available peers - if (no_of_available_dev > 0) -#endif - { - if (ugd->avlbl_wfd_item == NULL) - _create_available_dev_genlist(ugd); - - count = 0; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) && - ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_DISCONNECTED) - { - if (ugd->gl_available_peers[count].gl_item) - elm_object_item_del(ugd->gl_available_peers[count].gl_item); - - memcpy(&ugd->gl_available_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s)); - - ugd->gl_available_peers[count].gl_item = - elm_genlist_item_append(ugd->genlist, &peer_itc, (void*) &(ugd->gl_available_peers[count]), NULL, - ELM_GENLIST_ITEM_NONE, _gl_peer_sel, (void*) &(ugd->gl_available_peers[count])); - count++; + if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) && + ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_FAILED_TO_CONNECT && + ((device_type_s *)iterator->data)->conn_status != PEER_CONN_STATUS_CONNECTED) { + /* free disconnected gl peer */ + if (find_peer_in_glist(ugd->gl_conn_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) { + free_gl_peer(&ugd->gl_conn_peers_start, ((device_type_s *)iterator->data)->mac_addr, + &ugd->gl_connected_peer_cnt); } - else - { - // device is busy or connected.. - // skip it... + + /* free busy gl peer, which is available now */ + if (find_peer_in_glist(ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) { + free_gl_peer(&ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr, &ugd->gl_busy_peer_cnt); + if (ugd->gl_busy_peer_cnt == 0) { + WFD_IF_DEL_ITEM(ugd->busy_wfd_item); + } } - } - } - _create_multi_button_genlist(ugd); - - // If connected, not display busy device... - if (no_of_conn_dev == 0 && no_of_busy_dev > 0) - { - if (ugd->busy_wfd_item == NULL) - _create_busy_dev_list(ugd); - - count = 0; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) == TRUE) - { - if (ugd->gl_busy_peers[count].gl_item) - elm_object_item_del(ugd->gl_busy_peers[count].gl_item); - - memcpy(&ugd->gl_busy_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s)); - - ugd->gl_busy_peers[count].gl_item = - elm_genlist_item_append(ugd->genlist, &peer_busy_itc, (void*) &(ugd->gl_busy_peers[count]), NULL, - ELM_GENLIST_ITEM_NONE, _gl_busy_peer_sel, ugd); - //elm_genlist_item_select_mode_set(ugd->gl_busy_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - count++; + if (find_peer_in_glist(ugd->gl_failed_peers_start, (const char *)((device_type_s *)iterator->data)->mac_addr) != NULL) { + continue; } - else - { - // device is available or connected.. - // skip it... + + peer = find_peer_in_glist(ugd->gl_avlb_peers_start, (const char *)((device_type_s *)iterator->data)->mac_addr); + if (peer == NULL) { + item = get_insert_postion((device_type_s *)iterator->data, + ugd->avlbl_wfd_item, ugd->gl_available_peer_cnt); + res = insert_gl_item(ugd->genlist, item, &peer_itc, &ugd->gl_avlb_peers_start, + (device_type_s *)iterator->data, _gl_peer_sel); + if (res != 0) { + break; + } + ugd->gl_available_peer_cnt++; + } else if (no_of_conn_dev > 0 && ((device_type_s *)iterator->data)->is_group_owner == TRUE) { + /* if peer is GO, free it */ + free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr, + &ugd->gl_available_peer_cnt); } } - ugd->busy_wfd_sep_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); } + } - /* display connect failed peers */ - if (no_of_conn_failed_dev > 0) - { - if (!ugd->conn_failed_wfd_item) - _create_connected_failed_dev_genlist(ugd); + wfd_check_gl_available_peers(ugd); + wfd_check_gl_conn_peers(ugd); - /* add timer for disappearing failed peers after N secs */ - if (NULL == ugd->display_timer) { - ugd->last_display_time = time(NULL); - ugd->display_timer = ecore_timer_add(5.0, (Ecore_Task_Cb)_connect_failed_peers_display_cb, ugd); - } + if (no_of_conn_dev == 0 && no_of_busy_dev > 0) { + if (ugd->busy_wfd_item == NULL) { + _create_busy_dev_list(ugd); + } - count = 0; - for (i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) && - ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) - { - if (ugd->gl_connected_failed_peers[count].gl_item) - elm_object_item_del(ugd->gl_connected_failed_peers[count].gl_item); - - memcpy(&ugd->gl_connected_failed_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s)); - - ugd->gl_connected_failed_peers[count].gl_item = - elm_genlist_item_append(ugd->genlist, &peer_conn_failed_itc, (void*) &(ugd->gl_connected_failed_peers[count]), NULL, - ELM_GENLIST_ITEM_NONE, NULL, ugd); - elm_genlist_item_select_mode_set(ugd->gl_connected_failed_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - count++; + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + /* Not include the device which is connected with me */ + if (__wfd_is_device_connected_with_me(ugd, (device_type_s *)iterator->data)) { + continue; + } + if (__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) == TRUE) { + if (find_peer_in_glist(ugd->gl_busy_peers_start, ((device_type_s *)iterator->data)->mac_addr) == NULL) { + if (find_peer_in_glist(ugd->gl_avlb_peers_start, + ((device_type_s *)iterator->data)->mac_addr) != NULL) { + free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr, + &ugd->gl_available_peer_cnt); + wfd_check_gl_available_peers(ugd); + } + item = get_insert_postion((device_type_s *)iterator->data, ugd->busy_wfd_item, + ugd->gl_busy_peer_cnt); + res = insert_gl_item(ugd->genlist, item, &peer_busy_itc, &ugd->gl_busy_peers_start, + (device_type_s *)iterator->data, _gl_busy_peer_sel); + if (res != 0) { + break; + } + ugd->gl_busy_peer_cnt++; } } - - ugd->conn_failed_wfd_sep_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL, - ELM_GENLIST_ITEM_NONE, NULL, NULL); - } - } - _create_about_genlist(ugd); + } - __FUNC_EXIT__; -} + wfd_check_gl_busy_peers(ugd); + __FUNC_EXIT__; +} -void create_wfd_ug_view(void *data) +/** + * This function let the ug update the failed peers + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_ug_update_failed_peers(void *data) { - __FUNC_ENTER__; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + int no_of_conn_failed_dev = 0; + GList *iterator = NULL; - struct ug_data *ugd = (struct ug_data*) data; - Evas_Object *back_btn = NULL; - Elm_Object_Item *navi_item = NULL; - Evas_Object *control_bar = NULL; - Elm_Object_Item *item = NULL; + __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev); + DBG(LOG_INFO, "conn_failed_dev=[%d]", no_of_conn_failed_dev); - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)"); - return; - } + if (no_of_conn_failed_dev == 0) { + return; + } + + /* add timer for disappearing failed peers after N secs */ + if (NULL == ugd->display_timer) { + ugd->last_display_time = time(NULL); + ugd->display_timer = ecore_timer_add(0.05, (Ecore_Task_Cb)_connect_failed_peers_display_cb, ugd); + } + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + if (!__wfd_is_device_busy(ugd, (device_type_s *)iterator->data) && + ((device_type_s *)iterator->data)->conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT) { + if (find_peer_in_glist(ugd->gl_failed_peers_start, ((device_type_s *)iterator->data)->mac_addr) == NULL) { + if (find_peer_in_glist(ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr) != NULL) { + free_gl_peer(&ugd->gl_avlb_peers_start, ((device_type_s *)iterator->data)->mac_addr, + &ugd->gl_available_peer_cnt); + wfd_check_gl_available_peers(ugd); + } + } + } + } + + __FUNC_EXIT__; +} + +#ifdef WFD_ON_OFF_GENLIST +/** + * This function is called when user swipes on/off button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _onoff_changed_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + WFD_RET_IF(ugd->on_off_check == NULL, "on_off_check(NULL)\n"); + wfd_refresh_wifi_direct_state(ugd); + if(ugd->device_name_item != NULL) + elm_genlist_item_update(ugd->device_name_item); + + elm_object_disabled_set(ugd->on_off_check, TRUE); + if(ugd->disconnect_btn) { + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + ugd->disconnect_btn = NULL; + } + elm_object_part_content_set(ugd->layout, "button.big", ugd->scan_toolbar); + + /* turn on/off wfd */ + if (!ugd->wfd_onoff) { + if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) { + DBG(LOG_INFO, "wifi-direct switch on\n"); + elm_genlist_item_selected_set(ugd->item_wifi_onoff, + EINA_FALSE); + wfd_client_switch_on(ugd); + } + } else { + if (ugd->wfd_status >= WIFI_DIRECT_STATE_ACTIVATING) { + DBG(LOG_INFO, "wifi-direct switch off\n"); + elm_genlist_item_selected_set(ugd->item_wifi_onoff, + EINA_FALSE); + wfd_client_switch_off(ugd); + } + } - ugd->naviframe = elm_naviframe_add(ugd->base); - elm_object_part_content_set(ugd->base, "elm.swallow.content", ugd->naviframe); - evas_object_show(ugd->naviframe); + __FUNC_EXIT__; +} - back_btn = elm_button_add(ugd->naviframe); - elm_object_style_set(back_btn, "naviframe/back_btn/default"); - evas_object_smart_callback_add(back_btn, "clicked", _back_btn_cb, (void*) ugd); - elm_object_focus_allow_set(back_btn, EINA_FALSE); +void wfd_ug_refresh_on_off_check(struct ug_data *ugd) +{ + __FUNC_ENTER__; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + WFD_RET_IF(ugd->on_off_check == NULL, "on_off_check(NULL)\n"); + wfd_refresh_wifi_direct_state(ugd); + if (ugd->wfd_status == WIFI_DIRECT_STATE_DEACTIVATING || + ugd->wfd_status == WIFI_DIRECT_STATE_ACTIVATING ) { + elm_object_disabled_set(ugd->on_off_check, TRUE); + } else { + elm_object_disabled_set(ugd->on_off_check, FALSE); + } + if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) { + elm_check_state_set(ugd->on_off_check, TRUE); + } else { + elm_check_state_set(ugd->on_off_check, FALSE); + } - ugd->genlist = _create_basic_genlist(ugd); - if(ugd->genlist == NULL) - { - DBG(LOG_ERROR, "Failed to create basic genlist"); - return; - } - elm_object_style_set (ugd->genlist, "dialogue"); - evas_object_show(ugd->genlist); - wfd_refresh_wifi_direct_state(ugd); - if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING) - ugd->wfd_onoff = TRUE; + __FUNC_EXIT__; +} - navi_item = elm_naviframe_item_push(ugd->naviframe, _("IDS_WFD_HEADER_WIFI_DIRECT"), back_btn, NULL, ugd->genlist, NULL); // dgettext("sys_string", "IDS_COM_OPT1_WI_FI_DIRECT") +void wfd_ug_create_on_off_check(struct ug_data *ugd) +{ + __FUNC_ENTER__; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + WFD_RET_IF(ugd->naviframe == NULL, "naviframe NULL\n"); + + Evas_Object *check = elm_check_add(ugd->naviframe); + elm_object_style_set(check, "naviframe/title_on&off"); + elm_check_state_set(check, ugd->wfd_onoff); + evas_object_propagate_events_set(check, EINA_FALSE); + evas_object_smart_callback_add(check, "changed", _onoff_changed_cb, ugd); + elm_object_focus_allow_set(check, EINA_TRUE); + elm_object_item_part_content_set(ugd->navi_item, "title_right_btn", check); + evas_object_show(check); + ugd->on_off_check = check; - control_bar = elm_toolbar_add(ugd->naviframe); - elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND); - evas_object_show(control_bar); + __FUNC_EXIT__; +} +#endif - ugd->scan_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_SCAN"), _scan_btn_cb, (void*) ugd); - item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL); - elm_object_item_disabled_set(item, EINA_TRUE); +/** + * This function let the ug create the main view + * @return void + * @param[in] data the pointer to the main data structure + */ +void create_wfd_ug_view(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + Evas_Object *more_btn; + Evas_Object *layout; + + ugd->naviframe = elm_naviframe_add(ugd->base); + elm_naviframe_prev_btn_auto_pushed_set(ugd->naviframe, EINA_FALSE); + ea_object_event_callback_add(ugd->naviframe, EA_CALLBACK_BACK, ea_naviframe_back_cb, NULL); + ea_object_event_callback_add(ugd->naviframe, EA_CALLBACK_MORE, ea_naviframe_more_cb, NULL); + elm_object_part_content_set(ugd->base, "elm.swallow.content", ugd->naviframe); + + ugd->back_btn = elm_button_add(ugd->naviframe); + elm_object_style_set(ugd->back_btn, "naviframe/back_btn/default"); +// evas_object_smart_callback_add(ugd->back_btn, "clicked", _back_btn_cb, (void *)ugd); + elm_object_focus_allow_set(ugd->back_btn, EINA_FALSE); + + /* Create layout */ + layout = elm_layout_add(ugd->naviframe); + elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "main_layout"); + ugd->layout = layout; + + ugd->genlist = _create_basic_genlist(ugd); + if (ugd->genlist == NULL) { + DBG(LOG_ERROR, "Failed to create basic genlist"); + return; + } + elm_object_part_content_set(layout, "elm.swallow.content", ugd->genlist); + + elm_genlist_fx_mode_set(ugd->genlist, EINA_FALSE); + evas_object_show(ugd->base); + elm_object_focus_set(ugd->base, EINA_TRUE); + + ugd->navi_item = elm_naviframe_item_push(ugd->naviframe, ugd->title, + ugd->back_btn, NULL, layout, NULL); + elm_naviframe_item_pop_cb_set(ugd->navi_item, _back_btn_cb, ugd); + + more_btn = elm_button_add(ugd->naviframe); + elm_object_style_set(more_btn, "naviframe/more/default"); + evas_object_smart_callback_add(more_btn, "clicked", + _more_button_cb, ugd->win); + elm_object_item_part_content_set(ugd->navi_item, "toolbar_more_btn", + more_btn); + + wifi_direct_initialize(); + wifi_direct_get_state(&ugd->wfd_status); + if (ugd->wfd_status > WIFI_DIRECT_STATE_DEACTIVATING) { + scan_button_create(ugd); + } - elm_object_item_disabled_set(ugd->scan_btn, !ugd->wfd_onoff); + if (ugd->view_type && g_strcmp0(_(ugd->view_type), _("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) { + int ret = 0; + ugd->raw_discovered_peer_cnt = 0; + wfd_create_multiconnect_view(ugd); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + return; + } - elm_object_item_part_content_set(navi_item, "controlbar", control_bar); + __FUNC_EXIT__; +} - __FUNC_EXIT__; +/** + * This function let the ug destroy the main view + * @return void + * @param[in] data the pointer to the main data structure + */ +void destroy_wfd_ug_view(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_IF_DEL_ITEM(ugd->device_name_item); + WFD_IF_DEL_ITEM(ugd->multi_connect_toolbar_item); + WFD_IF_DEL_ITEM(ugd->conn_wfd_item); + + WFD_IF_DEL_OBJ(ugd->scan_toolbar); + WFD_IF_DEL_OBJ(ugd->back_btn); + WFD_IF_DEL_OBJ(ugd->toolbar); + WFD_IF_DEL_OBJ(ugd->genlist); + WFD_IF_DEL_OBJ(ugd->naviframe); + __FUNC_EXIT__; } diff --git a/ug-wifidirect/src/wfd_ug_multiconnect_view.c b/ug-wifidirect/src/wfd_ug_multiconnect_view.c index aea5ce5..ef36a62 100755..100644 --- a/ug-wifidirect/src/wfd_ug_multiconnect_view.c +++ b/ug-wifidirect/src/wfd_ug_multiconnect_view.c @@ -18,8 +18,6 @@ */ #include <libintl.h> - -#include <assert.h> #include <glib.h> #include <Elementary.h> @@ -31,113 +29,203 @@ #include "wfd_ug_view.h" #include "wfd_client.h" -Elm_Gen_Item_Class select_all_itc; Elm_Gen_Item_Class device_itc; - -void _multiconnect_view_back_btn_cb(void *data, Evas_Object * obj, void *event_info) +/** + * This function let the ug call it when click 'back' button in multi connect view + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +Eina_Bool _multiconnect_view_pop_cb(void *data, Elm_Object_Item *it) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int ret = 0; + device_type_s *peer_for_free = NULL; + device_type_s *peer = NULL; + + if (!ugd) { + DBG(LOG_ERROR, "The param is NULL\n"); + return EINA_FALSE; + } - if(!ugd) - { - DBG(LOG_ERROR, "The param is NULL\n"); - return; - } + peer = ugd->multi_conn_dev_list_start; - ugd->multiconn_view_genlist = NULL; - elm_naviframe_item_pop(ugd->naviframe); + while (peer != NULL) { + DBG(LOG_INFO, "Free peer, ssid:%s\n", peer->ssid); + peer_for_free = peer; + peer = peer->next; + free(peer_for_free); + peer_for_free = NULL; + } - __FUNC_EXIT__; - return; -} + ugd->multi_conn_dev_list_start = NULL; + ugd->multiconn_view_genlist = NULL; + ugd->mcview_title_item = NULL; + ugd->mcview_nodevice_item = NULL; + ugd->multi_navi_item = NULL; + ugd->multiconn_conn_btn = NULL; + ugd->multiconn_layout = NULL; + ugd->multiconn_scan_stop_btn = NULL; + + DBG(LOG_INFO, "MultiConnectMode: %d\n", ugd->multi_connect_mode); + + /* if pressing connect for multi-connecting, it should not start discovery again */ + if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_NONE) { + if (ugd->view_type == NULL) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + DBG(LOG_INFO, "Discovery started\n"); + ret = wifi_direct_start_discovery_specific_channel(false, 1, + WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } else if (g_strcmp0(_(ugd->view_type), + _("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) { + DBG(LOG_INFO, "Discovery not started\n"); + ug_destroy_me(ugd->ug); + } + } -void reset_multi_conn_dev_list(void *data) -{ - struct ug_data *ugd = (struct ug_data*) data; - int i; - for (i = 0; i < MAX_PEER_NUM; i++) - { - ugd->multi_conn_dev_list[i].dev_sel_state = FALSE; - ugd->multi_conn_dev_list[i].peer.gl_item = NULL; - } - ugd->gl_available_dev_cnt_at_multiconn_view = 0; + __FUNC_EXIT__; + return EINA_TRUE; } +/** + * This function let the ug reset the connected failed peers + * @return false + * @param[in] event_info the pointer to the event information + */ gboolean __wfd_multi_connect_reset_cb(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; - ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; - ugd->raw_multi_selected_peer_cnt = 0; - wfd_ug_view_update_peers(ugd); + if (!data) { + DBG(LOG_ERROR, "The param is NULL\n"); + return false; + } + + device_type_s *peer = NULL; + struct ug_data *ugd = (struct ug_data *)data; + + peer = ugd->gl_mul_conn_peers_start; + while (peer != NULL) { + elm_object_item_del(peer->gl_item); + peer->gl_item = NULL; + peer = peer->next; + } + + WFD_IF_DEL_ITEM(ugd->multi_connect_wfd_item); + WFD_IF_DEL_ITEM(ugd->multi_connect_sep_item); + + wfd_ug_update_available_peers(ugd); __FUNC_EXIT__; return false; } +/** + * This function let the ug free the selected peers in multi connect view + * @return void + * @param[in] data the pointer to the main data structure + */ +void wfd_free_multi_selected_peers(void *data) +{ + __FUNC_ENTER__; + + int i = 0; + struct ug_data *ugd = (struct ug_data *)data; + + /* destroy the created group */ + wifi_direct_destroy_group(); + + /* release the selected peers */ + for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) { + memset(&ugd->raw_multi_selected_peers[i], 0x00, sizeof(device_type_s)); + } + + ugd->raw_multi_selected_peer_cnt = 0; + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE; + + __FUNC_EXIT__; + +} + +/** + * This function let the ug stop to connect to selected peer + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ int wfd_stop_multi_connect(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + + if (ugd->act_popup) { + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } - ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_COMPLETED; - wfd_client_set_p2p_group_owner_intent(7); + /* change the title of failed peers */ + ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_COMPLETED; + wfd_ug_view_refresh_glitem(ugd->multi_connect_wfd_item); + wfd_ug_update_toolbar(ugd); - g_timeout_add(1000 /*ms*/, __wfd_multi_connect_reset_cb, ugd); + if (ugd->gl_connected_peer_cnt > 0) { + wfd_client_set_p2p_group_owner_intent(7); + } else { + wifi_direct_destroy_group(); + } + + if(ugd->timer_multi_reset > 0) { + g_source_remove(ugd->timer_multi_reset); + } + /* after 30s, remove the failed peers */ + ugd->timer_multi_reset = g_timeout_add(30000 /*ms*/, + __wfd_multi_connect_reset_cb, ugd); + + if (ugd->g_source_multi_connect_next > 0) { + g_source_remove(ugd->g_source_multi_connect_next); + } + ugd->g_source_multi_connect_next = 0; + + /*when multi-connect end and auto_exit is true, exit UG*/ + if (ugd->is_auto_exit) { + _wfd_ug_auto_exit(ugd); + } - __FUNC_EXIT__; + __FUNC_EXIT__; return 0; } -int wfd_start_multi_connect(void* data) +/** + * This function let the ug start to connect the selected peers + * @return If success, return 0, else return -1 + * @param[in] data the pointer to the main data structure + */ +int wfd_start_multi_connect(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int i; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; int res; - if (ugd->raw_multi_selected_peer_cnt > 0) - { + if (ugd->raw_multi_selected_peer_cnt > 0) { ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS; - if (wfd_client_set_p2p_group_owner_intent(15) == WIFI_DIRECT_ERROR_NONE) - { - for (i=0;i<ugd->raw_multi_selected_peer_cnt; i++) - { - res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr); - if (res == -1) - { - DBG(LOG_VERBOSE, "Failed to connect [%s].\n", ugd->raw_multi_selected_peers[i].ssid); - ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; - } - else - { - ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING; - break; - } - } - if (i >= ugd->raw_multi_selected_peer_cnt) - { - wfd_client_set_p2p_group_owner_intent(7); + res = wfd_client_group_add(); + if (res == -1) { + DBG(LOG_ERROR, "Failed to add group"); + wfd_free_multi_selected_peers(ugd); - DBG(LOG_VERBOSE, "All connect trails are failed.\n"); - return -1; - } - } - else - { - // error popup... - DBG(LOG_VERBOSE, "Setting GO intent is failed.\n"); + __FUNC_EXIT__; return -1; } - - } - else - { - DBG(LOG_VERBOSE, "No selected peers.\n"); + } else { + DBG(LOG_INFO, "No selected peers.\n"); return -1; } @@ -145,551 +233,769 @@ int wfd_start_multi_connect(void* data) return 0; } -gboolean wfd_multi_connect_next_cb(void* data) +void wfd_sort_multi_selected_peers(struct ug_data *ugd) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + int i = 0; + int j = 0; + device_type_s peer; + + for(i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) { + for(j = 0; j < ugd->raw_multi_selected_peer_cnt-i-1; j++) { + if (strcasecmp(ugd->raw_multi_selected_peers[j].ssid, ugd->raw_multi_selected_peers[j + 1].ssid) > 0) { + peer = ugd->raw_multi_selected_peers[j]; + ugd->raw_multi_selected_peers[j] = ugd->raw_multi_selected_peers[j + 1]; + ugd->raw_multi_selected_peers[j + 1] = peer; + } + } + } + __FUNC_EXIT__; +} + +/** + * This function let the ug connect to the next selected peer automatically + * @return If stop the timer, return false, else return true + * @param[in] data the pointer to the main data structure + */ +gboolean wfd_multi_connect_next_cb(void *data) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; int i; int res; // Reset g_source handler.. + if (ugd->g_source_multi_connect_next > 0) { + g_source_remove(ugd->g_source_multi_connect_next); + } ugd->g_source_multi_connect_next = 0; - if (ugd->raw_multi_selected_peer_cnt > 0) - { + if (ugd->raw_multi_selected_peer_cnt > 0) { ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_IN_PROGRESS; - for (i=0;i<ugd->raw_multi_selected_peer_cnt; i++) - { - if (ugd->raw_multi_selected_peers[i].conn_status == PEER_CONN_STATUS_WAIT_FOR_CONNECT) - { + for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++) { + if (ugd->raw_multi_selected_peers[i].conn_status == PEER_CONN_STATUS_WAIT_FOR_CONNECT) { + ugd->mac_addr_connecting = ugd->raw_multi_selected_peers[i].mac_addr; res = wfd_client_connect(ugd->raw_multi_selected_peers[i].mac_addr); - if (res == -1) - { - DBG(LOG_VERBOSE, "Failed to connect [%s].\n", ugd->raw_multi_selected_peers[i].ssid); + if (res == -1) { ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_FAILED_TO_CONNECT; - } - else - { + } else { ugd->raw_multi_selected_peers[i].conn_status = PEER_CONN_STATUS_CONNECTING; break; } } } - if (i >= ugd->raw_multi_selected_peer_cnt) - { + if (i >= ugd->raw_multi_selected_peer_cnt) { // All selected peers are touched. - DBG(LOG_VERBOSE, "Stop Multi Connect...\n"); + DBG(LOG_INFO, "Stop Multi Connect...\n"); wfd_stop_multi_connect(ugd); } - } - else - { - DBG(LOG_VERBOSE, "No selected peers.\n"); - return -1; + } else { + DBG(LOG_INFO, "No selected peers.\n"); } __FUNC_EXIT__; return false; } - -void _connect_btn_cb(void *data, Evas_Object * obj, void *event_info) +/** + * This function let the ug call it when click 'connect' button in multi connect view + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _connect_btn_cb(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - int i = 0; - int count = 0; - char popup_text[MAX_POPUP_TEXT_SIZE] = {0}; - DBG(LOG_VERBOSE, "_connect_btn_cb \n"); - - for (i = 0; i < ugd->gl_available_peer_cnt ; i++) - { - if (TRUE == ugd->multi_conn_dev_list[i].dev_sel_state) - { - DBG(LOG_VERBOSE, "ugd->peers[i].mac_addr = %s, i = %d\n", ugd->multi_conn_dev_list[i].peer.mac_addr, i); - - memcpy(&ugd->raw_multi_selected_peers[count], &ugd->multi_conn_dev_list[i].peer,sizeof(device_type_s)); - ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int count = 0; + char popup_text[MAX_POPUP_TEXT_SIZE] = {0}; + device_type_s *peer = NULL; + + peer = ugd->multi_conn_dev_list_start; + while (peer != NULL) { + if(peer->dev_sel_state) { count++; - } - } - - ugd->raw_multi_selected_peer_cnt = count; + } + peer = peer->next; + } + DBG(LOG_INFO, "MultiSelected Peer Count: %d", count); - /* if more than 7 device selected, show the popup */ - if (count > MAX_POPUP_PEER_NUM) { - snprintf(popup_text, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_MULTI_CONNECT"), count); + /* if more than 7 device selected, show the popup */ + if (count > MAX_CONNECTED_PEER_NUM) { + 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); wfd_ug_warn_popup(ugd, popup_text, POP_TYPE_MULTI_CONNECT_POPUP); - } + __FUNC_EXIT__; + return; + } - if (wfd_start_multi_connect(ugd) != -1) - { - wfd_ug_view_update_peers(ugd); - } + peer = ugd->multi_conn_dev_list_start; + count = 0; + while (peer != NULL) { + if(peer->dev_sel_state) { + DBG(LOG_INFO, "peer_name[%s] select state[%d]", peer->ssid, peer->dev_sel_state); + memcpy(&ugd->raw_multi_selected_peers[count], peer, sizeof(device_type_s)); + ugd->raw_multi_selected_peers[count].conn_status = PEER_CONN_STATUS_WAIT_FOR_CONNECT; + count++; + } + peer = peer->next; + } - elm_naviframe_item_pop(ugd->naviframe); + DBG(LOG_INFO, "MultiSelected Peer Count2: %d", count); + ugd->raw_multi_selected_peer_cnt = count; + wfd_sort_multi_selected_peers(ugd); + wfd_cancel_progressbar_stop_timer(ugd); + wfd_cancel_not_alive_delete_timer(ugd); - //ToDo: Do we need to free multiconn_view_genlist? - ugd->multiconn_view_genlist = NULL; - _change_multi_button_title(ugd); + /* start multi connection */ + wfd_start_multi_connect(ugd); + + elm_naviframe_item_pop(ugd->naviframe); __FUNC_EXIT__; return; } +void wfd_naviframe_title_set(struct ug_data *ugd, const char *title) +{ + if (!ugd || !ugd->multi_navi_item) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } + elm_object_item_part_text_set(ugd->multi_navi_item, "default", title); +} +/** + * This function let the ug call it when click the peer in multi connect view + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ static void _wfd_gl_multi_sel_cb(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; - int i = 0; - int index = 0; int sel_count = 0; bool is_sel = FALSE; - bool is_selct_all = TRUE; - Eina_Bool state = 0; + + Eina_Bool state = EINA_FALSE; Evas_Object *chk_box = NULL; - char msg[MAX_POPUP_TEXT_SIZE] = {0}; - struct ug_data *ugd = (struct ug_data*) data; - Elm_Object_Item *item = (Elm_Object_Item *)event_info; + const char *object_type = NULL; + struct ug_data *ugd = (struct ug_data *)wfd_get_ug_data(); + device_type_s *peer = (device_type_s *)data; - if (NULL == ugd || NULL == item) { - DBG(LOG_ERROR, "The param is NULL\n"); - return; + if (NULL == ugd) { + DBG(LOG_ERROR, "ugd is NULL\n"); + return; } - elm_genlist_item_selected_set(item, EINA_FALSE); - index = elm_genlist_item_index_get(item) - 3; /* subtract the previous items */ - DBG(LOG_VERBOSE, "selected index = %d \n", index); - if (index < 0) { - DBG(LOG_ERROR, "The index is invalid.\n"); - return; + ugd->is_multi_check_all_selected = TRUE; + + if(event_info != NULL) { + Evas_Object *content = elm_object_item_part_content_get(event_info, "elm.icon.2"); + chk_box = elm_object_part_content_get(content, "elm.swallow.content"); + state = elm_check_state_get(chk_box); + DBG(LOG_INFO, "state = %d \n", state); + if (chk_box == NULL) { + DBG(LOG_INFO, "Check box is null\n"); + } } - chk_box = elm_object_item_part_content_get((Elm_Object_Item *)event_info, "elm.icon.1"); - state = elm_check_state_get(chk_box); - DBG(LOG_VERBOSE, "state = %d \n", state); - elm_check_state_set(chk_box, !state); + object_type = evas_object_type_get(obj); + if (g_strcmp0(object_type, "elm_genlist") == 0) { + Elm_Object_Item *item = (Elm_Object_Item *)event_info; + if (item) { + elm_genlist_item_selected_set(item, EINA_FALSE); + } + DBG(LOG_INFO, "State elm_genlist %d\n", state); + elm_check_state_set(chk_box, !state); + peer->dev_sel_state = !state; + } else if (g_strcmp0(object_type, "elm_check") == 0){ + DBG(LOG_INFO, "elm_check state; %d\n", peer->dev_sel_state); + peer->dev_sel_state = !peer->dev_sel_state; + } - ugd->multi_conn_dev_list[index].dev_sel_state = !state; - DBG(LOG_VERBOSE, "ptr->dev_sel_state = %d \n", ugd->multi_conn_dev_list[index].dev_sel_state); - DBG(LOG_VERBOSE, "ptr->peer.mac_addr = %s \n", ugd->multi_conn_dev_list[index].peer.mac_addr); + DBG(LOG_INFO, "ptr->dev_sel_state = %d \n", peer->dev_sel_state); + DBG_SECURE(LOG_INFO, "ptr->peer.mac_addr = ["MACSECSTR"]\n", + MAC2SECSTR(peer->mac_addr)); - /* update the checkbox and button */ - for (; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) { - if (ugd->multi_conn_dev_list[i].dev_sel_state) { + peer = ugd->multi_conn_dev_list_start; + while (peer != NULL) { + if(peer->dev_sel_state) { is_sel = TRUE; sel_count++; } else { - is_selct_all = FALSE; + ugd->is_multi_check_all_selected = FALSE; } + peer = peer->next; } - chk_box = elm_object_item_part_content_get(ugd->mcview_select_all_item, "elm.icon"); - elm_check_state_set(chk_box, is_selct_all); - - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel); + if (is_sel) { + char title[MAX_POPUP_TEXT_SIZE] = {0}; + snprintf(title, MAX_POPUP_TEXT_SIZE, _("IDS_ST_HEADER_PD_SELECTED"), sel_count); + wfd_naviframe_title_set(ugd, title); + } else { + wfd_naviframe_title_set(ugd, _("IDS_DLNA_HEADER_SELECT_DEVICES_ABB")); } - if (sel_count > 0) { - snprintf(msg, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_SELECTED_DEVICE_NUM"), sel_count); - wfd_ug_tickernoti_popup(msg); + state = elm_check_state_get(ugd->select_all_icon); + if (ugd->multiconn_layout) { + if (state != EINA_TRUE && ugd->is_multi_check_all_selected == TRUE) { + elm_check_state_set(ugd->select_all_icon, TRUE); + ugd->is_select_all_checked = TRUE; + } else if (ugd->is_multi_check_all_selected == FALSE) { + elm_check_state_set(ugd->select_all_icon, FALSE); + ugd->is_select_all_checked = FALSE; + } + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, + "IDS_WIFI_SK_CONNECT", is_sel); } __FUNC_EXIT__; } -static void _wfd_gl_sel_cb(void *data, Evas_Object *obj, void *event_info) +/** + * This function let the ug get the label of peer + * @return the label of peer + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static char *_wfd_gl_device_label_get(void *data, Evas_Object *obj, const char *part) { - int sel_count = 0; - char msg[MAX_POPUP_TEXT_SIZE] = {0}; - struct ug_data *ugd = (struct ug_data*) data; - - elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE); + __FUNC_ENTER__; + DBG(LOG_INFO, "part %s", part); + device_type_s *peer = (device_type_s *)data; + char *ssid; - if (NULL == ugd || NULL == obj) { - DBG(LOG_ERROR, "NULL parameters.\n"); - return; + if (NULL == peer) { + return NULL; } - Evas_Object *sel_chkbox = elm_object_item_part_content_get(ugd->mcview_select_all_item, "elm.icon"); - if (sel_chkbox==NULL) - { - DBG(LOG_VERBOSE, "select-all chkbox is NULL\n"); - return; + if (!g_strcmp0(part, "elm.text.main.left")) { + if (strlen(peer->ssid) != 0) { + ssid = elm_entry_utf8_to_markup(peer->ssid); + if (NULL == ssid) { + DBG(LOG_ERROR, "elm_entry_utf8_to_markup failed.\n"); + __FUNC_EXIT__; + return NULL; + } + __FUNC_EXIT__; + return ssid; + } } - Eina_Bool state = elm_check_state_get(sel_chkbox); + return NULL; +} - if (state==TRUE) - state = FALSE; - else - state = TRUE; - elm_check_state_set(sel_chkbox, state); +/** + * This function let the ug get the icon path of peer + * @return the icon path of titile + * @param[in] peer the pointer to the peer + */ +static char *__wfd_get_device_icon_path(device_type_s *peer) +{ + __FUNC_ENTER__; + char *img_name = NULL; + + switch (peer->category) { + case WFD_DEVICE_TYPE_COMPUTER: + img_name = WFD_ICON_DEVICE_COMPUTER; + break; + case WFD_DEVICE_TYPE_INPUT_DEVICE: + img_name = WFD_ICON_DEVICE_INPUT_DEVICE; + break; + case WFD_DEVICE_TYPE_PRINTER: + img_name = WFD_ICON_DEVICE_PRINTER; + break; + case WFD_DEVICE_TYPE_CAMERA: + img_name = WFD_ICON_DEVICE_CAMERA; + break; + case WFD_DEVICE_TYPE_STORAGE: + img_name = WFD_ICON_DEVICE_STORAGE; + break; + case WFD_DEVICE_TYPE_NW_INFRA: + img_name = WFD_ICON_DEVICE_NETWORK_INFRA; + break; + case WFD_DEVICE_TYPE_DISPLAYS: + img_name = WFD_ICON_DEVICE_DISPLAY; + break; + case WFD_DEVICE_TYPE_MM_DEVICES: + img_name = WFD_ICON_DEVICE_MULTIMEDIA; + break; + case WFD_DEVICE_TYPE_GAME_DEVICES: + img_name = WFD_ICON_DEVICE_GAMING; + break; + case WFD_DEVICE_TYPE_TELEPHONE: + img_name = WFD_ICON_DEVICE_TELEPHONE; + break; + case WFD_DEVICE_TYPE_AUDIO: + img_name = WFD_ICON_DEVICE_HEADSET; + break; + default: + img_name = WFD_ICON_DEVICE_UNKNOWN; + break; + } + return img_name; +} - DBG(LOG_VERBOSE, "state = %d \n", state); +/** + * This function let the ug get the icon of peer + * @return the icon of peer + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] part the pointer to the part of item + */ +static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; + char *img_name = NULL; + device_type_s *peer = (device_type_s *) data; + Evas_Object *icon = NULL; + Evas_Object *icon_layout = NULL; + + + DBG(LOG_INFO, "Part %s", part); + + if (!g_strcmp0(part, "elm.icon.2")) { + icon_layout = elm_layout_add(obj); + elm_layout_theme_set(icon_layout, "layout", "list/C/type.2", "default"); + DBG(LOG_INFO, "Part %s", part); + icon = elm_check_add(icon_layout); + elm_object_style_set(icon, "default/genlist"); + evas_object_propagate_events_set(icon, EINA_FALSE); + if (peer->dev_sel_state == EINA_TRUE) { + elm_check_state_set(icon, EINA_TRUE); + } + evas_object_smart_callback_add(icon, + "changed", _wfd_gl_multi_sel_cb, (void *)data); + elm_layout_content_set(icon_layout, "elm.swallow.content", icon); + }else if (!g_strcmp0(part, "elm.icon.1")) { + DBG(LOG_INFO, "Part %s", part); + icon_layout = elm_layout_add(obj); + elm_layout_theme_set(icon_layout, "layout", "list/B/type.3", "default"); + img_name = __wfd_get_device_icon_path(peer); + icon = elm_image_add(icon_layout); + elm_image_file_set(icon, WFD_UG_EDJ_PATH, img_name); + evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + ea_theme_object_color_set(icon, "AO001"); + evas_object_show(icon); + evas_object_propagate_events_set(icon, EINA_FALSE); + elm_layout_content_set(icon_layout, "elm.swallow.content", icon); + } + evas_object_show(icon_layout); + return icon_layout; +} - int i = 0; +/** + * This function let the ug call it when unresized event is received +*/ +static void _gl_unrealized(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + int sel_count = 0; bool is_sel = FALSE; - Elm_Object_Item *item = NULL; - Evas_Object *chk_box = NULL; + device_type_s *peer = NULL; - /* set the state of all the available devices */ - for (i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) { - is_sel = state; - ugd->multi_conn_dev_list[i].dev_sel_state = state; - item = ugd->multi_conn_dev_list[i].peer.gl_item; - chk_box = elm_object_item_part_content_get(item, "elm.icon.1"); - elm_check_state_set(chk_box, state); + if (!ugd->multiconn_conn_btn) { + DBG(LOG_INFO, "popup naviframe, no need to update UI\n"); + return; + } - if (state) { - sel_count++; + if (ugd->gl_available_dev_cnt_at_multiconn_view > 0) { + peer = ugd->multi_conn_dev_list_start; + while (peer != NULL) { + if(peer->dev_sel_state) { + is_sel = TRUE; + sel_count++; + } + peer = peer->next; } } - /* update the connect button */ - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel); + if (is_sel) { + char title[MAX_POPUP_TEXT_SIZE] = {0}; + snprintf(title, MAX_POPUP_TEXT_SIZE, _("IDS_ST_HEADER_PD_SELECTED"), sel_count); + wfd_naviframe_title_set(ugd, title); + } else { + wfd_naviframe_title_set(ugd, _("IDS_DLNA_HEADER_SELECT_DEVICES_ABB")); } - /* tickernoti popup */ - if (sel_count > 0) { - snprintf(msg, MAX_POPUP_TEXT_SIZE, _("IDS_WFD_POP_SELECTED_DEVICE_NUM"), sel_count); - wfd_ug_tickernoti_popup(msg); + if (ugd->multiconn_conn_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, + "IDS_WIFI_SK_CONNECT", is_sel); } - //elm_check_state_set(ugd->mcview_select_all_icon, EINA_FALSE); + __FUNC_EXIT__; } - -static char *_wfd_gl_device_label_get(void *data, Evas_Object *obj, const char *part) +/** + * This function let the ug free the multi connect devices + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int wfd_free_multiconnect_device(struct ug_data *ugd) { - DBG(LOG_VERBOSE, "part %s", part); - device_type_s *peer = (device_type_s*) data; + __FUNC_ENTER__; - if (NULL == peer) - return NULL; + if (ugd->multiconn_view_genlist == NULL) { + return 0; + } - if (!strcmp(part, "elm.text")) { - return strdup(peer->ssid); + ugd->gl_available_dev_cnt_at_multiconn_view = 0; + if (ugd->multi_conn_dev_list_start != NULL) { + wfd_ug_view_free_peer(ugd->multi_conn_dev_list_start); + ugd->multi_conn_dev_list_start = NULL; } - return NULL; -} + __FUNC_EXIT__; + return 0; +} -static char *__wfd_get_device_icon_path(device_type_s *peer) +/** + * This function let the ug create "no device found" item +*/ +Evas_Object *_create_no_device_multiconnect_genlist(struct ug_data *ugd) { - char *img_path = NULL; - - switch(peer->category) - { - case WFD_DEVICE_TYPE_COMPUTER: - img_path = WFD_ICON_DEVICE_COMPUTER; - break; - case WFD_DEVICE_TYPE_INPUT_DEVICE: - img_path = WFD_ICON_DEVICE_INPUT_DEVICE; - break; - case WFD_DEVICE_TYPE_PRINTER: - img_path = WFD_ICON_DEVICE_PRINTER; - break; - case WFD_DEVICE_TYPE_CAMERA: - img_path = WFD_ICON_DEVICE_CAMERA; - break; - case WFD_DEVICE_TYPE_STORAGE: - img_path = WFD_ICON_DEVICE_STORAGE; - break; - case WFD_DEVICE_TYPE_NW_INFRA: - img_path = WFD_ICON_DEVICE_NETWORK_INFRA; - break; - case WFD_DEVICE_TYPE_DISPLAYS: - img_path = WFD_ICON_DEVICE_DISPLAY; - break; - case WFD_DEVICE_TYPE_MM_DEVICES: - img_path = WFD_ICON_DEVICE_MULTIMEDIA_DEVICE; - break; - case WFD_DEVICE_TYPE_GAME_DEVICES: - img_path = WFD_ICON_DEVICE_GAMING_DEVICE; - break; - case WFD_DEVICE_TYPE_TELEPHONE: - img_path = WFD_ICON_DEVICE_TELEPHONE; - break; - case WFD_DEVICE_TYPE_AUDIO: - img_path = WFD_ICON_DEVICE_AUDIO_DEVICE; - break; - default: - img_path = WFD_ICON_DEVICE_COMPUTER; - break; - } - - return img_path; -} + __FUNC_ENTER__; + if (NULL == ugd) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return NULL; + } + if (!ugd->mcview_nodevice_item) { + ugd->mcview_nodevice_item = elm_genlist_item_append(ugd->multiconn_view_genlist, &noitem_itc, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->mcview_nodevice_item != NULL) + elm_genlist_item_select_mode_set(ugd->mcview_nodevice_item , ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + } -static void _wfd_check_clicked_cb(void *data, Evas_Object *obj, void *event_info) + __FUNC_EXIT__; + return ugd->multiconn_view_genlist; +} + +/** + * This function let the ug update the multi connect devices + * @return 0 + * @param[in] data the pointer to the main data structure + */ +int wfd_update_multiconnect_device(struct ug_data *ugd, bool is_free_all_peers) { - struct ug_data *ugd = (struct ug_data*) data; - if (NULL == ugd || NULL == obj) { - DBG(LOG_ERROR, "NULL parameters.\n"); - return; - } + __FUNC_ENTER__; - int i = 0; - bool is_sel = FALSE; + int count = 0; + device_type_s *device = NULL; + Evas_Object *genlist = NULL; Elm_Object_Item *item = NULL; - Evas_Object *chk_box = NULL; - Eina_Bool state = elm_check_state_get(obj); - elm_check_state_set(obj, !state); + int res = 0; - DBG(LOG_VERBOSE, "state = %d \n", state); - -#if 0 - /* set the state of all the available devices */ - for (i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) { - is_sel = state; - ugd->multi_conn_dev_list[i].dev_sel_state = state; - item = ugd->multi_conn_dev_list[i].peer.gl_item; - chk_box = elm_object_item_part_content_get(item, "elm.icon.1"); - elm_check_state_set(chk_box, state); + genlist = ugd->multiconn_view_genlist; + if (ugd->multiconn_view_genlist == NULL) { + return 0; } - /* update the connect button */ - wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), is_sel); -#endif -} + if (is_free_all_peers) { + wfd_free_multiconnect_device(ugd); + } + GList *iterator = NULL; + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + device = (device_type_s *)iterator->data; + if (device->is_connected == FALSE && device->is_group_owner == FALSE) { + count++; + } + } -static Evas_Object *_wfd_gl_device_icon_get(void *data, Evas_Object *obj, const char *part) -{ - char *img_path = NULL; - device_type_s *peer = (device_type_s*) data; - Evas_Object* icon = NULL; - - DBG(LOG_VERBOSE, "Part %s", part); - - if (!strcmp(part, "elm.icon.1")) { - DBG(LOG_VERBOSE, "Part %s", part); - icon = elm_check_add(obj); - elm_check_state_set(icon, EINA_FALSE); - evas_object_smart_callback_add(icon, "changed", _wfd_check_clicked_cb, (void *)data); - } else if (!strcmp(part, "elm.icon.2")) { - img_path = __wfd_get_device_icon_path(peer); - icon = elm_icon_add(obj); - elm_icon_file_set(icon, img_path, NULL); - evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1); - elm_icon_resizable_set(icon, 1, 1); - evas_object_show(icon); + if (count == 0) { + DBG(LOG_INFO, "There are No peers\n"); + if (!ugd->mcview_title_item) { + ugd->mcview_title_item = elm_genlist_item_append(genlist, &multi_view_title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(ugd->mcview_title_item != NULL) + elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + } else { + wfd_ug_view_refresh_glitem(ugd->mcview_title_item); + } + elm_check_state_set(ugd->select_all_icon, EINA_FALSE); + ugd->is_select_all_checked = FALSE; + wfd_free_multiconnect_device(ugd); + wfd_naviframe_title_set(ugd, _("IDS_DLNA_HEADER_SELECT_DEVICES_ABB")); + } else { + WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item); + wfd_ug_view_refresh_glitem(ugd->mcview_title_item); + + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + device = (device_type_s *)iterator->data; + if (device->is_connected == FALSE && device->is_group_owner == FALSE) { + if (!find_peer_in_glist(ugd->multi_conn_dev_list_start, device->mac_addr)) { + item = get_insert_postion(device, ugd->mcview_title_item, ugd->gl_available_dev_cnt_at_multiconn_view); + res = insert_gl_item(genlist, item, &device_itc, &ugd->multi_conn_dev_list_start, + device, _wfd_gl_multi_sel_cb); + if (res != 0) { + break; + } + elm_check_state_set(ugd->select_all_icon, EINA_FALSE); + ugd->is_select_all_checked = FALSE; + + ugd->gl_available_dev_cnt_at_multiconn_view++; + } + } + } } + ugd->is_multi_check_all_selected = FALSE; - return icon; + __FUNC_EXIT__; + return 0; } - -static char *_wfd_gl_select_all_label_get(void *data, Evas_Object *obj, const char *part) +void wfd_genlist_select_all_check_changed_cb(void *data, Evas_Object * obj, void *event_info) { - if (!strcmp(part, "elm.text")) { - DBG(LOG_VERBOSE, "Adding text %s", part); - return strdup("Select all"); + __FUNC_ENTER__; + Elm_Object_Item *item = NULL; + Evas_Object *chk_box = NULL; + Evas_Object *content = NULL; + const char *object_type; + Eina_Bool state; + + + struct ug_data *ugd = (struct ug_data *)data; + if (NULL == ugd || NULL == obj) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return; } - return NULL; -} -static Evas_Object *_wfd_gl_select_all_icon_get(void *data, Evas_Object *obj, const char *part) -{ - struct ug_data *ugd = (struct ug_data*) data; - Evas_Object* icon = NULL; + if (ugd->multi_conn_dev_list_start == NULL) { + elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE); + elm_check_state_set(ugd->select_all_icon, EINA_FALSE); + ugd->is_select_all_checked = FALSE; - if (!strcmp(part, "elm.icon")) { - DBG(LOG_VERBOSE, "Part %s", part); - icon = elm_check_add(obj); - elm_check_state_set(icon, EINA_FALSE); - evas_object_smart_callback_add(icon, "changed", _wfd_check_clicked_cb, (void *)data); + DBG(LOG_INFO, "No devices in multi-connect view.\n"); + return; } - return icon; -} + device_type_s *peer = ugd->multi_conn_dev_list_start; + elm_genlist_item_selected_set(ugd->select_all_view_genlist, EINA_FALSE); + object_type = evas_object_type_get(obj); + if (g_strcmp0(object_type, "elm_genlist") == 0) { + state = elm_check_state_get(ugd->select_all_icon); + elm_check_state_set(ugd->select_all_icon, !state); + ugd->is_select_all_checked = !state; + } + state = elm_check_state_get(ugd->select_all_icon); + DBG(LOG_INFO, "state = %d",state); + if (state == EINA_TRUE) { + if (ugd->is_multi_check_all_selected == FALSE) { + int sel_count = 0; + while (peer != NULL) { + peer->dev_sel_state = TRUE; + item = peer->gl_item; + content = elm_object_item_part_content_get(item, "elm.icon.2"); + chk_box = elm_object_part_content_get(content, "elm.swallow.content"); + elm_check_state_set(chk_box, TRUE); + sel_count++; + peer = peer->next; + } + ugd->is_multi_check_all_selected = TRUE; -int _wfd_free_multiconnect_device(struct ug_data *ugd) -{ - __FUNC_ENTER__; - - int count = 0; - int i = 0; - - if (ugd->multiconn_view_genlist == NULL) - { - return 0; - } - - if (ugd->mcview_title_item != NULL) - { - elm_object_item_del(ugd->mcview_title_item); - ugd->mcview_title_item = NULL; - } - - if (ugd->mcview_select_all_item != NULL) - { - elm_object_item_del(ugd->mcview_select_all_item); - ugd->mcview_select_all_item = NULL; - } - - if (ugd->mcview_nodevice_item != NULL) - { - elm_object_item_del(ugd->mcview_nodevice_item); - ugd->mcview_nodevice_item = NULL; - } - - for(i = 0; i < ugd->gl_available_dev_cnt_at_multiconn_view; i++) - { - if (ugd->multi_conn_dev_list[i].peer.gl_item != NULL) - { - elm_object_item_del(ugd->multi_conn_dev_list[i].peer.gl_item); - ugd->multi_conn_dev_list[i].peer.gl_item = NULL; - } - } - ugd->gl_available_dev_cnt_at_multiconn_view = 0; - - __FUNC_EXIT__; - return 0; -} + char title[MAX_POPUP_TEXT_SIZE] = {0}; + snprintf(title, MAX_POPUP_TEXT_SIZE, + _("IDS_ST_HEADER_PD_SELECTED"), sel_count); + wfd_naviframe_title_set(ugd, title); -int _wfd_update_multiconnect_device(struct ug_data *ugd) -{ - __FUNC_ENTER__; - - int count = 0; - device_type_s *device = NULL; - Evas_Object *genlist = NULL; - int i = 0; - - genlist = ugd->multiconn_view_genlist; - if (ugd->multiconn_view_genlist == NULL) - { - return 0; - } - - _wfd_free_multiconnect_device(ugd); - - count = 0; - for(i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - device = &ugd->raw_discovered_peers[i]; - if (device->is_connected == FALSE) - { - count++; - } - } - ugd->gl_available_dev_cnt_at_multiconn_view = count; - - if (ugd->gl_available_dev_cnt_at_multiconn_view == 0) - { - DBG(LOG_ERROR, "There are No peers\n"); - ugd->mcview_title_item = elm_genlist_item_append(genlist, &title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - ugd->mcview_nodevice_item = elm_genlist_item_append(genlist, &noitem_itc, (void*)ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(ugd->mcview_nodevice_item , ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - } - else - { - ugd->mcview_title_item = elm_genlist_item_append(genlist, &title_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); - elm_genlist_item_select_mode_set(ugd->mcview_title_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); - ugd->mcview_select_all_item = elm_genlist_item_append(genlist, &select_all_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _wfd_gl_sel_cb, ugd); - - count = 0; - for(i = 0; i < ugd->raw_discovered_peer_cnt; i++) - { - device = &ugd->raw_discovered_peers[i]; - if (device->is_connected == FALSE) - { - DBG(LOG_VERBOSE, "%dth peer being added on genlist\n", i); - - if (ugd->multi_conn_dev_list[count].peer.gl_item != NULL) - elm_object_item_del(ugd->multi_conn_dev_list[count].peer.gl_item); - ugd->multi_conn_dev_list[count].peer.gl_item = NULL; - - memcpy(&ugd->multi_conn_dev_list[count].peer, device, sizeof(device_type_s)); - - ugd->multi_conn_dev_list[count].dev_sel_state = FALSE; - ugd->multi_conn_dev_list[count].peer.gl_item = - elm_genlist_item_append(genlist, &device_itc, (void*) &ugd->multi_conn_dev_list[count].peer, - NULL, ELM_GENLIST_ITEM_NONE, _wfd_gl_multi_sel_cb, ugd); - count++; + if (ugd->multiconn_layout) { + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, + "IDS_WIFI_SK_CONNECT", TRUE); } } - } + } else { + while (peer != NULL) { + peer->dev_sel_state = FALSE; + item = peer->gl_item; + content = elm_object_item_part_content_get(item, "elm.icon.2"); + chk_box = elm_object_part_content_get(content, "elm.swallow.content"); + elm_check_state_set(chk_box, FALSE); + peer = peer->next; + } + ugd->is_multi_check_all_selected = FALSE; + wfd_naviframe_title_set(ugd, + _("IDS_DLNA_HEADER_SELECT_DEVICES_ABB")); - __FUNC_EXIT__; - return 0; + if (ugd->multiconn_layout) { + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, + "IDS_WIFI_SK_CONNECT", FALSE); + } + } } -void _wifid_create_multiconnect_view(struct ug_data *ugd) +/** + * This function let the ug call it when click 'scan' button + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _multi_scan_btn_cb(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; + int ret = -1; + const char *btn_text = NULL; + device_type_s *peer = NULL; + struct ug_data *ugd = (struct ug_data *) data; - Evas_Object *back_btn = NULL; - Evas_Object *control_bar = NULL; - Evas_Object *genlist = NULL; - - Elm_Object_Item *navi_item = NULL; - Elm_Object_Item *item = NULL; - - if(ugd == NULL) - { - DBG(LOG_ERROR, "Incorrect parameter(NULL)"); - return; - } - - select_all_itc.item_style = "1text.1icon.3"; - select_all_itc.func.text_get = _wfd_gl_select_all_label_get; - select_all_itc.func.content_get = _wfd_gl_select_all_icon_get; - select_all_itc.func.state_get = NULL; - select_all_itc.func.del = NULL; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } - device_itc.item_style = "1text.2icon.2"; - device_itc.func.text_get = _wfd_gl_device_label_get; - device_itc.func.content_get = _wfd_gl_device_icon_get; - device_itc.func.state_get = NULL; - device_itc.func.del = NULL; + if (ugd->multiconn_conn_btn) { + peer = ugd->multi_conn_dev_list_start; + while (peer) { + if(peer->dev_sel_state) { + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", TRUE); + break; + } + peer = peer->next; + } + if (!peer) { + wfd_ug_view_refresh_button(ugd->multiconn_conn_btn, "IDS_WIFI_SK_CONNECT", FALSE); + } + } - DBG(LOG_VERBOSE, "_wifid_create_multiconnect_view"); - back_btn = elm_button_add(ugd->naviframe); - elm_object_style_set(back_btn, "naviframe/back_btn/default"); - evas_object_smart_callback_add(back_btn, "clicked", _multiconnect_view_back_btn_cb, (void*) ugd); - elm_object_focus_allow_set(back_btn, EINA_FALSE); + btn_text = elm_object_text_get(ugd->multiconn_scan_stop_btn); + if (NULL == btn_text) { + DBG(LOG_ERROR, "Incorrect button text(NULL)\n"); + return; + } - genlist = elm_genlist_add(ugd->naviframe); - ugd->multiconn_view_genlist = genlist; - elm_object_style_set(ugd->multiconn_view_genlist, "dialogue"); + if (0 == strcmp(btn_text, _("IDS_WIFI_SK4_SCAN"))) { + wfd_refresh_wifi_direct_state(ugd); + DBG(LOG_INFO, "Start discovery again, status: %d\n", ugd->wfd_status); + + /* if connected, show the popup*/ + if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) { + wfd_ug_act_popup(ugd, _("IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"), POP_TYPE_SCAN_AGAIN); + } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) { + wfd_client_switch_on(ugd); + __FUNC_EXIT__; + return; + } else { + WFD_IF_DEL_ITEM(ugd->mcview_nodevice_item); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL); + if (ret != WIFI_DIRECT_ERROR_NONE) { + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE; + DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret); + wifi_direct_cancel_discovery(); + } + } + elm_object_domain_translatable_text_set(ugd->multiconn_scan_stop_btn, + PACKAGE, "IDS_WIFI_SK_STOP"); + } else if (0 == strcmp(btn_text, _("IDS_WIFI_SK_STOP"))) { + DBG(LOG_INFO, "Stop pressed.\n"); + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED; + wfd_cancel_progressbar_stop_timer(ugd); + wfd_delete_progressbar_cb(ugd); + wfd_cancel_not_alive_delete_timer(ugd); + } - ugd->mcview_title_item = NULL; + __FUNC_EXIT__; + return; +} - _wfd_update_multiconnect_device(ugd); +/** + * This function let the ug create the view for multi connection + * @return void + * @param[in] ugd the pointer to the main data structure + */ +void wfd_create_multiconnect_view(struct ug_data *ugd) +{ + __FUNC_ENTER__; - evas_object_show(genlist); + Evas_Object *genlist = NULL; + Elm_Object_Item *navi_item = NULL; + Evas_Object *btn1 = NULL; + Evas_Object *btn2 = NULL; + Evas_Object *layout = NULL; - navi_item = elm_naviframe_item_push(ugd->naviframe, _("Multi connect"), back_btn, NULL, genlist, NULL); + if (ugd == NULL) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)"); + return; + } - control_bar = elm_toolbar_add(ugd->naviframe); - elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND); - evas_object_show(control_bar); + device_itc.item_style = "1line"; + device_itc.func.text_get = _wfd_gl_device_label_get; + device_itc.func.content_get = _wfd_gl_device_icon_get; + device_itc.func.state_get = NULL; + device_itc.func.del = NULL; + + /* Create layout */ + layout = elm_layout_add(ugd->naviframe); + elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "main_layout"); + ugd->multiconn_layout = layout; + + + genlist = elm_genlist_add(ugd->multiconn_layout); + elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS); + evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_smart_callback_add(genlist, "unrealized", _gl_unrealized, ugd); + + elm_object_part_content_set(layout, "elm.swallow.content", genlist); + elm_genlist_fx_mode_set(genlist, EINA_FALSE); + elm_genlist_homogeneous_set(genlist, EINA_TRUE); + elm_genlist_realization_mode_set(genlist, TRUE); + + + ugd->multiconn_view_genlist = genlist; + ugd->mcview_title_item = NULL; + ugd->mcview_nodevice_item = NULL; + ugd->gl_available_dev_cnt_at_multiconn_view = 0; + evas_object_show(genlist); + + navi_item = elm_naviframe_item_push(ugd->naviframe, + "IDS_DLNA_HEADER_SELECT_DEVICES_ABB", NULL, NULL, layout, NULL); + elm_object_item_domain_text_translatable_set(navi_item, PACKAGE, EINA_TRUE); + + elm_naviframe_item_pop_cb_set(navi_item, _multiconnect_view_pop_cb, (void *)ugd); + ugd->select_all_view_genlist = elm_genlist_item_append(genlist, + &select_all_multi_connect_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, + wfd_genlist_select_all_check_changed_cb, (void *)ugd ); + + + btn1 = elm_button_add(ugd->multiconn_layout); + elm_object_style_set(btn1, "bottom"); + if (ugd->view_type && g_strcmp0(_(ugd->view_type), + _("IDS_WIFI_BUTTON_MULTI_CONNECT")) == 0) { + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_WIFI_SK4_SCAN"); + } else { + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_WIFI_SK_STOP"); + } + elm_object_part_content_set(ugd->multiconn_layout, "button.prev", btn1); + evas_object_smart_callback_add(btn1, "clicked",_multi_scan_btn_cb, (void *)ugd); + evas_object_show(btn1); + ugd->multiconn_scan_stop_btn = btn1; - ugd->multi_scan_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_SCAN"), _scan_btn_cb, (void*) ugd); - item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL); - elm_object_item_disabled_set(item, EINA_TRUE); - ugd->multi_connect_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_CONNECT"), _connect_btn_cb, (void*) ugd); + btn2 = elm_button_add(ugd->multiconn_layout); + elm_object_style_set(btn2, "bottom"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_WIFI_SK_CONNECT"); + elm_object_part_content_set(ugd->multiconn_layout, "button.next", btn2); + evas_object_smart_callback_add(btn2, "clicked",_connect_btn_cb, (void *)ugd); + evas_object_show(btn2); + ugd->multiconn_conn_btn = btn2; + elm_object_disabled_set(ugd->multiconn_conn_btn, EINA_TRUE); - if (ugd->multi_connect_btn) { - wfd_ug_view_refresh_button(ugd->multi_connect_btn, _("IDS_WFD_BUTTON_CONNECT"), FALSE); - } + ugd->multi_navi_item = navi_item; - item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL); - elm_object_item_disabled_set(item, EINA_TRUE); - elm_object_item_part_content_set(navi_item, "controlbar", control_bar); + wfd_update_multiconnect_device(ugd, true); - __FUNC_EXIT__; + __FUNC_EXIT__; } diff --git a/ug-wifidirect/src/wfd_ug_popup.c b/ug-wifidirect/src/wfd_ug_popup.c index 254a4e9..83f038d 100755 --- a/ug-wifidirect/src/wfd_ug_popup.c +++ b/ug-wifidirect/src/wfd_ug_popup.c @@ -18,121 +18,381 @@ */ #include <libintl.h> - -#include <assert.h> #include <glib.h> #include <Elementary.h> #include <vconf.h> #include <ui-gadget-module.h> #include <wifi-direct.h> +#include "utilX.h" #include "wfd_ug.h" #include "wfd_ug_view.h" #include "wfd_client.h" -static void _wfd_ug_act_popup_wifi_ok_cb(void *data, Evas_Object *obj, void *event_info) +static void delete_popup(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - // TODO: Turn off WiFi - ugd->wfd_status = WFD_LINK_STATUS_DEACTIVATED; - wfd_wifi_off(ugd); + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } - evas_object_del(ugd->act_popup); - ugd->act_popup = NULL; - __FUNC_EXIT__; + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + __FUNC_EXIT__; } -static void _wfd_ug_act_popup_wifi_cancel_cb(void *data, Evas_Object *obj, void *event_info) +static void pushbutton_accept_connect_cb(void *data, Evas_Object * obj, + void *event_info) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; - // TODO: set genlist head item as "WiFi Direct" - ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; - wfd_ug_view_refresh_glitem(ugd->head); + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } + int result = -1; + result = wifi_direct_accept_connection(ugd->mac_addr_req); + if (result != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_INFO,"Failed to connect"); + } + delete_popup(ugd); - evas_object_del(ugd->act_popup); - ugd->act_popup = NULL; - __FUNC_EXIT__; + __FUNC_EXIT__; } -static void _wfd_ug_act_popup_disconnect_ok_cb(void *data, Evas_Object *obj, void *event_info) +static void pushbutton_reject_connect_cb(void *data, Evas_Object * obj, + void *event_info) { __FUNC_ENTER__; - char *mac_addr = NULL; - struct ug_data *ugd = (struct ug_data*) data; - + struct ug_data *ugd = (struct ug_data *) data; if (NULL == ugd) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return; } + int result = -1; + if (ugd->mac_addr_req[0] != '\0') { + result = wifi_direct_reject_connection(ugd->mac_addr_req); + if (result != WIFI_DIRECT_ERROR_NONE) + DBG(LOG_INFO,"Failed to reject connection"); + } else { + DBG(LOG_INFO,"No Peer mac address"); + } + delete_popup(ugd); + + __FUNC_EXIT__; +} +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE +static void _mouseup_wifi_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Mouse_Up *ev = event_info; + if (ev->button == 3) { + struct ug_data *ugd = (struct ug_data *) data; + + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } +} + +static void _keydown_wifi_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Key_Down *ev = event_info; + if (!strcmp(ev->keyname, KEY_BACK)) { + struct ug_data *ugd = (struct ug_data *) data; + + ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; + wfd_ug_view_refresh_glitem(ugd->head); - if (ugd->gl_connected_peer_cnt < 1) { - DBG(LOG_ERROR, "No connected peer\n"); evas_object_del(ugd->act_popup); ugd->act_popup = NULL; - return; } +} +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + +static void _mouseup_hotspot_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Mouse_Up *ev = event_info; + if (ev->button == 3) { + struct ug_data *ugd = (struct ug_data *) data; - /* just one peer */ - mac_addr = ugd->gl_connected_peers[0].mac_addr; - wfd_client_disconnect(mac_addr); - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { - wfd_stop_multi_connect(ugd); +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); +#endif + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } +} +static void _keydown_hotspot_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Key_Down *ev = event_info; + if (!strcmp(ev->keyname, KEY_BACK)) { + struct ug_data *ugd = (struct ug_data *) data; + + ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT; + wfd_ug_view_refresh_glitem(ugd->head); + + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } +} + +static void _mouseup_disconnect_all_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Mouse_Up *ev = event_info; + if (ev->button == 3) { + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } + + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } +} + +/*static void _keydown_disconnect_all_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Key_Down *ev = event_info; + if (!strcmp(ev->keyname, KEY_BACK)) { + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; + } + + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } +}*/ + + +/** + * This function let the ug call it when click 'ok' button in hotspot action popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_hotspot_ok_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + int result = -1; + struct ug_data *ugd = (struct ug_data *) data; + + result = wfd_mobile_ap_off(ugd); + if (0 == result) { +#ifdef WFD_ON_OFF_GENLIST + /* refresh the header */ + if (ugd->on_off_check) { + elm_check_state_set(ugd->on_off_check, TRUE); + elm_object_disabled_set(ugd->on_off_check, TRUE); + } +#endif + + /* while activating/deactivating, disable the buttons */ + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->back_btn) { + elm_object_disabled_set(ugd->back_btn, TRUE); + } + ugd->is_hotspot_locally_disabled = TRUE; } evas_object_del(ugd->act_popup); ugd->act_popup = NULL; - __FUNC_EXIT__; } -static void _wfd_ug_act_popup_disconnect_cancel_cb(void *data, Evas_Object *obj, void *event_info) +/** + * This function let the ug call it when click 'cancel' button in hotspot action popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_hotspot_cancel_cb(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; - struct ug_data *ugd = (struct ug_data*) data; - if (NULL == ugd) { - DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); +#endif + + wfd_client_destroy_tethering(ugd); + + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + __FUNC_EXIT__; +} + +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE +/** + * This function let the ug call it when click 'ok' button in wifi action popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_wifi_ok_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + int result = -1; + struct ug_data *ugd = (struct ug_data *) data; + + result = wfd_wifi_off(ugd); + if (0 == result) { +#ifdef WFD_ON_OFF_GENLIST + /* refresh the header */ + if (ugd->on_off_check) { + elm_check_state_set(ugd->on_off_check, TRUE); + elm_object_disabled_set(ugd->on_off_check, TRUE); + } +#endif + /* while activating/deactivating, disable the buttons */ + if (ugd->scan_toolbar) { + wfd_ug_view_refresh_button(ugd->scan_toolbar, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->multiconn_scan_stop_btn) { + wfd_ug_view_refresh_button(ugd->multiconn_scan_stop_btn, "IDS_WIFI_SK4_SCAN", FALSE); + } + + if (ugd->back_btn) { + elm_object_disabled_set(ugd->back_btn, TRUE); + } } evas_object_del(ugd->act_popup); ugd->act_popup = NULL; + __FUNC_EXIT__; +} +/** + * This function let the ug call it when click 'cancel' button in wifi action popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_wifi_cancel_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_refresh_on_off_check(ugd); +#endif + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; __FUNC_EXIT__; } -static void _wfd_ug_act_popup_disconnect_all_ok_cb(void *data, Evas_Object *obj, void *event_info) +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + +gboolean _wfd_disconnect_idle_cb(gpointer user_data) { __FUNC_ENTER__; + GList *iterator = NULL; - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) user_data; if (NULL == ugd) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); - return; + return FALSE; } + Evas_Object *content; + content = elm_object_part_content_unset(ugd->layout, "button.next"); + WFD_IF_DEL_OBJ(content); + + wfd_ug_view_init_genlist(ugd, true); - wfd_client_disconnect(NULL); - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { - wfd_stop_multi_connect(ugd); + if (0 != wfd_client_disconnect(NULL)) { + DBG(LOG_ERROR, "Disconnection Failed !!!\n"); } - evas_object_del(ugd->act_popup); - ugd->act_popup = NULL; + ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START; + discover_cb(WIFI_DIRECT_ERROR_NONE, WIFI_DIRECT_DISCOVERY_STARTED, ugd); + + if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE) { + wfd_free_multi_selected_peers(ugd); + } else { + /* update the connecting icon */ + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + ((device_type_s *)iterator->data)->conn_status = PEER_CONN_STATUS_DISCONNECTED; + wfd_ug_view_refresh_glitem(((device_type_s *)iterator->data)->gl_item); + } + } __FUNC_EXIT__; + return FALSE; } -static void _wfd_ug_act_popup_disconnect_all_cancel_cb(void *data, Evas_Object *obj, void *event_info) +gboolean _wfd_cancel_connect_idle_cb(gpointer user_data) { __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + int res; + GList *iterator = NULL; + struct ug_data *ugd = (struct ug_data *) user_data; + if (NULL == ugd || NULL == ugd->mac_addr_connecting) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return FALSE; + } + + res = wifi_direct_cancel_connection(ugd->mac_addr_connecting); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed wifi_direct_cancel_connection() [%d]\n", res); + return FALSE; + } + + ugd->mac_addr_connecting = NULL; + if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE) { + if (ugd->raw_connected_peer_cnt > 0) { + res = wifi_direct_disconnect_all(); + if (res != WIFI_DIRECT_ERROR_NONE) { + DBG(LOG_ERROR, "Failed wifi_direct_disconnect_all() [%d]\n", res); + return FALSE; + } + } + + wfd_free_multi_selected_peers(ugd); + wfd_ug_view_init_genlist(ugd, true); + } else { + /* update the connecting icon */ + for (iterator = ugd->raw_discovered_peer_list; iterator; iterator = iterator->next) { + ((device_type_s *)iterator->data)->conn_status = PEER_CONN_STATUS_DISCONNECTED; + } + wfd_ug_view_init_genlist(ugd, false); + } + + __FUNC_EXIT__; + return FALSE; +} + +/** + * This function let the ug call it when click 'ok' button in cancel connection popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_cancel_connect_ok_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; if (NULL == ugd) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return; @@ -141,92 +401,232 @@ static void _wfd_ug_act_popup_disconnect_all_cancel_cb(void *data, Evas_Object * evas_object_del(ugd->act_popup); ugd->act_popup = NULL; + g_idle_add(_wfd_cancel_connect_idle_cb, ugd); + __FUNC_EXIT__; } -static void _wfd_ug_act_popup_scan_again_ok_cb(void *data, Evas_Object *obj, void *event_info) +/** + * This function let the ug call it when click 'ok' button in disconnect all popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_disconnect_all_ok_cb(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) data; if (NULL == ugd) { DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); return; } - if (ugd->conn_wfd_item != NULL) { - elm_object_item_del(ugd->conn_wfd_item); - ugd->conn_wfd_item = NULL; - } + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; - /* cancel the current connection */ - wfd_client_disconnect(NULL); - if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS) { - wfd_stop_multi_connect(ugd); + g_idle_add(_wfd_disconnect_idle_cb, ugd); + + __FUNC_EXIT__; +} + +/** + * This function let the ug call it when click 'cancel' button in disconnect all popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_act_popup_cancel_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + + struct ug_data *ugd = (struct ug_data *) data; + if (NULL == ugd) { + DBG(LOG_ERROR, "Incorrect parameter(NULL)\n"); + return; } - /* start discovery again */ - wfd_client_start_discovery(ugd); evas_object_del(ugd->act_popup); ugd->act_popup = NULL; __FUNC_EXIT__; } -static void _wfd_ug_act_popup_scan_again_cancel_cb(void *data, Evas_Object *obj, void *event_info) +void act_popup_language_changed(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + int popup_type = (int)data; + Evas_Object *btn1 = NULL; + Evas_Object *btn2 = NULL; + struct ug_data *ugd = wfd_get_ug_data(); - evas_object_del(ugd->act_popup); - ugd->act_popup = NULL; + if (!ugd || !ugd->act_popup) { + DBG(LOG_ERROR, "NULL parameters.\n"); + return; + } + + btn1 = elm_object_part_content_get(ugd->act_popup, "button1"); + btn2 = elm_object_part_content_get(ugd->act_popup, "button2"); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_BR_SK_OK"); + + switch(popup_type) { + + case POPUP_TYPE_HOTSPOT_OFF: + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_NO"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_BR_SK_YES"); + elm_object_domain_translatable_text_set(ugd->act_popup, PACKAGE, + "IDS_WIFI_BODY_USING_WI_FI_DIRECT_WILL_DISCONNECT_CURRENT_WI_FI_TETHERING_CONTINUE_Q"); + break; + + case POP_TYPE_DISCONNECT: + elm_object_domain_translatable_text_set(ugd->act_popup, PACKAGE, + "IDS_WIFI_POP_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_CONTINUE_Q"); + break; + case POP_TYPE_SCAN_AGAIN: + elm_object_domain_translatable_text_set(ugd->act_popup, PACKAGE, + "IDS_WIFI_BODY_CURRENT_CONNECTION_WILL_BE_DISCONNECTED_SO_THAT_SCANNING_CAN_START_CONTINUE_Q"); + break; + case POP_TYPE_CANCEL_CONNECT: + elm_object_domain_translatable_text_set(ugd->act_popup, PACKAGE, + "IDS_WIFI_POP_THIS_WI_FI_DIRECT_CONNECTION_WILL_BE_CANCELLED"); + break; + case POP_TYPE_ACCEPT_CONNECTION: + elm_object_domain_translatable_text_set(ugd->act_popup, PACKAGE, + "IDS_WIFI_BODY_PS_IS_REQUESTING_A_WI_FI_DIRECT_CONNECTION_ALLOW_Q"); + break; + default: + break; + } __FUNC_EXIT__; } +/** + * This function let the ug create a action popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] message the pointer to the text of popup + * @param[in] popup_type the message type + */ void wfd_ug_act_popup(void *data, const char *message, int popup_type) { __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + struct ug_data *ugd = (struct ug_data *) data; Evas_Object *popup = NULL; Evas_Object *btn1 = NULL, *btn2 = NULL; + WFD_IF_DEL_OBJ(ugd->act_popup); + popup = elm_popup_add(ugd->base); + elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0); + ea_object_event_callback_add(popup, EA_CALLBACK_BACK, ea_popup_back_cb, NULL); evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_object_text_set(popup, message); + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, _("IDS_WIFI_HEADER_WI_FI_DIRECT_CONNECTION_ABB")); + elm_object_domain_translatable_text_set(popup, PACKAGE, message); + evas_object_smart_callback_add(popup, "language,changed", act_popup_language_changed, (void *)popup_type); btn1 = elm_button_add(popup); btn2 = elm_button_add(popup); - elm_object_style_set(btn1, "popup_button/default"); - elm_object_style_set(btn2, "popup_button/default"); + elm_object_style_set(btn1, "popup"); + elm_object_style_set(btn2, "popup"); /* set the different text by type */ - if (popup_type == POPUP_TYPE_WIFI_OFF) { - elm_object_text_set(btn1, S_("IDS_COM_SK_YES")); - elm_object_text_set(btn2, S_("IDS_COM_SK_NO")); + if ( +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE + popup_type == POPUP_TYPE_WIFI_OFF || +#endif + + popup_type == POPUP_TYPE_HOTSPOT_OFF || + + FALSE) { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_WIFI_BODY_WI_FI_DIRECT_ABB"); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_ST_BUTTON_ENABLE"); + } else if (popup_type == POP_TYPE_CANCEL_CONNECT) { + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_WIFI_SK_STOP"); + } else if (popup_type == POP_TYPE_DISCONNECT) { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_WIFI_SK_DISCONNECT"); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_BR_SK_OK"); + + } else if (popup_type == POP_TYPE_SCAN_AGAIN) { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_WIFI_SK4_SCAN"); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_BR_SK_OK"); + } else if (popup_type == POP_TYPE_ACCEPT_CONNECTION) { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_WIFI_BODY_WI_FI_DIRECT_ABB"); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_WIFI_SK_CONNECT"); } else { - elm_object_text_set(btn1, S_("IDS_COM_SK_OK")); - elm_object_text_set(btn2, S_("IDS_COM_SK_CANCEL")); + elm_object_domain_translatable_text_set(btn1, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_domain_translatable_text_set(btn2, PACKAGE, + "IDS_BR_SK_OK"); } elm_object_part_content_set(popup, "button1", btn1); elm_object_part_content_set(popup, "button2", btn2); /* set the different callback by type */ +#ifndef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE if (popup_type == POPUP_TYPE_WIFI_OFF) { - evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_wifi_ok_cb, (void*) ugd); - evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_wifi_cancel_cb, (void*) ugd); - } else if (popup_type == POP_TYPE_DISCONNECT) { - //evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_disconnect_ok_cb, (void*) ugd); - evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_disconnect_all_ok_cb, (void*) ugd); - evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_disconnect_cancel_cb, (void*) ugd); - } else if (popup_type == POP_TYPE_DISCONNECT_ALL) { - evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_disconnect_all_ok_cb, (void*) ugd); - evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_disconnect_all_cancel_cb, (void*) ugd); - } else if (popup_type == POP_TYPE_SCAN_AGAIN) { - evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_scan_again_ok_cb, (void*) ugd); - evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_scan_again_cancel_cb, (void*) ugd); + evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP, _mouseup_wifi_cb, (void *)ugd); +// evas_object_event_callback_add(popup, EVAS_CALLBACK_KEY_DOWN, _keydown_wifi_cb, (void *)ugd); + + evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_wifi_cancel_cb, (void *)ugd); + evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_wifi_ok_cb, (void *)ugd); + } else +#endif /* MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE */ + + if (popup_type == POPUP_TYPE_HOTSPOT_OFF) { + evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP, _mouseup_hotspot_cb, (void *)ugd); +// evas_object_event_callback_add(popup, EVAS_CALLBACK_KEY_DOWN, _keydown_hotspot_cb, (void *)ugd); + + evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_hotspot_cancel_cb, (void *)ugd); + evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_hotspot_ok_cb, (void *)ugd); + } else + + if (popup_type == POP_TYPE_DISCONNECT || + popup_type == POP_TYPE_SCAN_AGAIN) { + evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP, _mouseup_disconnect_all_cb, (void *)ugd); +// evas_object_event_callback_add(popup, EVAS_CALLBACK_KEY_DOWN, _keydown_disconnect_all_cb, (void *)ugd); + + evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_cancel_cb, (void *)ugd); + evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_disconnect_all_ok_cb, (void *)ugd); + } else if (popup_type == POP_TYPE_CANCEL_CONNECT) { + evas_object_event_callback_add(popup, EVAS_CALLBACK_MOUSE_UP, _mouseup_disconnect_all_cb, (void *)ugd); + + evas_object_smart_callback_add(btn1, "clicked", _wfd_ug_act_popup_cancel_cb, (void *)ugd); + evas_object_smart_callback_add(btn2, "clicked", _wfd_ug_act_popup_cancel_connect_ok_cb, (void *)ugd); + } else if (popup_type == POP_TYPE_ACCEPT_CONNECTION ) { + evas_object_smart_callback_add(btn1, "clicked", + pushbutton_reject_connect_cb, (void *)ugd); + evas_object_smart_callback_add(btn2, "clicked", + pushbutton_accept_connect_cb, (void *)ugd); } evas_object_show(popup); @@ -234,135 +634,178 @@ void wfd_ug_act_popup(void *data, const char *message, int popup_type) __FUNC_EXIT__; } +/** + * This function let the ug remove the action popup + * @return void + * @param[in] data the pointer to the main data structure + */ void wfg_ug_act_popup_remove(void *data) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - if(ugd->act_popup) - { - evas_object_del(ugd->act_popup); - ugd->act_popup = NULL; - } - __FUNC_EXIT__; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + + if (ugd->act_popup) { + evas_object_del(ugd->act_popup); + ugd->act_popup = NULL; + } + __FUNC_EXIT__; } +/** + * This function let the ug call it when click 'ok' button in warning popup of terminated problem + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ static void _wfd_ug_terminate_popup_cb(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; - evas_object_del(ugd->warn_popup); - ugd->warn_popup = NULL; + evas_object_del(ugd->warn_popup); + ugd->warn_popup = NULL; - wfd_ug_view_free_peers(ugd); + wfd_ug_view_free_peers(ugd); - ug_destroy_me(ugd->ug); - __FUNC_EXIT__; + ug_destroy_me(ugd->ug); + __FUNC_EXIT__; } -static void _wfd_ug_warn_popup_cb(void *data, Evas_Object *obj, void *event_info) +/** + * This function let the ug call it when click 'ok' button in warning popup of turning off WFD automatically + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +/*static void _wfd_ug_automatic_turn_off_popup_cb(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - evas_object_del(ugd->warn_popup); - ugd->warn_popup = NULL; + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; - __FUNC_EXIT__; -} + evas_object_del(ugd->warn_popup); + ugd->warn_popup = NULL; -void wfd_ug_warn_popup(void *data, const char *message, int popup_type) + __FUNC_EXIT__; +}*/ + +/** + * This function let the ug call it when click 'ok' button in warning popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +static void _wfd_ug_warn_popup_cb(void *data, Evas_Object *obj, void *event_info) { - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - Evas_Object *popup = NULL; - Evas_Object *btn = NULL; - - popup = elm_popup_add(ugd->base); - evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_object_text_set(popup, message); - - btn = elm_button_add(popup); - elm_object_style_set(btn, "popup_button/default"); - elm_object_text_set(btn, S_("IDS_COM_SK_OK")); - elm_object_part_content_set(popup, "button1", btn); - if(popup_type == POPUP_TYPE_TERMINATE) - evas_object_smart_callback_add(btn, "clicked", _wfd_ug_terminate_popup_cb, (void*) ugd); - else - evas_object_smart_callback_add(btn, "clicked", _wfd_ug_warn_popup_cb, (void*) ugd); - - evas_object_show(popup); - ugd->warn_popup = popup; - __FUNC_EXIT__; -} + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; -void wfg_ug_warn_popup_remove(void *data) -{ - __FUNC_ENTER__; - struct ug_data *ugd = (struct ug_data*) data; - - if(ugd->warn_popup) - { - evas_object_del(ugd->warn_popup); - ugd->warn_popup = NULL; - } - __FUNC_EXIT__; -} + evas_object_del(ugd->warn_popup); + ugd->warn_popup = NULL; + if (ugd->rename_entry) { + elm_object_focus_set(ugd->rename_entry, EINA_TRUE); + } + + __FUNC_EXIT__; +} -void wfd_ug_tickernoti_popup(char *msg) +void warn_popup_language_changed(void *data, Evas_Object *obj, void *event_info) { __FUNC_ENTER__; - int ret = -1; - bundle *b = NULL; + int popup_type = (int)data; + struct ug_data *ugd = wfd_get_ug_data(); + char popup_text[MAX_POPUP_TEXT_SIZE] = {0}; + Evas_Object *btn = NULL; - b = bundle_create(); - if (!b) { - DBG(LOG_ERROR, "FAIL: bundle_create()\n"); + if (!ugd || !ugd->warn_popup) { + DBG(LOG_ERROR, "NULL parameters.\n"); return; } - /* tickernoti style */ - ret = bundle_add(b, "0", "info"); - if (ret) { - DBG(LOG_ERROR, "Fail to add tickernoti style\n"); - bundle_free(b); - return; + btn = elm_object_part_content_get(ugd->warn_popup, "button1"); + elm_object_domain_translatable_text_set(btn, PACKAGE, + "IDS_BR_SK_OK"); + + switch(popup_type) { + case POPUP_TYPE_ACTIVATE_FAIL_POLICY_RESTRICTS: + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + "IDS_COM_POP_SECURITY_POLICY_RESTRICTS_USE_OF_WI_FI"); + break; + case POPUP_TYPE_TERMINATE: + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + "IDS_COM_POP_FAILED"); + break; + case POPUP_TYPE_TERMINATE_DEACTIVATE_FAIL: + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + "IDS_WIFI_POP_DEACTIVATION_FAILED"); + break; + case POPUP_TYPE_TERMINATE_NOT_SUPPORT: + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + "IDS_ST_POP_NOT_SUPPORTED"); + break; + case POP_TYPE_BUSY_DEVICE_POPUP: + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + "IDS_ST_POP_DEVICE_CONNECTED_TO_ANOTHER_DEVICE"); + break; + case POP_TYPE_MULTI_CONNECT_POPUP: + 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); + elm_object_domain_translatable_text_set(ugd->warn_popup, PACKAGE, + popup_text); + break; + default: + break; } - /* popup text */ - ret = bundle_add(b, "1", msg); - if (ret) { - DBG(LOG_ERROR, "Fail to add popup text\n"); - bundle_free(b); - return; - } + __FUNC_EXIT__; +} - /* orientation of tickernoti */ - ret = bundle_add(b, "2", "1"); - if (ret) { - DBG(LOG_ERROR, "Fail to add orientation of tickernoti\n"); - bundle_free(b); - return; - } +/** + * This function let the ug create a warning popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] message the pointer to the text of popup + * @param[in] popup_type the message type + */ +void wfd_ug_warn_popup(void *data, const char *message, int popup_type) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + Evas_Object *popup = NULL; + Evas_Object *btn = NULL; - /* timeout(second) of tickernoti */ - ret = bundle_add(b, "3", "3"); - if (ret) { - DBG(LOG_ERROR, "Fail to add timeout of tickernoti\n"); - bundle_free(b); - return; + popup = elm_popup_add(ugd->base); + elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0); + ea_object_event_callback_add(popup, EA_CALLBACK_BACK, ea_popup_back_cb, NULL); + evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + if (popup_type == POP_TYPE_MULTI_CONNECT_POPUP || + popup_type == POP_TYPE_BUSY_DEVICE_POPUP) { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_WIFI_HEADER_UNABLE_TO_CONNECT_ABB2"); + } else { + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, _("IDS_WIFI_HEADER_WI_FI_DIRECT_CONNECTION_ABB")); } - - /* launch tickernoti */ - ret = syspopup_launch(TICKERNOTI_SYSPOPUP, b); - if (ret) { - DBG(LOG_ERROR, "Fail to launch syspopup\n"); + elm_object_domain_translatable_text_set(popup, PACKAGE, message); + evas_object_smart_callback_add(popup, "language,changed", warn_popup_language_changed, (void *)popup_type); + + btn = elm_button_add(popup); + elm_object_style_set(btn, "popup"); + elm_object_domain_translatable_text_set(btn, PACKAGE, "IDS_BR_SK_OK"); + elm_object_part_content_set(popup, "button1", btn); + if (popup_type == POPUP_TYPE_TERMINATE || + popup_type == POPUP_TYPE_TERMINATE_DEACTIVATE_FAIL || + popup_type == POPUP_TYPE_TERMINATE_NOT_SUPPORT) { + evas_object_smart_callback_add(btn, "clicked", _wfd_ug_terminate_popup_cb, (void *)ugd); + } else { + evas_object_smart_callback_add(btn, "clicked", _wfd_ug_warn_popup_cb, (void *)ugd); } - bundle_free(b); + evas_object_show(popup); + ugd->warn_popup = popup; __FUNC_EXIT__; } diff --git a/ug-wifidirect/src/wfd_ug_rename_popup.c b/ug-wifidirect/src/wfd_ug_rename_popup.c new file mode 100644 index 0000000..7014fa5 --- /dev/null +++ b/ug-wifidirect/src/wfd_ug_rename_popup.c @@ -0,0 +1,415 @@ +/* +* WiFi-Direct UG +* +* Copyright 2012 Samsung Electronics Co., Ltd + +* Licensed under the Flora License, Version 1.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at + +* http://www.tizenopensource.org/license + +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +*/ + +#include <Elementary.h> +#include <vconf.h> +#include <wifi-direct.h> + +#include "wfd_ug.h" +#include "wfd_ug_view.h" +#include "wfd_client.h" + +#define WSC_SPEC_DEVICE_NAME_MAX_LEN 32 +static char special_char[30] = "'!@$%^&*()-_=+[];:,<.>/?"; + +static bool is_space_str(const char *str) +{ + while (str) { + if (*str != '\0' && *str != ' ') { + return FALSE; + } else if (*str == '\0') { + return TRUE; + } + str++; + } + return TRUE; +} + +/** + * This function check the max length of the device name + * @return void + * @param[in] data the pointer to the main data structure + */ +static void _rename_popop_entry_changed_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RET_IF(ugd == NULL || obj == NULL, "Incorrect parameter(NULL)\n"); + WFD_RET_IF(ugd->rename_button == NULL, "ugd->rename_button(NULL)\n"); + + const char *entry_text = NULL; + char *input_str = NULL; + bool is_space_string = FALSE; + + entry_text = elm_entry_entry_get(obj); + input_str = elm_entry_markup_to_utf8(entry_text); + + if (elm_object_part_content_get(obj, "elm.swallow.clear")) { + if (elm_object_focus_get(obj)) { + if (elm_entry_is_empty(obj)) + elm_object_signal_emit(obj, "elm,state,clear,hidden", ""); + else + elm_object_signal_emit(obj, "elm,state,clear,visible", ""); + } + } + + if (input_str == NULL || (strlen(input_str) == 0)) { + elm_object_disabled_set(ugd->rename_button, TRUE); + elm_entry_input_panel_return_key_disabled_set(ugd->rename_entry, TRUE); + WFD_IF_FREE_MEM(input_str); + return; + } + + is_space_string = is_space_str(input_str); + if (is_space_string) { + elm_object_disabled_set(ugd->rename_button, TRUE); + elm_entry_input_panel_return_key_disabled_set(ugd->rename_entry, TRUE); + WFD_IF_FREE_MEM(input_str); + return; + } + + if (strlen(input_str) > 0) { + elm_object_disabled_set(ugd->rename_button, FALSE); + elm_entry_input_panel_return_key_disabled_set(ugd->rename_entry, FALSE); + } + + WFD_IF_FREE_MEM(input_str); + __FUNC_EXIT__; +} + +static void _rename_popup_cancel_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + + WFD_IF_DEL_OBJ(ugd->rename_popup); + WFD_IF_DEL_OBJ(ugd->rename_entry); + + __FUNC_EXIT__; +} + +int _check_device_name(const char *device_name) +{ + __FUNC_ENTER__; + + int i = 0; + int j = 0; + bool is_unavailable_char_found = true; + + if ((device_name == NULL) || (strlen(device_name) == 0)) { + return -1; + } + + for (i = 0; i < strlen(device_name); i++) { + if ((device_name[i] >= '0' && device_name[i] <= '9') || + (device_name[i] >= 'a' && device_name[i] <= 'z') || + (device_name[i] >= 'A' && device_name[i] <= 'Z') || + device_name[i] == ' ') { + continue; + } + is_unavailable_char_found = true; + for (j = 0; j < strlen(special_char); j++) { + if (special_char[j] == device_name[i]) { + is_unavailable_char_found = false; + break; + } + } + + if (is_unavailable_char_found) { + DBG(LOG_ERROR, "Unavailable char:[%c]\n", device_name[i]); + return -1; + } + } + + __FUNC_EXIT__; + return 0; +} + +static void _rename_popup_ok_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + + const char *entry_str = elm_entry_entry_get(ugd->rename_entry); + char *device_name_str = NULL; + device_name_str = elm_entry_markup_to_utf8(entry_str); + + DBG(LOG_INFO, "New device name:[%s]\n", device_name_str); + _check_device_name(device_name_str); + + if (0 != vconf_set_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR, device_name_str)) { + DBG(LOG_ERROR, "Set vconf[%s] failed\n",VCONFKEY_SETAPPL_DEVICE_NAME_STR); + } +#ifdef WFD_ON_OFF_GENLIST + wfd_ug_view_refresh_glitem(ugd->item_wifi_onoff); +#endif + wfd_ug_view_refresh_glitem(ugd->device_name_item); + WFD_IF_DEL_OBJ(ugd->rename_popup); + WFD_IF_DEL_OBJ(ugd->rename_entry); + WFD_IF_FREE_MEM(device_name_str); + __FUNC_EXIT__; +} + +static void _eraser_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RET_IF(ugd == NULL, "Incorrect parameter(NULL)\n"); + WFD_RET_IF(ugd->rename_entry == NULL, "ugd->rename_entry(NULL)\n"); + elm_entry_entry_set(ugd->rename_entry, ""); + elm_object_domain_translatable_part_text_set(ugd->rename_entry, "elm.guide", + PACKAGE, "IDS_STU_HEADER_ENTER_DEVICE_NAME"); + + WFD_RET_IF(ugd->rename_button == NULL, "ugd->rename_button(NULL)\n"); + elm_object_disabled_set(ugd->rename_button, TRUE); + elm_entry_input_panel_return_key_disabled_set(ugd->rename_entry, TRUE); + __FUNC_EXIT__; +} + +static void __device_name_maxlength_reached_cb(void *data, Evas_Object *obj, + void *event_info) +{ + __FUNC_ENTER__; + + if (data == NULL || obj == NULL) { + DBG(LOG_ERROR, "The param is NULL\n"); + return; + } + + int ret = notification_status_message_post( + _("IDS_COM_POP_MAXIMUM_NUMBER_OF_CHARACTERS_REACHED")); + if (ret != NOTIFICATION_ERROR_NONE) { + DBG(LOG_ERROR, "notification_status_message_post() ERROR [%d]", ret); + } + + __FUNC_EXIT__; +} + +static void _entry_focused_cb(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_object_part_content_get(obj, "elm.swallow.clear")) { + if (!elm_entry_is_empty(obj)) + elm_object_signal_emit(obj, "elm,state,clear,visible", ""); + else + elm_object_signal_emit(obj, "elm,state,clear,hidden", ""); + } + elm_object_signal_emit(obj, "elm,state,focus,on", ""); +} + +static void _rename_entry_keydown_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + + Evas_Event_Key_Down *ev; + Evas_Object *entry = obj; + + WFD_RET_IF(data == NULL, "Incorrect parameter data(NULL)\n"); + WFD_RET_IF(event_info == NULL, "Incorrect parameter event_info(NULL)\n"); + WFD_RET_IF(entry == NULL, "Incorrect parameter entry(NULL)\n"); + + ev = (Evas_Event_Key_Down *)event_info; + DBG(LOG_INFO, "ENTER ev->key:%s", ev->key); + + if (g_strcmp0(ev->key, "KP_Enter") == 0 || g_strcmp0(ev->key, "Return") == 0) { + Ecore_IMF_Context *imf_context; + + imf_context = (Ecore_IMF_Context*)elm_entry_imf_context_get(entry); + if (imf_context) { + ecore_imf_context_input_panel_hide(imf_context); + } + + elm_object_focus_set(entry, EINA_FALSE); + } +} +static char *__wfd_main_rename_desc_label_get(void *data, Evas_Object *obj, + const char *part) +{ + __FUNC_ENTER__; + + DBG(LOG_INFO,"Part = %s", part); + if (obj == NULL || part == NULL) { + return NULL; + } + + if (!strcmp(part, "elm.text.multiline")) { + return g_strdup(_("IDS_ST_POP_DEVICE_NAMES_ARE_DISPLAYED_TO_DISTINGUISH_EACH_OF_THE_DEVICES_AVAILABLE_MSG")); + } + __FUNC_EXIT__; + return NULL; +} + +static Evas_Object *__wfd_main_rename_entry_icon_get( + void *data, Evas_Object *obj, const char *part) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *)data; + WFD_RETV_IF(ugd == NULL, NULL, "Incorrect parameter(NULL)\n"); + Evas_Object *entry = NULL; + Evas_Object *layout = NULL; + Evas_Object *button = NULL; + Ecore_IMF_Context *imf_context; + char *name_value = NULL; + + static Elm_Entry_Filter_Limit_Size limit_filter_data; + + if (!strcmp(part, "elm.icon.entry")) { + + name_value = elm_entry_utf8_to_markup(ugd->dev_name); + entry = ea_editfield_add(obj, EA_EDITFIELD_SCROLL_SINGLELINE); + limit_filter_data.max_char_count = WSC_SPEC_DEVICE_NAME_MAX_LEN; + elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size, &limit_filter_data); + + evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL); + ea_entry_selection_back_event_allow_set(entry, EINA_TRUE); + elm_object_signal_emit(entry, "elm,action,hide,search_icon", ""); + elm_object_domain_translatable_part_text_set(entry, "elm.guide", + PACKAGE, "IDS_STU_HEADER_ENTER_DEVICE_NAME"); + + imf_context = (Ecore_IMF_Context*)elm_entry_imf_context_get(entry); + if (imf_context) { + ecore_imf_context_input_panel_return_key_type_set(imf_context, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_DONE); + } + + ugd->rename_entry = entry; + elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT); + elm_entry_entry_set(entry, name_value); + WFD_IF_FREE_MEM(name_value); + elm_entry_cursor_end_set(entry); + + evas_object_smart_callback_add(entry, "changed,user", _rename_popop_entry_changed_cb, ugd); + evas_object_smart_callback_add(entry, "changed", _rename_popop_entry_changed_cb, ugd); + evas_object_smart_callback_add(entry, "preedit,changed", _rename_popop_entry_changed_cb, ugd); + evas_object_smart_callback_add(entry, "maxlength,reached", + __device_name_maxlength_reached_cb, ugd); + + button = elm_button_add(obj); + elm_object_style_set(button, "search_clear"); + elm_object_focus_allow_set(button, EINA_FALSE); + elm_object_part_content_set(entry, "elm.swallow.clear", button); + evas_object_smart_callback_add(button, "clicked", _eraser_btn_clicked_cb, ugd); + + evas_object_smart_callback_add(entry, "focused", _entry_focused_cb, NULL); + evas_object_event_callback_add(entry, EVAS_CALLBACK_KEY_DOWN, _rename_entry_keydown_cb, ugd); + elm_object_part_content_set(layout, "entry_part", entry); + evas_object_show(entry); + elm_object_focus_set(entry, EINA_TRUE); + + __FUNC_EXIT__; + return entry; + } + __FUNC_EXIT__; + return NULL; +} + + +/** + * This function let the ug create rename popup + * @return void + * @param[in] data the pointer to the main data structure + * @param[in] obj the pointer to the evas object + * @param[in] event_info the pointer to the event information + */ +void _gl_rename_device_sel(void *data, Evas_Object *obj, void *event_info) +{ + __FUNC_ENTER__; + struct ug_data *ugd = (struct ug_data *) data; + WFD_RET_IF(ugd == NULL, "The param is NULL\n"); + WFD_IF_DEL_OBJ(ugd->ctxpopup); + WFD_IF_DEL_OBJ(ugd->rename_popup); + Evas_Object *popup; + Evas_Object *button; + Evas_Object *genlist = NULL; + Evas_Object *layout = NULL; + Elm_Object_Item *git = NULL; + + popup = elm_popup_add(ugd->layout); +// elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0); + ea_object_event_callback_add(popup, EA_CALLBACK_BACK, _rename_popup_cancel_cb, ugd); + evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_object_domain_translatable_part_text_set(popup, "title,text", + PACKAGE, "IDS_ST_HEADER_RENAME_DEVICE"); + + layout = elm_layout_add(popup); + elm_layout_file_set(layout, WFD_UG_EDJ_PATH, "main_rename_device_ly"); + evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + + genlist = elm_genlist_add(layout); + evas_object_size_hint_weight_set(genlist, + EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS); + elm_scroller_content_min_limit(genlist, EINA_FALSE, EINA_TRUE); + + /* Entry genlist item */ + ugd->rename_entry_itc = elm_genlist_item_class_new(); + WFD_RET_IF(ugd->rename_entry_itc == NULL, "rename_entry_itc is NULL\n"); + ugd->rename_entry_itc->item_style = "entry"; + ugd->rename_entry_itc->func.text_get = NULL; + ugd->rename_entry_itc->func.content_get = __wfd_main_rename_entry_icon_get; + ugd->rename_entry_itc->func.state_get = NULL; + ugd->rename_entry_itc->func.del = NULL; + + elm_genlist_item_append(genlist, ugd->rename_entry_itc, ugd, + NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); + + ugd->rename_desc_itc = elm_genlist_item_class_new(); + WFD_RET_IF(ugd->rename_desc_itc == NULL, "rename_desc_itc is NULL\n"); + ugd->rename_desc_itc->item_style = "multiline_sub"; + ugd->rename_desc_itc->func.text_get = __wfd_main_rename_desc_label_get; + ugd->rename_desc_itc->func.content_get = NULL; + ugd->rename_desc_itc->func.state_get = NULL; + ugd->rename_desc_itc->func.del = NULL; + + git = elm_genlist_item_append(genlist, ugd->rename_desc_itc, NULL, NULL, + ELM_GENLIST_ITEM_NONE, NULL, NULL); + if(git != NULL) + elm_genlist_item_select_mode_set(git, + ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); + + button = elm_button_add(popup); + elm_object_style_set(button, "popup"); + elm_object_domain_translatable_text_set(button, PACKAGE, + "IDS_BR_SK_CANCEL"); + elm_object_part_content_set(popup, "button1", button); + evas_object_smart_callback_add(button, "clicked", _rename_popup_cancel_cb, ugd); + + button = elm_button_add(popup); + elm_object_style_set(button, "popup"); + elm_object_domain_translatable_text_set(button, PACKAGE, + "IDS_ST_SK_RENAME"); + elm_object_part_content_set(popup, "button2", button); + evas_object_smart_callback_add(button, "clicked", _rename_popup_ok_cb, ugd); + ugd->rename_button = button; + evas_object_show(button); + + elm_genlist_realization_mode_set(genlist, EINA_TRUE); + evas_object_show(genlist); + elm_object_part_content_set(layout, "elm.swallow.layout", genlist); + evas_object_show(layout); + elm_object_content_set(popup, layout); + evas_object_show(popup); + elm_object_focus_set(ugd->rename_entry, EINA_TRUE); + ugd->rename_popup = popup; + evas_object_show(button); + + __FUNC_EXIT__; +} + |