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