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