ug-wifidirect/src/wfd_ug.c

   1 /*
   2 *  WiFi-Direct UG
   3 *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9
  10 * http://www.tizenopensource.org/license
  11
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17 *
  18 */
  19
  20
  21 #ifndef UG_MODULE_API
  22 #define UG_MODULE_API __attribute__ ((visibility("default")))
  23 #endif
  24
  25
  26 #include <sys/time.h>
  27 #include <libintl.h>
  28 #include <sys/utsname.h>
  29
  30 #include <vconf.h>
  31 #include <Elementary.h>
  32 #include <ui-gadget-module.h>
  33 #include <app_control.h>
  34
  35 #include "wfd_ug.h"
  36 #include "wfd_ug_view.h"
  37 #include "wfd_client.h"
  38 #ifdef MOTION_CONTROL_ENABLE
  39 #include "wfd_motion_control.h"
  40 #endif
  41
  42 void initialize_gen_item_class();
  43
  44 struct ug_data *global_ugd = NULL;
  45
  46 struct ug_data *wfd_get_ug_data()
  47 {
  48         return global_ugd;
  49 }
  50
  51 static void __wfd_main_vconf_change_cb(keynode_t *key, void *data)
  52 {
  53         __FUNC_ENTER__;
  54         WFD_RET_IF(NULL == key, "ERROR : key is NULL !!\n");
  55         WFD_RET_IF(NULL == data, "ERROR : data is NULL");
  56         struct ug_data *ugd = (struct ug_data *) data;
  57
  58         char *vconf_name = vconf_keynode_get_name(key);
  59
  60         if (!g_strcmp0(vconf_name, VCONFKEY_SETAPPL_DEVICE_NAME_STR)){
  61                 char *name_value = NULL;
  62                 name_value = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
  63                 WFD_RET_IF (!name_value, "Get string is failed");
  64                 DBG(LOG_INFO,"name : %s", name_value);
  65
  66                 if (ugd->device_name_item && g_strcmp0(ugd->dev_name, name_value))
  67                         wfd_ug_view_refresh_glitem(ugd->device_name_item);
  68
  69                 free(name_value);
  70         } else {
  71                 DBG(LOG_ERROR, "vconf_name is error");
  72         }
  73         __FUNC_EXIT__;
  74 }
  75
  76 #ifdef WIFI_STATE_CB
  77 static void _wifi_on_state_cb(keynode_t *key, void *data)
  78 {
  79         WFD_RET_IF(NULL == key, "ERROR : key is NULL !!\n");
  80         WFD_RET_IF(NULL == data, "ERROR : data is NULL");
  81
  82         struct ug_data *ugd = (struct ug_data *)data;
  83         int wifi_state = 0;
  84
  85         if (vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state) < 0) {
  86                 DBG(LOG_ERROR, "Failed to get vconf VCONFKEY_WIFI_STATE\n");
  87                 return;
  88         }
  89
  90         DBG(LOG_INFO, "WiFi State [%d]\n", wifi_state);
  91         if (wifi_state > VCONFKEY_WIFI_OFF && wifi_state < VCONFKEY_WIFI_STATE_MAX) {
  92                 if (WIFI_DIRECT_ERROR_NONE != wifi_direct_get_state(&ugd->wfd_status)) {
  93                         DBG(LOG_ERROR, "Failed to Get WiFi Direct State");
  94                         return;
  95                 }
  96                 if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) {
  97                         DBG(LOG_INFO, "Activate WiFi Direct...");
  98                         if (FALSE != wfd_client_switch_on(ugd)) {
  99                                 DBG(LOG_ERROR, "Failed to Activate WiFi Direct");
 100                         }
 101                 }
 102         }
 103 }
 104 #endif
 105
 106
 107 static void __wfd_hotspot_mode_vconf_change_cb(keynode_t *key, void *data)
 108 {
 109         DBG(LOG_INFO, "__wfd_hotspot_mode_vconf_change_cb");
 110         if (NULL == key || NULL == data) {
 111                 DBG(LOG_INFO, "Invalid parameters \n");
 112                 return;
 113         }
 114         struct ug_data *ugd = (struct ug_data *) data;
 115         int hotspot_mode = 0;
 116         int res = 0;
 117
 118         res = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_mode);
 119         if (res) {
 120                 DBG(LOG_INFO, "Failed to get vconf value for PLMN(%d)", res);
 121                 return;
 122         }
 123         DBG(LOG_INFO, "__wfd_hotspot_mode_vconf_change_cb mode %d", hotspot_mode);
 124
 125         if (VCONFKEY_MOBILE_HOTSPOT_MODE_NONE == hotspot_mode) {
 126                 if (NULL != ugd->act_popup) {
 127                         evas_object_del(ugd->act_popup);
 128                 }
 129 #ifdef WFD_ON_OFF_GENLIST
 130                 wfd_ug_refresh_on_off_check(ugd);
 131 #endif
 132         } else if (hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI ||
 133                                 hotspot_mode == VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP) {
 134                 if (NULL != ugd->warn_popup) {
 135                         evas_object_del(ugd->warn_popup);
 136                         ugd->warn_popup = NULL;
 137                 }
 138         }
 139
 140 }
 141
 142 /**
 143  *      This function let the ug create backgroud
 144  *      @return  backgroud
 145  *      @param[in] ugd the pointer to the parent object
 146  *      @param[in] ugd the pointer to the main data structure
 147  */
 148 static Evas_Object *_create_bg(Evas_Object *parent, char *style)
 149 {
 150         __FUNC_ENTER__;
 151         Evas_Object *bg;
 152
 153         bg = elm_bg_add(parent);
 154         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 155         elm_object_style_set(bg, style);
 156         evas_object_show(bg);
 157
 158         __FUNC_EXIT__;
 159         return bg;
 160 }
 161
 162 /**
 163  *      This function let the ug create full view
 164  *      @return  full view
 165  *      @param[in] ugd the pointer to the parent object
 166  *      @param[in] ugd the pointer to the main data structure
 167  */
 168 static Evas_Object *_create_fullview(Evas_Object *parent, struct ug_data *ugd)
 169 {
 170         __FUNC_ENTER__;
 171         Evas_Object *base;
 172
 173         if (parent == NULL) {
 174                 DBG(LOG_ERROR, "Incorrenct parameter");
 175                 return NULL;
 176         }
 177
 178         /* Create Full view */
 179         base = elm_layout_add(parent);
 180         if (!base) {
 181                 DBG(LOG_ERROR, "Failed to add layout");
 182                 return NULL;
 183         }
 184
 185         elm_layout_theme_set(base, "layout", "application", "default");
 186         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 187         evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
 188
 189         __FUNC_EXIT__;
 190         return base;
 191 }
 192
 193 /**
 194  *      This function let the ug create frame view
 195  *      @return  frame view
 196  *      @param[in] ugd the pointer to the parent object
 197  *      @param[in] ugd the pointer to the main data structure
 198  */
 199 static Evas_Object *_create_frameview(Evas_Object *parent, struct ug_data *ugd)
 200 {
 201         __FUNC_ENTER__;
 202         Evas_Object *base;
 203
 204         if (parent == NULL) {
 205                 DBG(LOG_ERROR, "Incorrenct parameter");
 206                 return NULL;
 207         }
 208
 209         /* Create Frame view */
 210         base = elm_layout_add(parent);
 211         if (!base) {
 212                 DBG(LOG_ERROR, "Failed to add layout");
 213                 return NULL;
 214         }
 215
 216         elm_layout_theme_set(base, "layout", "application", "default");
 217         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 218         evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
 219
 220         __FUNC_EXIT__;
 221         return base;
 222 }
 223
 224 /**
 225  *      This function let the ug destroy the ug
 226  *      @return   void
 227  *      @param[in] data the pointer to the main data structure
 228  */
 229 void wfd_destroy_ug(void *data)
 230 {
 231         __FUNC_ENTER__;
 232         struct ug_data *ugd = (struct ug_data *) data;
 233
 234 #ifdef WFD_DBUS_LAUNCH
 235         if (ugd->dbus_cancellable != NULL) {
 236                 g_cancellable_cancel(ugd->dbus_cancellable);
 237                 g_object_unref(ugd->dbus_cancellable);
 238                 ugd->dbus_cancellable = NULL;
 239                 if (ugd->conn) {
 240                         g_object_unref(ugd->conn);
 241                         ugd->conn = NULL;
 242                 }
 243                 DBG(LOG_INFO, "Cancelled dbus call");
 244                 return;
 245         } else
 246 #endif
 247         {
 248                 DBG(LOG_INFO, "dbus_cancellable is NULL");
 249                 ug_destroy_me(ugd->ug);
 250         }
 251
 252         __FUNC_EXIT__;
 253         return;
 254 }
 255
 256 static void wfd_ug_layout_del_cb(void *data , Evas *e, Evas_Object *obj, void *event_info)
 257 {
 258         __FUNC_ENTER__;
 259
 260         struct ug_data *ugd = (struct ug_data *) data;
 261         if (ugd == NULL) {
 262                 DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 263                 return;
 264         }
 265
 266         wfd_client_free_raw_discovered_peers(ugd);
 267         wfd_ug_view_free_peers(ugd);
 268         destroy_wfd_ug_view(ugd);
 269
 270         __FUNC_EXIT__;
 271 }
 272
 273 #ifdef WFD_DBUS_LAUNCH
 274 /**
 275  *      This function let the ug initialize wfd
 276  *      @return   void
 277  *      @param[in] data the pointer to the main data structure
 278  *      @param[in] evas the pointer to the evas canvas
 279  *      @param[in] obj the pointer to the evas object
 280  *      @param[in] event_info the pointer to the event information
 281  */
 282 static void _wfd_init_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 283 {
 284         __FUNC_ENTER__;
 285         int res = -1;
 286         struct ug_data *ugd = (struct ug_data *)data;
 287         WFD_RET_IF(ugd == NULL || ugd->base == NULL, "Incorrect parameter(NULL)\n");
 288
 289         evas_object_event_callback_del(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb);
 290
 291         res = launch_wifi_direct_manager(ugd);
 292         if (res != 0) {
 293                 DBG(LOG_ERROR, "Failed to launch wifi direct manager\n");
 294         }
 295
 296         __FUNC_EXIT__;
 297         return;
 298 }
 299 #endif
 300
 301 static void *on_create(ui_gadget_h ug, enum ug_mode mode, app_control_h control, void *priv)
 302 {
 303         __FUNC_ENTER__;
 304         struct ug_data *ugd;
 305         int wfd_status = -1;
 306         int rots[4] = { 0, 90, 180, 270 };
 307         int ret;
 308
 309         if (!ug || !priv) {
 310                 return NULL;
 311         }
 312
 313         ugd = priv;
 314         ugd->ug = ug;
 315
 316         bindtextdomain(PACKAGE, LOCALEDIR);
 317
 318         ugd->win = ug_get_window();
 319         if (!ugd->win) {
 320                 return NULL;
 321         }
 322
 323         /* set rotation */
 324         if (elm_win_wm_rotation_supported_get(ugd->win)) {
 325                 int rots[4] = {0, 90, 180, 270};
 326                 elm_win_wm_rotation_available_rotations_set(ugd->win, (const int *)(&rots), 4);
 327         }
 328
 329         /* check the input parameters from app at first */
 330         ugd->wfds = NULL;
 331         ugd->device_filter = -1; /* show all devices */
 332         ugd->is_auto_exit = false;
 333         ugd->is_multi_connect = true;
 334         ugd->is_init_ok = false;
 335         ugd->title = strdup(_("IDS_WIFI_BODY_WI_FI_DIRECT_ABB"));
 336
 337         if (control) {
 338                 char *wfds = NULL;
 339                 char *device_filter = NULL;
 340                 char *auto_exit = NULL;
 341                 char *multi_connect = NULL;
 342                 char *title = NULL;
 343                 char* viewtype = NULL;
 344
 345                 /*
 346                 * get the control name
 347                 * default value: Wi-Fi Direct
 348                 */
 349                 ret = app_control_get_extra_data(control, "wfds", &wfds);
 350                 if (ret == APP_CONTROL_ERROR_NONE && wfds) {
 351                         DBG_SECURE(LOG_INFO, "Wfds name: %s", wfds);
 352                         ugd->wfds = strdup(wfds);
 353                         WFD_IF_FREE_MEM(wfds);
 354                 }
 355
 356                 ret = app_control_get_extra_data(control, "viewtype", &viewtype);
 357                 if(ret == APP_CONTROL_ERROR_NONE && viewtype) {
 358                         DBG(LOG_INFO, "viewtype: %s\n", viewtype);
 359                         ugd->view_type = strdup(viewtype);
 360                         WFD_IF_FREE_MEM(viewtype);
 361                 }
 362
 363                 /*
 364                 * get the device filter
 365                 * default value: NULL
 366                 */
 367                 ret = app_control_get_extra_data(control, "device_filter", &device_filter);
 368                 if (ret == APP_CONTROL_ERROR_NONE && device_filter) {
 369                         DBG(LOG_INFO, "Device filter: %s", device_filter);
 370                         if (0 == strncmp(device_filter, "computer", 8)) {
 371                                 ugd->device_filter = WFD_DEVICE_TYPE_COMPUTER;
 372                         } else if (0 == strncmp(device_filter, "input_device", 12)) {
 373                                 ugd->device_filter = WFD_DEVICE_TYPE_INPUT_DEVICE;
 374                         } else if (0 == strncmp(device_filter, "printer", 6)) {
 375                                 ugd->device_filter = WFD_DEVICE_TYPE_PRINTER;
 376                         } else if (0 == strncmp(device_filter, "camera", 6)) {
 377                                 ugd->device_filter = WFD_DEVICE_TYPE_CAMERA;
 378                         } else if (0 == strncmp(device_filter, "storage", 7)) {
 379                                 ugd->device_filter = WFD_DEVICE_TYPE_STORAGE;
 380                         } else if (0 == strncmp(device_filter, "network_infra", 13)) {
 381                                 ugd->device_filter = WFD_DEVICE_TYPE_NW_INFRA;
 382                         } else if (0 == strncmp(device_filter, "display", 7)) {
 383                                 ugd->device_filter = WFD_DEVICE_TYPE_DISPLAYS;
 384                         } else if (0 == strncmp(device_filter, "multimedia_device", 17)) {
 385                                 ugd->device_filter = WFD_DEVICE_TYPE_MM_DEVICES;
 386                         } else if (0 == strncmp(device_filter, "game_device", 11)) {
 387                                 ugd->device_filter = WFD_DEVICE_TYPE_GAME_DEVICES;
 388                         } else if (0 == strncmp(device_filter, "telephone", 9)) {
 389                                 ugd->device_filter = WFD_DEVICE_TYPE_TELEPHONE;
 390                         } else if (0 == strncmp(device_filter, "audio", 5)) {
 391                                 ugd->device_filter = WFD_DEVICE_TYPE_AUDIO;
 392                         } else {
 393                                 ugd->device_filter = WFD_DEVICE_TYPE_OTHER;
 394                         }
 395                         WFD_IF_FREE_MEM(device_filter);
 396                 }
 397
 398                 /*
 399                 * get whether support auto exit after connection
 400                 * default value: false
 401                 */
 402                 ret = app_control_get_extra_data(control, "auto_exit", &auto_exit);
 403                 if (ret == APP_CONTROL_ERROR_NONE && auto_exit) {
 404                         DBG(LOG_INFO, "Auto exit: %s", auto_exit);
 405                         if (0 == strncmp(auto_exit, "on", 2)) {
 406                                 ugd->is_auto_exit = true;
 407                         } else {
 408                                 ugd->is_auto_exit = false;
 409                         }
 410                         WFD_IF_FREE_MEM(auto_exit);
 411                 }
 412
 413                 /*
 414                 * get whether support multi connection,
 415                 * default value: true
 416                 */
 417                 ret = app_control_get_extra_data(control, "multi_connect", &multi_connect);
 418                 if (ret == APP_CONTROL_ERROR_NONE && multi_connect) {
 419                         DBG(LOG_INFO, "Multi connection: %s", multi_connect);
 420                         if (0 == strncmp(multi_connect, "off", 2)) {
 421                                 ugd->is_multi_connect = false;
 422                         } else {
 423                                 ugd->is_multi_connect = true;
 424                         }
 425                         WFD_IF_FREE_MEM(multi_connect);
 426                 }
 427
 428                 /*
 429                 * get the title of UG
 430                 * default value: Wi-Fi Direct
 431                 */
 432                 ret = app_control_get_extra_data(control, "title_string", &title);
 433                 if (ret == APP_CONTROL_ERROR_NONE && title) {
 434                         DBG(LOG_INFO, "Title of UG: %s", title);
 435                         WFD_IF_FREE_MEM(ugd->title);
 436                         ugd->title = strdup(title);
 437                         WFD_IF_FREE_MEM(title);
 438                 }
 439         }
 440
 441         if (mode == UG_MODE_FULLVIEW) {
 442                 ugd->base = _create_fullview(ugd->win, ugd);
 443         } else {
 444                 ugd->base = _create_frameview(ugd->win, ugd);
 445         }
 446
 447         if (ugd->base) {
 448                 evas_object_event_callback_add(ugd->base, EVAS_CALLBACK_DEL, wfd_ug_layout_del_cb, ugd);
 449                 ugd->bg = _create_bg(ugd->win, "group_list");
 450                 elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg);
 451         } else {
 452                 DBG(LOG_ERROR, "Failed to create base layout\n");
 453                 return NULL;
 454         }
 455
 456         /* check status of wifi-direct from vconf */
 457         wfd_status = wfd_get_vconf_status();
 458         if (wfd_status < 0) {
 459                 return NULL;
 460         }
 461
 462         /* draw UI */
 463         initialize_gen_item_class();
 464         create_wfd_ug_view(ugd);
 465         wfd_ug_view_init_genlist(ugd, true);
 466 #ifdef MOTION_CONTROL_ENABLE
 467         motion_create(ugd);
 468 #endif
 469
 470         /*
 471         * if not deactivated, do initialization at once;
 472         * otherwise, do initialization later
 473         */
 474         if (wfd_status != VCONFKEY_WIFI_DIRECT_DEACTIVATED) {
 475                 init_wfd_client(ugd);
 476         } else {
 477                 ugd->wfd_status = WIFI_DIRECT_STATE_DEACTIVATED;
 478
 479 #ifdef WFD_DBUS_LAUNCH
 480                 evas_object_event_callback_add(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb, ugd);
 481 #else
 482                 ret = init_wfd_client(ugd);
 483                 WFD_RETV_IF(ret != 0, NULL,  "Failed to initialize WFD client library\n");
 484
 485                 /* Activate WiFi Direct */
 486                 DBG(LOG_INFO, "Activating WiFi Direct...");
 487                 if (ugd->wfd_status <= WIFI_DIRECT_STATE_DEACTIVATING) {
 488                         ret = wfd_client_switch_on(ugd);
 489                         WFD_RETV_IF(ret != 0, NULL, "Failed to activate WFD\n");
 490                 }
 491 #endif
 492         }
 493         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 494                         __wfd_main_vconf_change_cb, ugd);
 495         if (ret) {
 496                 DBG(LOG_ERROR, "Failed to set vconf notification callback(VCONFKEY_SETAPPL_DEVICE_NAME_STR)");
 497         }
 498
 499 #ifdef WIFI_STATE_CB
 500         ret = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, _wifi_on_state_cb, ugd);
 501         if (ret) {
 502                 DBG(LOG_ERROR, "Failed to set vconf notification callback(VCONFKEY_WIFI_STATE)");
 503
 504         }
 505 #endif
 506
 507         ret = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_MODE,
 508                 __wfd_hotspot_mode_vconf_change_cb, ugd);
 509         if (ret) {
 510                 DBG(LOG_ERROR, "Failed to set vconf notification callback(MOBILE_HOTSPOT_MODE)");
 511         }
 512
 513         __FUNC_EXIT__;
 514         return ugd->base;
 515 }
 516
 517 static void on_start(ui_gadget_h ug, app_control_h control, void *priv)
 518 {
 519         __FUNC_ENTER__;
 520         struct ug_data *ugd;
 521         int res;
 522
 523         if (!ug || !priv) {
 524                 return;
 525         }
 526
 527         ugd = priv;
 528
 529         struct utsname kernel_info;
 530         res = uname(&kernel_info);
 531         if (res != 0) {
 532                 DBG(LOG_ERROR, "Failed to detect target type\n");
 533         } else {
 534                 DBG_SECURE(LOG_INFO, "HW ID of this device [%s]\n", kernel_info.machine);
 535                 if (strncmp(kernel_info.machine, "arm", 3) != 0) {
 536                         wfd_ug_warn_popup(ugd, _("IDS_ST_POP_NOT_SUPPORTED"), POPUP_TYPE_TERMINATE_NOT_SUPPORT);
 537                         return;
 538                 }
 539         }
 540
 541         __FUNC_EXIT__;
 542 }
 543
 544 static void on_pause(ui_gadget_h ug, app_control_h control, void *priv)
 545 {
 546         __FUNC_ENTER__;
 547
 548         WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n");
 549         struct ug_data *ugd = priv;
 550         ugd->is_paused = true;
 551
 552         wfd_refresh_wifi_direct_state(ugd);
 553         DBG(LOG_INFO, "on pause, wfd status: %d\n", ugd->wfd_status);
 554
 555         if ((WIFI_DIRECT_STATE_DISCOVERING == ugd->wfd_status) &&
 556                 (WIFI_DIRECT_ERROR_NONE != wifi_direct_cancel_discovery())) {
 557                 DBG(LOG_ERROR, "Failed to send cancel discovery state [%d]\n", ugd->wfd_status);
 558                 __FUNC_EXIT__;
 559                 return;
 560         }
 561
 562         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 563
 564         __FUNC_EXIT__;
 565 }
 566
 567 static void on_resume(ui_gadget_h ug, app_control_h control, void *priv)
 568 {
 569         __FUNC_ENTER__;
 570
 571         WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n");
 572         struct ug_data *ugd = priv;
 573         ugd->is_paused = false;
 574         int ret;
 575         wfd_refresh_wifi_direct_state(ugd);
 576         DBG(LOG_INFO, "on resume, status: %d\n", ugd->wfd_status);
 577         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_STOPPED;
 578
 579         elm_genlist_realized_items_update(ugd->genlist);
 580
 581         if (ugd->wfd_status > WIFI_DIRECT_STATE_DEACTIVATED && ugd->wfd_status < WIFI_DIRECT_STATE_CONNECTED) {
 582                 DBG(LOG_INFO, "Start discovery again\n");
 583                 ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL_START;
 584                 ret = wifi_direct_start_discovery_specific_channel(false, 1, WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL);
 585                 if (ret != WIFI_DIRECT_ERROR_NONE) {
 586                         ugd->wfd_discovery_status = WIFI_DIRECT_DISCOVERY_NONE;
 587                         DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", ret);
 588                         wifi_direct_cancel_discovery();
 589                 }
 590         }
 591
 592         __FUNC_EXIT__;
 593 }
 594
 595 static void on_destroy(ui_gadget_h ug, app_control_h control, void *priv)
 596 {
 597         __FUNC_ENTER__;
 598
 599         WFD_RET_IF(ug == NULL || priv == NULL, "The param is NULL\n");
 600
 601         struct ug_data *ugd = priv;
 602         int ret;
 603         WFD_RET_IF(ugd->base == NULL, "The param is NULL\n");
 604
 605 #ifdef MOTION_CONTROL_ENABLE
 606         motion_destroy();
 607 #endif
 608
 609         /* DeInit WiFi Direct */
 610         ret = deinit_wfd_client(ugd);
 611         if (ret) {
 612                 DBG(LOG_ERROR,"Failed to DeInit WiFi Direct");
 613         }
 614
 615         if (ugd->scan_toolbar) {
 616                 wfd_ug_view_refresh_button(ugd->scan_toolbar,
 617                         _("IDS_WIFI_SK4_SCAN"), FALSE);
 618         }
 619
 620         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 621                         __wfd_main_vconf_change_cb);
 622         if (ret == -1) {
 623                 DBG(LOG_ERROR,"Failed to ignore vconf key callback\n");
 624         }
 625
 626 #ifdef WIFI_STATE_CB
 627         ret = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, _wifi_on_state_cb);
 628         if (ret == -1) {
 629                 DBG(LOG_ERROR,"Failed to ignore vconf key callback\n");
 630         }
 631 #endif
 632
 633         ret = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_MODE,
 634                         __wfd_hotspot_mode_vconf_change_cb);
 635         if (ret == -1) {
 636                 DBG(LOG_ERROR,"Failed to ignore vconf key callback MOBILE_HOTSPOT_MODE\n");
 637         }
 638
 639         wfd_ug_view_free_peers(ugd);
 640         WFD_IF_FREE_MEM(ugd->title);
 641         WFD_IF_FREE_MEM(ugd->wfds);
 642         WFD_IF_FREE_MEM(ugd->view_type);
 643
 644         WFD_IF_DEL_OBJ(ugd->bg);
 645
 646 #ifdef WFD_DBUS_LAUNCH
 647         if (ugd->base)
 648                 evas_object_event_callback_del(ugd->base, EVAS_CALLBACK_SHOW, _wfd_init_cb);
 649 #endif
 650         WFD_IF_DEL_OBJ(ugd->base);
 651         DBG(LOG_INFO, "WFD client deregistered");
 652
 653         __FUNC_EXIT__;
 654         return;
 655 }
 656
 657 static void on_message(ui_gadget_h ug, app_control_h msg, app_control_h control, void *priv)
 658 {
 659         __FUNC_ENTER__;
 660         char* app_msg = NULL;
 661         struct ug_data *ugd = priv;
 662
 663         if (!ug || !priv) {
 664                 DBG(LOG_ERROR, "The param is NULL\n");
 665                 return;
 666         }
 667
 668         if (msg) {
 669                 app_control_get_extra_data(msg, "msg", &app_msg);
 670                 DBG(LOG_DEBUG, "Msg from app: %s", app_msg);
 671
 672                 if (!strcmp(app_msg, "destroy")) {
 673                         if(!ugd->rename_popup) {
 674                                 DBG(LOG_INFO, "Destroying UG.");
 675                                 wfd_ug_view_free_peers(ugd);
 676                                 wfd_destroy_ug(ugd);
 677                         }
 678                 }
 679                 WFD_IF_FREE_MEM(app_msg);
 680         }
 681         __FUNC_EXIT__;
 682 }
 683
 684 static void on_event(ui_gadget_h ug, enum ug_event event, app_control_h control, void *priv)
 685 {
 686         __FUNC_ENTER__;
 687
 688         if (!ug || !priv) {
 689                 DBG(LOG_ERROR, "The param is NULL\n");
 690                 return;
 691         }
 692
 693         switch (event) {
 694         case UG_EVENT_LOW_MEMORY:
 695                 DBG(LOG_INFO, "UG_EVENT_LOW_MEMORY\n");
 696                 break;
 697         case UG_EVENT_LOW_BATTERY:
 698                 DBG(LOG_INFO, "UG_EVENT_LOW_BATTERY\n");
 699                 break;
 700         case UG_EVENT_LANG_CHANGE:
 701                 DBG(LOG_INFO, "UG_EVENT_LANG_CHANGE\n");
 702                 break;
 703         case UG_EVENT_ROTATE_PORTRAIT:
 704                 _ctxpopup_move();
 705                 DBG(LOG_INFO, "UG_EVENT_ROTATE_PORTRAIT\n");
 706                 break;
 707         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 708                 DBG(LOG_INFO, "UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN\n");
 709                 break;
 710         case UG_EVENT_ROTATE_LANDSCAPE:
 711                 _ctxpopup_move();
 712                 DBG(LOG_INFO, "UG_EVENT_ROTATE_LANDSCAPE\n");
 713                 break;
 714         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 715                 _ctxpopup_move();
 716                 DBG(LOG_INFO, "UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN\n");
 717                 break;
 718         default:
 719                 DBG(LOG_INFO, "default\n");
 720                 break;
 721         }
 722
 723         __FUNC_EXIT__;
 724 }
 725
 726 static void on_key_event(ui_gadget_h ug, enum ug_key_event event, app_control_h control, void *priv)
 727 {
 728         __FUNC_ENTER__;
 729
 730         if (!ug || !priv) {
 731                 DBG(LOG_ERROR, "The param is NULL\n");
 732                 return;
 733         }
 734
 735         switch (event) {
 736         case UG_KEY_EVENT_END:
 737                 DBG(LOG_INFO, "UG_KEY_EVENT_END\n");
 738                 break;
 739         default:
 740                 break;
 741         }
 742
 743         __FUNC_EXIT__;
 744 }
 745
 746 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 747 {
 748         __FUNC_ENTER__;
 749         struct ug_data *ugd;
 750
 751         if (!ops) {
 752                 DBG(LOG_ERROR, "The param is NULL\n");
 753                 return -1;
 754         }
 755
 756         ugd = calloc(1, sizeof(struct ug_data));
 757         if (ugd == NULL) {
 758                 DBG(LOG_ERROR, "Failed to allocate memory for UG data\n");
 759                 return -1;
 760         }
 761
 762         global_ugd = ugd;
 763
 764         ops->create = on_create;
 765         ops->start = on_start;
 766         ops->pause = on_pause;
 767         ops->resume = on_resume;
 768         ops->destroy = on_destroy;
 769         ops->message = on_message;
 770         ops->event = on_event;
 771         ops->key_event = on_key_event;
 772         ops->priv = ugd;
 773         ops->opt = UG_OPT_INDICATOR_ENABLE;
 774
 775         __FUNC_EXIT__;
 776         return 0;
 777 }
 778
 779 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 780 {
 781         __FUNC_ENTER__;
 782
 783         struct ug_data *ugd;
 784
 785         if (!ops) {
 786                 DBG(LOG_ERROR, "The param is NULL\n");
 787                 return;
 788         }
 789
 790         ugd = ops->priv;
 791
 792         WFD_IF_FREE_MEM(ugd);
 793
 794         __FUNC_EXIT__;
 795 }
 796
 797 UG_MODULE_API int setting_plugin_reset(app_control_h control, void *priv)
 798 {
 799         __FUNC_ENTER__;
 800         int res = -1;
 801         wifi_direct_state_e state;
 802
 803         res = wifi_direct_initialize();
 804         if (res != WIFI_DIRECT_ERROR_NONE) {
 805                 DBG(LOG_ERROR, "Failed to initialize wifi direct. [%d]\n", res);
 806                 return -1;
 807         }
 808
 809         res = wifi_direct_get_state(&state);
 810         if (res != WIFI_DIRECT_ERROR_NONE) {
 811                 DBG(LOG_ERROR, "Failed to get link status. [%d]\n", res);
 812                 return -1;
 813         }
 814
 815         if (state < WIFI_DIRECT_STATE_ACTIVATING) {
 816                 DBG(LOG_INFO, "No need to reset Wi-Fi Direct.\n");
 817         } else {
 818                 /*if connected, disconnect all devices*/
 819                 if (WIFI_DIRECT_STATE_CONNECTED == state) {
 820                         res = wifi_direct_disconnect_all();
 821                         if (res != WIFI_DIRECT_ERROR_NONE) {
 822                                 DBG(LOG_ERROR, "Failed to send disconnection request to all. [%d]\n", res);
 823                                 return -1;
 824                         }
 825                 }
 826
 827                 res = wifi_direct_deactivate();
 828                 if (res != WIFI_DIRECT_ERROR_NONE) {
 829                         DBG(LOG_ERROR, "Failed to reset Wi-Fi Direct. [%d]\n", res);
 830                         return -1;
 831                 }
 832         }
 833
 834         res = wifi_direct_deinitialize();
 835         if (res != WIFI_DIRECT_ERROR_NONE) {
 836                 DBG(LOG_ERROR, "Failed to deinitialize wifi direct. [%d]\n", res);
 837                 return -1;
 838         }
 839
 840         __FUNC_EXIT__;
 841         return 0;
 842 }
 843
 844 UG_MODULE_API int setting_plugin_search_init(app_control_h control, void *priv, char** applocale)
 845 {
 846         __FUNC_ENTER__;
 847
 848         *applocale = strdup("ug-setting-wifidirect-efl");
 849         void *node = NULL;
 850
 851         Eina_List **pplist = (Eina_List**)priv;
 852
 853         node = setting_plugin_search_item_add("IDS_WIFI_BUTTON_MULTI_CONNECT", "viewtype:IDS_WIFI_BUTTON_MULTI_CONNECT", NULL, 5, NULL);
 854         *pplist = eina_list_append(*pplist, node);
 855
 856          __FUNC_EXIT__;
 857         return 0;
 858 }
 859