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