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 "mobile_hotspot.h"
  25 #include "mh_view_main.h"
  26 #include "mh_func_onoff.h"
  27 #include "mh_common_utility.h"
  28
  29 static Evas_Object *create_content(mh_appdata_t *ad)
  30 {
  31         __MOBILE_AP_FUNC_ENTER__;
  32
  33         ad->naviframe = _create_naviframe(ad->layout);
  34         ap_draw_contents(ad);
  35
  36         __MOBILE_AP_FUNC_EXIT__;
  37
  38         return ad->naviframe;
  39 }
  40
  41 static void __set_callbacks(tethering_h handle, void *user_data)
  42 {
  43         int ret;
  44
  45         ret = tethering_set_enabled_cb(handle, TETHERING_TYPE_ALL,
  46                         _enabled_cb, user_data);
  47         if (ret != TETHERING_ERROR_NONE)
  48                 ERR("tethering_set_enabled_cb [0x%X]\n", ret);
  49
  50         ret = tethering_set_disabled_cb(handle, TETHERING_TYPE_ALL,
  51                         _disabled_cb, user_data);
  52         if (ret != TETHERING_ERROR_NONE)
  53                 ERR("tethering_set_disabled_cb [0x%X]\n", ret);
  54
  55         ret = tethering_set_connection_state_changed_cb(handle,
  56                         TETHERING_TYPE_ALL,
  57                         _connection_changed_cb, user_data);
  58         if (ret != TETHERING_ERROR_NONE)
  59                 ERR("tethering_set_connection_state_changed_cb [0x%X]\n", ret);
  60 }
  61
  62 static void __unset_callbacks(tethering_h handle)
  63 {
  64         int ret;
  65
  66         ret = tethering_unset_connection_state_changed_cb(handle,
  67                         TETHERING_TYPE_ALL);
  68         if (ret != TETHERING_ERROR_NONE)
  69                 ERR("tethering_unset_connection_state_changed_cb[0x%X]\n", ret);
  70
  71         ret = tethering_unset_disabled_cb(handle, TETHERING_TYPE_ALL);
  72         if (ret != TETHERING_ERROR_NONE)
  73                 ERR("tethering_unset_disabled_cb [0x%X]\n", ret);
  74
  75         ret = tethering_unset_enabled_cb(handle, TETHERING_TYPE_ALL);
  76         if (ret != TETHERING_ERROR_NONE)
  77                 ERR("tethering_unset_enabled [0x%X]\n", ret);
  78 }
  79
  80 static void *on_create(ui_gadget_h ug, enum ug_mode mode,
  81                 service_h service, void *priv)
  82 {
  83         __MOBILE_AP_FUNC_ENTER__;
  84
  85         if (!ug || !priv) {
  86                 ERR("The param is NULL\n");
  87                 return NULL;
  88         }
  89
  90         if (mode != UG_MODE_FULLVIEW) {
  91                 ERR("Only Fullview is supported\n");
  92                 return NULL;
  93         }
  94
  95         Evas_Object *layout;
  96         Evas_Object *content;
  97         mh_ugdata_t *ugd;
  98         mh_appdata_t *ad;
  99         int ret;
 100
 101         bindtextdomain(MH_TEXT_DOMAIN, MH_LOCALEDIR);
 102         dgettext(PACKAGE, LOCALEDIR);
 103
 104         ad = (mh_appdata_t *)malloc(sizeof(mh_appdata_t));
 105         if (ad == NULL) {
 106                 // TODO review this
 107                 ERR("Error!!! failed to allocate memory()\n");
 108                 return NULL;
 109         }
 110         memset(ad, 0x0, sizeof(mh_appdata_t));
 111
 112         ugd = (mh_ugdata_t *)priv;
 113         ugd->ad = ad;
 114         ugd->ug = ug;
 115         ad->gadget = ugd;
 116
 117         ecore_imf_init();
 118
 119         ret = tethering_create(&ad->handle);
 120         if (ret != TETHERING_ERROR_NONE) {
 121                 ERR("tethering_create is failed : %d\n", ret);
 122                 free(ad);
 123                 ugd->ad = NULL;
 124                 return NULL;
 125         }
 126
 127         ad->win = ug_get_parent_layout(ug);
 128         if (!ad->win) {
 129                 ERR("ad->win is NULL\n");
 130                 free(ad);
 131                 ugd->ad = NULL;
 132                 return NULL;
 133         }
 134
 135         layout = _create_win_layout(ad);
 136         if (layout == NULL) {
 137                 ERR("_create_win_layout is failed\n");
 138                 free(ad);
 139                 ugd->ad = NULL;
 140                 return NULL;
 141         }
 142
 143         content = create_content(ad);
 144         if (content == NULL) {
 145                 ERR("create_content is failed\n");
 146                 free(ad);
 147                 ugd->ad = NULL;
 148                 return NULL;
 149         }
 150
 151         elm_object_part_content_set(layout, "elm.swallow.content", content);
 152         evas_object_show(layout);
 153
 154         ret = connection_create(&ad->conn_handle);
 155         if (ret != CONNECTION_ERROR_NONE) {
 156                 ERR("connection_create() is failed : %d\n", ret);
 157         }
 158
 159         ret = wifi_initialize();
 160         if (ret != WIFI_ERROR_NONE) {
 161                 ERR("wifi_initialize() is failed : %d\n", ret);
 162         }
 163
 164         __set_callbacks(ad->handle, (void *)ad);
 165
 166         __MOBILE_AP_FUNC_EXIT__;
 167         return layout;
 168 }
 169
 170 static void on_start(ui_gadget_h ug, service_h service, void *priv)
 171 {
 172 }
 173
 174 static void on_pause(ui_gadget_h ug, service_h service, void *priv)
 175 {
 176
 177 }
 178
 179 static void on_resume(ui_gadget_h ug, service_h service, void *priv)
 180 {
 181
 182 }
 183
 184 static void on_destroy(ui_gadget_h ug, service_h service, void *priv)
 185 {
 186         __MOBILE_AP_FUNC_ENTER__;
 187
 188         if (priv == NULL) {
 189                 ERR("The param is NULL\n");
 190                 return;
 191         }
 192
 193         mh_ugdata_t *ugd = priv;
 194         mh_appdata_t *ad = ugd->ad;
 195         int ret = 0;
 196
 197         if (ad == NULL) {
 198                 ERR("The param is NULL\n");
 199                 return;
 200         }
 201
 202         __unset_callbacks(ad->handle);
 203         _stop_update_data_packet_usage(ad);
 204
 205         ret = wifi_deinitialize();
 206         if (ret != WIFI_ERROR_NONE) {
 207                 ERR("wifi_deinitialize() is failed : %d\n", ret);
 208         }
 209
 210         ret = connection_destroy(ad->conn_handle);
 211         if (ret != CONNECTION_ERROR_NONE) {
 212                 ERR("connection_destroy() is failed : %d\n", ret);
 213         }
 214
 215         ret = tethering_destroy(ad->handle);
 216         if (ret != TETHERING_ERROR_NONE) {
 217                 ERR("tethering_destroy() is failed : %d\n", ret);
 218         }
 219
 220         if (ad->layout == NULL) {
 221                 ERR("ad->layout is NULL\n");
 222                 free(ugd->ad);
 223                 ugd->ad = NULL;
 224                 return;
 225         }
 226
 227         ap_callback_del(ad);
 228         if (ad->popup) {
 229                 evas_object_del(ad->popup);
 230                 ad->popup = NULL;
 231         }
 232
 233         evas_object_del(ad->bg);
 234         ad->bg = NULL;
 235
 236         evas_object_del(ad->layout);
 237         ad->layout = NULL;
 238
 239         ecore_imf_shutdown();
 240
 241         free(ugd->ad);
 242         ugd->ad = NULL;
 243
 244         __MOBILE_AP_FUNC_EXIT__;
 245         return;
 246 }
 247
 248 static void on_message(ui_gadget_h ug, service_h msg,
 249                 service_h service, void *priv)
 250 {
 251 }
 252
 253 static void __rotate_changed_cb(mh_appdata_t *ad, enum ug_event rotate_state)
 254 {
 255         if (ad == NULL) {
 256                 ERR("ad is NULL\n");
 257                 return;
 258         }
 259
 260         Elm_Object_Item *top_navi_it = NULL;
 261         mh_wifi_setting_view_t *st = &ad->setup;
 262
 263         ad->rotate_state = rotate_state;
 264
 265         top_navi_it = elm_naviframe_top_item_get(ad->naviframe);
 266         if (top_navi_it == NULL) {
 267                 ERR("elm_naviframe_top_item_get returns NULL\n");
 268                 return;
 269         }
 270
 271         if (top_navi_it != st->navi_it) {
 272                 return;
 273         }
 274
 275         if (rotate_state == UG_EVENT_ROTATE_PORTRAIT ||
 276                         rotate_state == UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN) {
 277                 DBG("Naviframe title is shown\n");
 278                 elm_naviframe_item_title_visible_set(st->navi_it,
 279                                 EINA_TRUE);
 280         } else if (rotate_state == UG_EVENT_ROTATE_LANDSCAPE ||
 281                         rotate_state == UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN) {
 282                 if (ad->imf_state == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
 283                         DBG("Naviframe title is hided\n");
 284                         elm_naviframe_item_title_visible_set(st->navi_it,
 285                                         EINA_FALSE);
 286                 }
 287         } else {
 288                 ERR("Unknown rotate_state : %d\n", rotate_state);
 289         }
 290
 291         return;
 292 }
 293
 294 static void on_event(ui_gadget_h ug, enum ug_event event,
 295                 service_h service, void *priv)
 296 {
 297         __MOBILE_AP_FUNC_ENTER__;
 298
 299         if (!ug || !priv) {
 300                 ERR("The param is NULL\n");
 301                 return;
 302         }
 303
 304         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 305         mh_appdata_t *ad = ugd->ad;
 306
 307         switch (event) {
 308         case UG_EVENT_LOW_MEMORY:
 309                 DBG("UG_EVENT_LOW_MEMORY\n");
 310                 break;
 311         case UG_EVENT_LOW_BATTERY:
 312                 DBG("UG_EVENT_LOW_BATTERY\n");
 313                 break;
 314         case UG_EVENT_LANG_CHANGE:
 315                 DBG("UG_EVENT_LANG_CHANGE\n");
 316                 break;
 317         case UG_EVENT_ROTATE_PORTRAIT:
 318         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 319                 DBG("UG_EVENT_ROTATE_PORTRAIT[_UPSIDEDOWN]\n");
 320                 __rotate_changed_cb(ad, event);
 321                 break;
 322         case UG_EVENT_ROTATE_LANDSCAPE:
 323         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 324                 DBG("UG_EVENT_ROTATE_LANDSCAPE[_UPSIDEDOWN]\n");
 325                 __rotate_changed_cb(ad, event);
 326                 break;
 327         default:
 328                 DBG("default\n");
 329                 break;
 330         }
 331
 332         __MOBILE_AP_FUNC_EXIT__;
 333 }
 334
 335 static void on_key_event(ui_gadget_h ug, enum ug_key_event event,
 336                 service_h service, void *priv)
 337 {
 338         __MOBILE_AP_FUNC_ENTER__;
 339
 340         if (priv == NULL || ug == NULL) {
 341                 ERR("The param is NULL\n");
 342                 return;
 343         }
 344
 345         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 346         mh_appdata_t *ad = ugd->ad;
 347
 348         if (ad == NULL) {
 349                 ERR("ad is NULL\n");
 350                 return;
 351         }
 352
 353         switch (event) {
 354         case UG_KEY_EVENT_END:
 355                 DBG("UG_KEY_EVENT_END is received : %p\n", ad->popup);
 356                 if (NULL == ad->popup)
 357                         ug_destroy_me(ug);
 358                 else
 359                         _destroy_popup(ad);
 360                 break;
 361
 362         default:
 363                 break;
 364         }
 365
 366         __MOBILE_AP_FUNC_EXIT__;
 367 }
 368
 369 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 370 {
 371         __MOBILE_AP_FUNC_ENTER__;
 372
 373         if (!ops) {
 374                 ERR("The param is NULL\n");
 375                 return -1;
 376         }
 377
 378         mh_ugdata_t *ugd;
 379         ugd = calloc(1, sizeof(mh_ugdata_t));
 380         if (!ugd) {
 381                 ERR("Quit : calloc failed(ugd)\n");
 382                 return -1;
 383         }
 384
 385         ops->create = on_create;
 386         ops->start = on_start;
 387         ops->pause = on_pause;
 388         ops->resume = on_resume;
 389         ops->destroy = on_destroy;
 390         ops->message = on_message;
 391         ops->event = on_event;
 392         ops->key_event = on_key_event;
 393         ops->priv = ugd;
 394         ops->opt = UG_OPT_INDICATOR_ENABLE;
 395
 396         __MOBILE_AP_FUNC_EXIT__;
 397
 398         return 0;
 399 }
 400
 401 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 402 {
 403         __MOBILE_AP_FUNC_ENTER__;
 404
 405         if (!ops) {
 406                 ERR("The param is NULL\n");
 407                 return;
 408         }
 409
 410         mh_ugdata_t *ugd = (mh_ugdata_t *)ops->priv;
 411
 412         if (ugd)
 413                 free(ugd);
 414
 415         __MOBILE_AP_FUNC_EXIT__;
 416 }
 417
 418 static void __mh_reset_vconf(tethering_h handle)
 419 {
 420         int ret = 0;
 421
 422         ret = vconf_set_int(VCONF_MOBILE_AP_PREV_WIFI_STATUS, 0);
 423         if (ret != 0)
 424                 ERR("vconf_set_int failed\n");
 425
 426         ret = tethering_wifi_set_ssid_visibility(handle, true);
 427         if (ret != TETHERING_ERROR_NONE)
 428                 ERR("tethering_wifi_set_ssid_visibility failed\n");
 429
 430         ret = tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_NONE);
 431         if (ret != TETHERING_ERROR_NONE)
 432                 ERR("tethering_wifi_set_security_type failed\n");
 433
 434         return;
 435 }
 436
 437 UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
 438 {
 439         __MOBILE_AP_FUNC_ENTER__;
 440
 441         int ret = -1;
 442         tethering_h handle = NULL;
 443
 444         if (tethering_create(&handle) != TETHERING_ERROR_NONE) {
 445                 ERR("tethering_create failed\n");
 446                 return -1;
 447         }
 448
 449         if (tethering_is_enabled(handle, TETHERING_TYPE_USB) ||
 450                         tethering_is_enabled(handle, TETHERING_TYPE_WIFI) ||
 451                         tethering_is_enabled(handle, TETHERING_TYPE_BT)) {
 452                 ret = tethering_disable(handle, TETHERING_TYPE_ALL);
 453                 if (ret != TETHERING_ERROR_NONE) {
 454                         ERR("tethering_disable failed : %d\n", ret);
 455                         tethering_destroy(handle);
 456                         return -1;
 457                 }
 458
 459         }
 460
 461         __mh_reset_vconf(handle);
 462
 463         tethering_destroy(handle);
 464
 465         __MOBILE_AP_FUNC_EXIT__;
 466
 467         return 0;
 468 }