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