src/mh_main_ug.c

   1 /*
   2 * ug-mobile-ap
   3 *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.1 (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 #ifndef UG_MODULE_API
  21 #define UG_MODULE_API __attribute__ ((visibility("default")))
  22 #endif
  23
  24 #include "mobile_hotspot.h"
  25 #include "mh_view_main.h"
  26 #include "mh_func_onoff.h"
  27 #include "mh_common_utility.h"
  28 #include "mh_popup.h"
  29 #include "mh_string.h"
  30 #include "mh_view_wifi_setup.h"
  31
  32 static Evas_Object *create_content(mh_appdata_t *ad)
  33 {
  34         __MOBILE_AP_FUNC_ENTER__;
  35
  36         ad->naviframe = _create_naviframe(ad->layout);
  37         _main_draw_contents(ad);
  38
  39         __MOBILE_AP_FUNC_EXIT__;
  40
  41         return ad->naviframe;
  42 }
  43
  44 static void __set_callbacks(mh_appdata_t *ad, void *user_data)
  45 {
  46         DBG("+\n");
  47
  48         int ret;
  49
  50         ret = tethering_set_enabled_cb(ad->handle, TETHERING_TYPE_ALL,
  51                         _enabled_cb, user_data);
  52         if (ret != TETHERING_ERROR_NONE)
  53                 ERR("tethering_set_enabled_cb [0x%X]\n", ret);
  54
  55         ret = tethering_wifi_set_passphrase_changed_cb(ad->handle,
  56                         _passphrase_changed_cb, user_data);
  57         if (ret != TETHERING_ERROR_NONE)
  58                 ERR("tethering_wifi_set_passphrase_changed_cb [0x%X]\n", ret);
  59
  60         ret = tethering_wifi_set_ssid_visibility_changed_cb(ad->handle,
  61                         _visibility_changed_cb, user_data);
  62         if (ret != TETHERING_ERROR_NONE)
  63                 ERR("tethering_wifi_set_ssid_visibility_changed_cb [0x%X]\n", ret);
  64
  65         ret = tethering_wifi_set_security_type_changed_cb(ad->handle,
  66                         _security_type_changed_cb, user_data);
  67         if (ret != TETHERING_ERROR_NONE)
  68                 ERR("tethering_wifi_set_security_type_changed_cb [0x%X]\n", ret);
  69
  70         ret = tethering_set_disabled_cb(ad->handle, TETHERING_TYPE_ALL,
  71                         _disabled_cb, user_data);
  72         if (ret != TETHERING_ERROR_NONE)
  73                 ERR("tethering_set_disabled_cb [0x%X]\n", ret);
  74
  75         ret = tethering_set_connection_state_changed_cb(ad->handle,
  76                         TETHERING_TYPE_ALL,
  77                         _connection_changed_cb, user_data);
  78         if (ret != TETHERING_ERROR_NONE)
  79                 ERR("tethering_set_connection_state_changed_cb [0x%X]\n", ret);
  80
  81         ret = wifi_manager_set_device_state_changed_cb(ad->wifi_handle,
  82                         _wifi_state_changed_cb, user_data);
  83         if (ret != WIFI_MANAGER_ERROR_NONE)
  84                 ERR("wifi_manager_set_device_state_changed_cb [0x%X]\n", ret);
  85         vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
  86                                 _device_name_changed_cb, user_data);
  87
  88         vconf_notify_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
  89                         _handle_network_cellular_state_changed_cb, user_data);
  90
  91         vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
  92                         _handle_usb_status_change, (void *)user_data);
  93
  94         vconf_notify_key_changed(VCONF_KEY_MOBILEAP_SYSPOPUP_RESPONSE,
  95                         _handle_mobileap_syspopup_popup_response, (void *)user_data);
  96
  97         DBG("-\n");
  98 }
  99
 100 static void __unset_callbacks(mh_appdata_t *ad)
 101 {
 102         DBG("+\n");
 103
 104         int ret;
 105
 106         ret = wifi_manager_unset_device_state_changed_cb(ad->wifi_handle);
 107         if (ret != WIFI_MANAGER_ERROR_NONE)
 108                 ERR("wifi_manager_unset_device_state_changed_cb [0x%X]\n", ret);
 109
 110         ret = tethering_unset_connection_state_changed_cb(ad->handle,
 111                         TETHERING_TYPE_ALL);
 112         if (ret != TETHERING_ERROR_NONE)
 113                 ERR("tethering_unset_connection_state_changed_cb[0x%X]\n", ret);
 114
 115         ret = tethering_unset_disabled_cb(ad->handle, TETHERING_TYPE_ALL);
 116         if (ret != TETHERING_ERROR_NONE)
 117                 ERR("tethering_unset_disabled_cb [0x%X]\n", ret);
 118
 119         ret = tethering_wifi_unset_security_type_changed_cb(ad->handle);
 120         if (ret != TETHERING_ERROR_NONE)
 121                 ERR("tethering_wifi_unset_security_type_changed_cb [0x%X]\n", ret);
 122
 123         ret = tethering_wifi_unset_ssid_visibility_changed_cb(ad->handle);
 124         if (ret != TETHERING_ERROR_NONE)
 125                 ERR("tethering_wifi_unset_ssid_visibility_changed_cb [0x%X]\n", ret);
 126
 127         ret = tethering_wifi_unset_passphrase_changed_cb(ad->handle);
 128         if (ret != TETHERING_ERROR_NONE)
 129                 ERR("tethering_wifi_unset_passphrase_changed_cb [0x%X]\n", ret);
 130
 131         ret = tethering_unset_enabled_cb(ad->handle, TETHERING_TYPE_ALL);
 132         if (ret != TETHERING_ERROR_NONE)
 133                 ERR("tethering_unset_enabled [0x%X]\n", ret);
 134
 135         vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 136                         _device_name_changed_cb);
 137
 138         vconf_ignore_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
 139                         _handle_network_cellular_state_changed_cb);
 140
 141         vconf_ignore_key_changed(VCONFKEY_SYSMAN_USB_STATUS, _handle_usb_status_change);
 142
 143         vconf_ignore_key_changed(VCONF_KEY_MOBILEAP_SYSPOPUP_RESPONSE,
 144                         _handle_mobileap_syspopup_popup_response);
 145
 146         DBG("-\n");
 147 }
 148
 149 static void *on_create(ui_gadget_h ug, enum ug_mode mode,
 150                 app_control_h app_control, void *priv)
 151 {
 152         DBG("+\n");
 153
 154         if (!ug || !priv) {
 155                 ERR("The param is NULL\n");
 156                 return NULL;
 157         }
 158
 159         if (mode != UG_MODE_FULLVIEW) {
 160                 ERR("Only Fullview is supported\n");
 161                 return NULL;
 162         }
 163
 164         Evas_Object *layout;
 165         Evas_Object *content;
 166         mh_ugdata_t *ugd;
 167         mh_appdata_t *ad;
 168         int ret;
 169
 170         bindtextdomain(MH_TEXT_DOMAIN, MH_LOCALEDIR);
 171         dgettext(PACKAGE, LOCALEDIR);
 172
 173         ad = (mh_appdata_t *)malloc(sizeof(mh_appdata_t));
 174         if (ad == NULL) {
 175                 ERR("Error!!! failed to allocate memory()\n");
 176                 return NULL;
 177         }
 178         memset(ad, 0x0, sizeof(mh_appdata_t));
 179
 180         ugd = (mh_ugdata_t *)priv;
 181         ugd->ad = ad;
 182         ugd->ug = ug;
 183         ad->gadget = ugd;
 184
 185         _send_signal_qp(QP_SIGNAL_PROGRESS_RESET);
 186
 187         ecore_imf_init();
 188
 189         ret = tethering_create(&ad->handle);
 190 #ifndef TIZEN_FEATURE_EMULATOR
 191         if (ret != TETHERING_ERROR_NONE) {
 192                 ERR("tethering_create is failed : %d\n", ret);
 193                 free(ad);
 194                 ugd->ad = NULL;
 195                 return NULL;
 196         }
 197 #endif
 198
 199         ad->win = ug_get_parent_layout(ug);
 200         if (!ad->win) {
 201                 ERR("ad->win is NULL\n");
 202                 free(ad);
 203                 ugd->ad = NULL;
 204                 return NULL;
 205         }
 206
 207         /* set rotation */
 208         if (elm_win_wm_rotation_supported_get(ad->win)) {
 209                 int rots[4] = {0, 90, 180, 270};
 210                 elm_win_wm_rotation_available_rotations_set(ad->win, (const int *)(&rots), 4);
 211         }
 212
 213         layout = _create_win_layout(ad);
 214         if (layout == NULL) {
 215                 ERR("_create_win_layout is failed\n");
 216                 free(ad);
 217                 ugd->ad = NULL;
 218                 return NULL;
 219         }
 220
 221         content = create_content(ad);
 222         if (content == NULL) {
 223                 ERR("create_content is failed\n");
 224                 free(ad);
 225                 ugd->ad = NULL;
 226                 return NULL;
 227         }
 228
 229         elm_object_part_content_set(layout, "elm.swallow.content", content);
 230         evas_object_show(layout);
 231         ret = connection_create(&ad->conn_handle);
 232         if (ret != CONNECTION_ERROR_NONE)
 233                 ERR("connection_create() is failed : %d\n", ret);
 234
 235         ret = wifi_manager_initialize(&ad->wifi_handle);
 236         if (ret != WIFI_MANAGER_ERROR_NONE)
 237                 ERR("wifi_manager_initialize() is failed : %d\n", ret);
 238
 239         __set_callbacks(ad, (void *)ad);
 240
 241         DBG("-\n");
 242         return layout;
 243 }
 244
 245 static void on_start(ui_gadget_h ug, app_control_h app_control, void *priv)
 246 {
 247         DBG("+\n");
 248
 249         char * viewtype = NULL;
 250
 251         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 252         mh_appdata_t *ad = ugd->ad;
 253
 254         ad->is_foreground = true;
 255
 256         if (_get_list_clients_count(ad) > 0) {
 257 #ifdef TETHERING_DATA_USAGE_SUPPORT
 258                 _start_update_data_packet_usage(ad);
 259 #endif
 260                 if (ad->navi_item)
 261                         _start_update_device_conn_time(ad);
 262         }
 263
 264         app_control_get_extra_data(app_control, "viewtype", &viewtype);
 265
 266         if (viewtype != NULL) {
 267                 if (strcmp(viewtype, "wifisettings") == 0)
 268                         mh_draw_wifi_setup_view(ad);
 269                 g_free(viewtype);
 270         }
 271
 272         DBG("-\n");
 273         return;
 274 }
 275
 276 static void on_pause(ui_gadget_h ug, app_control_h app_control, void *priv)
 277 {
 278         DBG("+\n");
 279
 280         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 281         mh_appdata_t *ad = ugd->ad;
 282
 283 #ifdef TETHERING_DATA_USAGE_SUPPORT
 284         _stop_update_data_packet_usage(ad);
 285 #endif
 286         _stop_update_device_conn_time(ad);
 287         ad->is_foreground = false;
 288
 289         DBG("-\n");
 290 }
 291
 292 static void on_resume(ui_gadget_h ug, app_control_h app_control, void *priv)
 293 {
 294         DBG("+\n");
 295
 296         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 297         mh_appdata_t *ad = ugd->ad;
 298         Elm_Object_Item *item = ad->main.device_item;
 299         GSList *l = NULL;
 300
 301         ad->is_foreground = true;
 302
 303         if (item && elm_genlist_item_expanded_get(item)) {
 304                 for (l = ad->client_list; l != NULL; l = g_slist_next(l)) {
 305                         item = elm_genlist_item_next_get(item);
 306                         elm_genlist_item_fields_update(item, "elm.text", ELM_GENLIST_ITEM_FIELD_TEXT);
 307                 }
 308         }
 309
 310         if (_get_list_clients_count(ad) > 0) {
 311 #ifdef TETHERING_DATA_USAGE_SUPPORT
 312                 _start_update_data_packet_usage(ad);
 313 #endif
 314                 if (ad->navi_item)
 315                         _start_update_device_conn_time(ad);
 316         }
 317         DBG("-\n");
 318 }
 319
 320 static void on_destroy(ui_gadget_h ug, app_control_h app_control, void *priv)
 321 {
 322         DBG("+\n");
 323
 324         if (priv == NULL) {
 325                 ERR("The param is NULL\n");
 326                 return;
 327         }
 328
 329         mh_ugdata_t *ugd = priv;
 330         mh_appdata_t *ad = ugd->ad;
 331         int ret = 0;
 332
 333         if (ad == NULL) {
 334                 ERR("The param is NULL\n");
 335                 return;
 336         }
 337
 338         __unset_callbacks(ad->handle);
 339
 340 #ifdef TETHERING_DATA_USAGE_SUPPORT
 341         _stop_update_data_packet_usage(ad);
 342 #endif
 343         _stop_update_device_conn_time(ad);
 344
 345         if (vconf_set_int(VCONF_MOBILE_AP_CONNECT_USB_POPUP_STATUS, 0) < 0)
 346                 ERR("vconf_set_int is failed\n");
 347
 348         ret = wifi_manager_deinitialize(ad->wifi_handle);
 349         if (ret != WIFI_MANAGER_ERROR_NONE)
 350                 ERR("wifi_manager_deinitialize() is failed : %d\n", ret);
 351
 352         ret = connection_destroy(ad->conn_handle);
 353         if (ret != CONNECTION_ERROR_NONE)
 354                 ERR("connection_destroy() is failed : %d\n", ret);
 355
 356         ret = tethering_destroy(ad->handle);
 357         if (ret != TETHERING_ERROR_NONE)
 358                 ERR("tethering_destroy() is failed : %d\n", ret);
 359
 360         if (ad->layout == NULL) {
 361                 ERR("ad->layout is NULL\n");
 362                 free(ugd->ad);
 363                 ugd->ad = NULL;
 364                 return;
 365         }
 366
 367         if (ad->popup) {
 368                 evas_object_del(ad->popup);
 369                 ad->popup = NULL;
 370         }
 371
 372         if (ad->ps_recheck_timer_id > 0) {
 373                 g_source_remove(ad->ps_recheck_timer_id);
 374                 ad->ps_recheck_timer_id = 0;
 375         }
 376
 377         evas_object_del(ad->bg);
 378         ad->bg = NULL;
 379
 380         evas_object_del(ad->layout);
 381         ad->layout = NULL;
 382
 383         _main_free_genlist_itc(ad);
 384
 385         ecore_imf_shutdown();
 386
 387         free(ugd->ad);
 388         ugd->ad = NULL;
 389
 390         DBG("-\n");
 391         return;
 392 }
 393
 394 static void on_message(ui_gadget_h ug, app_control_h msg,
 395                 app_control_h app_control, void *priv)
 396 {
 397 }
 398
 399 static void on_event(ui_gadget_h ug, enum ug_event event,
 400                 app_control_h app_control, void *priv)
 401 {
 402         __MOBILE_AP_FUNC_ENTER__;
 403
 404         if (!ug || !priv) {
 405                 ERR("The param is NULL\n");
 406                 return;
 407         }
 408
 409         switch (event) {
 410         case UG_EVENT_LOW_MEMORY:
 411                 break;
 412         case UG_EVENT_LOW_BATTERY:
 413                 break;
 414         case UG_EVENT_LANG_CHANGE:
 415                 break;
 416         case UG_EVENT_ROTATE_PORTRAIT:
 417         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 418                 DBG("UG_EVENT_ROTATE_PORTRAIT[_UPSIDEDOWN]\n");
 419                 break;
 420         case UG_EVENT_ROTATE_LANDSCAPE:
 421         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 422                 DBG("UG_EVENT_ROTATE_LANDSCAPE[_UPSIDEDOWN]\n");
 423                 break;
 424         default:
 425                 break;
 426         }
 427
 428         __MOBILE_AP_FUNC_EXIT__;
 429 }
 430
 431 static void on_key_event(ui_gadget_h ug, enum ug_key_event event,
 432                 app_control_h app_control, void *priv)
 433 {
 434         __MOBILE_AP_FUNC_ENTER__;
 435
 436         if (priv == NULL || ug == NULL) {
 437                 ERR("The param is NULL\n");
 438                 return;
 439         }
 440
 441         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 442         mh_appdata_t *ad = ugd->ad;
 443
 444         if (ad == NULL) {
 445                 ERR("ad is NULL\n");
 446                 return;
 447         }
 448
 449         switch (event) {
 450         case UG_KEY_EVENT_END:
 451                 DBG("UG_KEY_EVENT_END is received : %p\n", ad->popup);
 452                 if (NULL == ad->popup)
 453                         ug_destroy_me(ug);
 454                 else
 455                         _destroy_popup(ad);
 456                 break;
 457
 458         default:
 459                 break;
 460         }
 461
 462         __MOBILE_AP_FUNC_EXIT__;
 463 }
 464
 465 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 466 {
 467         DBG("+\n");
 468
 469         if (!ops) {
 470                 ERR("The param is NULL\n");
 471                 return -1;
 472         }
 473
 474         mh_ugdata_t *ugd;
 475         ugd = calloc(1, sizeof(mh_ugdata_t));
 476         if (!ugd) {
 477                 ERR("Quit : calloc failed(ugd)\n");
 478                 return -1;
 479         }
 480
 481         ops->create = on_create;
 482         ops->start = on_start;
 483         ops->pause = on_pause;
 484         ops->resume = on_resume;
 485         ops->destroy = on_destroy;
 486         ops->message = on_message;
 487         ops->event = on_event;
 488         ops->key_event = on_key_event;
 489         ops->priv = ugd;
 490         ops->opt = UG_OPT_INDICATOR_ENABLE;
 491
 492         return 0;
 493 }
 494
 495 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 496 {
 497         DBG("+\n");
 498
 499         if (!ops) {
 500                 ERR("The param is NULL\n");
 501                 return;
 502         }
 503
 504         mh_ugdata_t *ugd = (mh_ugdata_t *)ops->priv;
 505
 506         if (ugd)
 507                 free(ugd);
 508 }
 509
 510 static void __mh_reset_vconf(tethering_h handle)
 511 {
 512         int ret = 0;
 513
 514         ret = vconf_set_int(VCONF_MOBILE_AP_WIFI_POPUP_CHECKBOX_STATUS, 0);
 515         if (ret != 0)
 516                 ERR("vconf_set_int failed\n");
 517
 518         ret = vconf_set_int(VCONF_MOBILE_AP_BT_POPUP_CHECKBOX_STATUS, 0);
 519         if (ret != 0)
 520                 ERR("vconf_set_int failed\n");
 521
 522         ret = vconf_set_int(VCONF_MOBILE_AP_USB_POPUP_CHECKBOX_STATUS, 0);
 523         if (ret != 0)
 524                 ERR("vconf_set_int failed\n");
 525
 526         ret = vconf_set_int(VCONF_MOBILE_AP_PREV_WIFI_STATUS, 0);
 527         if (ret != 0)
 528                 ERR("vconf_set_int failed\n");
 529
 530         ret = vconf_set_int(VCONF_MOBILE_AP_CONNECT_USB_POPUP_STATUS, 0);
 531         if (ret != 0)
 532                 ERR("vconf_set_int is failed\n");
 533
 534         ret = tethering_wifi_set_ssid_visibility(handle, true);
 535         if (ret != TETHERING_ERROR_NONE)
 536                 ERR("tethering_wifi_set_ssid_visibility failed\n");
 537
 538         ret = tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK);
 539         if (ret != TETHERING_ERROR_NONE)
 540                 ERR("tethering_wifi_set_security_type failed\n");
 541
 542         return;
 543 }
 544
 545 UG_MODULE_API int setting_plugin_reset(app_control_h app_control, void *priv)
 546 {
 547         DBG("+\n");
 548
 549         int ret = -1;
 550         tethering_h handle = NULL;
 551
 552         if (tethering_create(&handle) != TETHERING_ERROR_NONE) {
 553                 ERR("tethering_create failed\n");
 554                 return -1;
 555         }
 556
 557         if (tethering_is_enabled(handle, TETHERING_TYPE_USB) ||
 558                         tethering_is_enabled(handle, TETHERING_TYPE_WIFI) ||
 559                         tethering_is_enabled(handle, TETHERING_TYPE_BT)) {
 560                 ret = tethering_disable(handle, TETHERING_TYPE_ALL);
 561                 if (ret != TETHERING_ERROR_NONE) {
 562                         ERR("tethering_disable failed : %d\n", ret);
 563                         tethering_destroy(handle);
 564                         return -1;
 565                 }
 566
 567         }
 568
 569         __mh_reset_vconf(handle);
 570
 571         tethering_destroy(handle);
 572
 573         return 0;
 574 }