ug-wifidirect/src/wfd_ug.c

   1 /*
   2 *  WiFi-Direct UG
   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
  21 #ifndef UG_MODULE_API
  22 #define UG_MODULE_API __attribute__ ((visibility("default")))
  23 #endif
  24
  25
  26 #include <sys/time.h>
  27 #include <libintl.h>
  28 #include <sys/utsname.h>
  29
  30 #include <Elementary.h>
  31 #include <ui-gadget-module.h>
  32 #include <wifi-direct.h>
  33
  34 #include "wfd_ug.h"
  35 #include "wfd_ug_view.h"
  36 #include "wfd_client.h"
  37
  38 void initialize_gen_item_class();
  39
  40 struct ug_data *global_ugd = NULL;
  41
  42 struct ug_data *wfd_get_ug_data()
  43 {
  44         return global_ugd;
  45 }
  46
  47
  48 static Evas_Object *_create_bg(Evas_Object *parent, char *style)
  49 {
  50     __FUNC_ENTER__;
  51     Evas_Object *bg;
  52
  53     bg = elm_bg_add(parent);
  54     evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  55     elm_object_style_set(bg, style);
  56     elm_win_resize_object_add(parent, bg);
  57     evas_object_show(bg);
  58
  59     __FUNC_EXIT__;
  60     return bg;
  61 }
  62
  63 static Evas_Object *_create_fullview(Evas_Object *parent, struct ug_data *ugd)
  64 {
  65     __FUNC_ENTER__;
  66     Evas_Object *base;
  67
  68     if(parent == NULL)
  69     {
  70         DBG(LOG_ERROR, "Incorrenct parameter");
  71         return NULL;
  72     }
  73
  74     /* Create Full view */
  75     base = elm_layout_add(parent);
  76     if(!base)
  77     {
  78         DBG(LOG_ERROR, "Failed to add layout");
  79         return NULL;
  80     }
  81
  82     elm_layout_theme_set(base, "layout", "application", "default");
  83     evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  84     evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
  85
  86     __FUNC_EXIT__;
  87     return base;
  88 }
  89
  90 static Evas_Object *_create_frameview(Evas_Object *parent, struct ug_data *ugd)
  91 {
  92     __FUNC_ENTER__;
  93     Evas_Object *base;
  94
  95     if(parent == NULL)
  96     {
  97         DBG(LOG_ERROR, "Incorrenct parameter");
  98         return NULL;
  99     }
 100
 101     /* Create Frame view */
 102     base = elm_layout_add(parent);
 103     if(!base)
 104     {
 105         DBG(LOG_ERROR, "Failed to add layout");
 106         return NULL;
 107     }
 108
 109     elm_layout_theme_set(base, "layout", "application", "default");
 110     evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 111     evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
 112
 113     __FUNC_EXIT__;
 114     return base;
 115 }
 116
 117
 118 void destroy_wfd_ug_view(void *data)
 119 {
 120     __FUNC_ENTER__;
 121
 122     struct ug_data *ugd = (struct ug_data*) data;
 123
 124     if(ugd->genlist)
 125     {
 126         evas_object_del(ugd->genlist);
 127         ugd->genlist = NULL;
 128     }
 129
 130     if(ugd->naviframe)
 131     {
 132         evas_object_del(ugd->naviframe);
 133         ugd->naviframe = NULL;
 134     }
 135
 136     __FUNC_EXIT__;
 137 }
 138
 139 static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h service,
 140                        void *priv)
 141 {
 142     __FUNC_ENTER__;
 143     struct ug_data *ugd;
 144     int res = 0;
 145
 146     if (!ug || !priv)
 147         return NULL;
 148
 149     ugd = priv;
 150     ugd->ug = ug;
 151
 152     bindtextdomain(PACKAGE, LOCALEDIR);
 153
 154     ugd->win = ug_get_window();
 155     if (!ugd->win)
 156         return NULL;
 157
 158     if (mode == UG_MODE_FULLVIEW)
 159         ugd->base = _create_fullview(ugd->win, ugd);
 160     else
 161         ugd->base = _create_frameview(ugd->win, ugd);
 162
 163     if(ugd->base)
 164     {
 165         ugd->bg = _create_bg(ugd->win, "group_list");
 166         elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg);
 167     }
 168     else
 169     {
 170         DBG(LOG_ERROR, "Failed to create base layout\n");
 171         return NULL;
 172     }
 173
 174     wfd_get_vconf_status(ugd);
 175
 176     initialize_gen_item_class();
 177
 178     res = init_wfd_client(ugd);
 179     if(res != 0)
 180     {
 181         DBG(LOG_ERROR, "Failed to initialize WFD client library\n");
 182         wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_PROBLEM_WITH_WFD"), POPUP_TYPE_TERMINATE);
 183     }
 184
 185     create_wfd_ug_view(ugd);
 186
 187     wfd_ug_view_refresh_glitem(ugd->head);
 188     if (ugd->scan_btn) {
 189         wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), TRUE);
 190     }
 191
 192     if(ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING)
 193     {
 194         wfd_ug_get_discovered_peers(ugd);
 195     }
 196
 197     if(ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED)
 198     {
 199         wfd_ug_get_connected_peers(ugd);
 200     }
 201
 202     wfd_ug_view_update_peers(ugd);
 203
 204     if (ugd->wfd_status == WIFI_DIRECT_STATE_ACTIVATED)
 205     {
 206         res = wifi_direct_start_discovery(FALSE, 0);
 207         if(res != WIFI_DIRECT_ERROR_NONE)
 208         {
 209             DBG(LOG_ERROR, "Failed to start discovery. [%d]\n", res);
 210         }
 211         DBG(LOG_VERBOSE, "Discovery is started\n");
 212     }
 213
 214     evas_object_show(ugd->base);
 215
 216     __FUNC_EXIT__;
 217     return ugd->base;
 218 }
 219
 220 static void on_start(ui_gadget_h ug, service_h service, void *priv)
 221 {
 222     __FUNC_ENTER__;
 223     struct ug_data *ugd;
 224     int res;
 225
 226     if (!ug || !priv)
 227         return;
 228
 229     ugd = priv;
 230
 231     struct utsname kernel_info;
 232     res = uname(&kernel_info);
 233     if(res != 0)
 234     {
 235         DBG(LOG_ERROR, "Failed to detect target type\n");
 236     }
 237     else
 238     {
 239         DBG(LOG_VERBOSE, "HW ID of this device [%s]\n", kernel_info.machine);
 240         if(strncmp(kernel_info.machine, "arm", 3) != 0)
 241         {
 242             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_NOT_SUPPORTED_DEVICE"), POPUP_TYPE_TERMINATE);
 243             return;
 244         }
 245     }
 246     __FUNC_EXIT__;
 247 }
 248
 249 static void on_pause(ui_gadget_h ug, service_h service, void *priv)
 250 {
 251     __FUNC_ENTER__;
 252     __FUNC_EXIT__;
 253 }
 254
 255 static void on_resume(ui_gadget_h ug, service_h service, void *priv)
 256 {
 257     __FUNC_ENTER__;
 258     __FUNC_EXIT__;
 259 }
 260
 261 static void on_destroy(ui_gadget_h ug, service_h service, void *priv)
 262 {
 263     __FUNC_ENTER__;
 264
 265     if (!ug || !priv)
 266     {
 267         DBG(LOG_ERROR, "The param is NULL\n");
 268         return;
 269     }
 270
 271     struct ug_data *ugd = priv;
 272     if (ugd == NULL || ugd->base == NULL)
 273     {
 274         DBG(LOG_ERROR, "The param is NULL\n");
 275         return;
 276     }
 277
 278     deinit_wfd_client(ugd);
 279     DBG(LOG_VERBOSE, "WFD client deregistered");
 280
 281     destroy_wfd_ug_view(ugd);
 282     DBG(LOG_VERBOSE, "Destroying About item");
 283
 284     wfd_ug_view_free_peers(ugd);
 285
 286     DBG(LOG_VERBOSE, "WFD client deregistered");
 287     if(ugd->bg)
 288     {
 289         evas_object_del(ugd->bg);
 290         ugd->bg = NULL;
 291     }
 292     DBG(LOG_VERBOSE, "WFD client deregistered");
 293
 294     if(ugd->base)
 295     {
 296         evas_object_del(ugd->base);
 297         ugd->base = NULL;
 298     }
 299
 300     __FUNC_EXIT__;
 301     return;
 302 }
 303
 304 static void on_message(ui_gadget_h ug, service_h msg, service_h service,
 305                        void *priv)
 306 {
 307     __FUNC_ENTER__;
 308     __FUNC_EXIT__;
 309 }
 310
 311 static void on_event(ui_gadget_h ug, enum ug_event event, service_h service,
 312                      void *priv)
 313 {
 314     __FUNC_ENTER__;
 315
 316     if (!ug || !priv)
 317     {
 318         DBG(LOG_ERROR, "The param is NULL\n");
 319         return;
 320     }
 321
 322     switch (event)
 323     {
 324         case UG_EVENT_LOW_MEMORY:
 325             DBG(LOG_VERBOSE, "UG_EVENT_LOW_MEMORY\n");
 326             break;
 327         case UG_EVENT_LOW_BATTERY:
 328             DBG(LOG_VERBOSE, "UG_EVENT_LOW_BATTERY\n");
 329             break;
 330         case UG_EVENT_LANG_CHANGE:
 331             DBG(LOG_VERBOSE, "UG_EVENT_LANG_CHANGE\n");
 332             break;
 333         case UG_EVENT_ROTATE_PORTRAIT:
 334             DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT\n");
 335             break;
 336         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 337             DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN\n");
 338             break;
 339         case UG_EVENT_ROTATE_LANDSCAPE:
 340             DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE\n");
 341             break;
 342         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 343             DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN\n");
 344             break;
 345         default:
 346             DBG(LOG_VERBOSE, "default\n");
 347             break;
 348     }
 349
 350     __FUNC_EXIT__;
 351 }
 352
 353 static void on_key_event(ui_gadget_h ug, enum ug_key_event event,
 354                          service_h service, void *priv)
 355 {
 356     __FUNC_ENTER__;
 357
 358     if (!ug || !priv)
 359     {
 360         DBG(LOG_ERROR, "The param is NULL\n");
 361         return;
 362     }
 363
 364     switch (event)
 365     {
 366         case UG_KEY_EVENT_END:
 367             DBG(LOG_VERBOSE, "UG_KEY_EVENT_END\n");
 368             break;
 369         default:
 370             break;
 371     }
 372
 373     __FUNC_EXIT__;
 374 }
 375
 376 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 377 {
 378     __FUNC_ENTER__;
 379     struct ug_data *ugd;
 380
 381     if (!ops)
 382     {
 383         DBG(LOG_ERROR, "The param is NULL\n");
 384         return -1;
 385     }
 386
 387     ugd = calloc(1, sizeof(struct ug_data));
 388     if (ugd == NULL)
 389     {
 390         DBG(LOG_ERROR, "Failed to allocate memory for UG data\n");
 391         return -1;
 392     }
 393
 394     global_ugd = ugd;
 395
 396     ops->create = on_create;
 397     ops->start = on_start;
 398     ops->pause = on_pause;
 399     ops->resume = on_resume;
 400     ops->destroy = on_destroy;
 401     ops->message = on_message;
 402     ops->event = on_event;
 403     ops->key_event = on_key_event;
 404     ops->priv = ugd;
 405     ops->opt = UG_OPT_INDICATOR_ENABLE;
 406
 407     __FUNC_EXIT__;
 408     return 0;
 409 }
 410
 411 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 412 {
 413     __FUNC_ENTER__;
 414
 415     struct ug_data *ugd;
 416
 417     if (!ops)
 418     {
 419         DBG(LOG_ERROR, "The param is NULL\n");
 420         return;
 421     }
 422
 423     ugd = ops->priv;
 424
 425     if (ugd)
 426         free(ugd);
 427
 428     __FUNC_EXIT__;
 429 }