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