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