ug-wifidirect/src/wfd_ug.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * This file implements Wi-Fi direct UI Gadget.
  19  *
  20  * @file    wfd_ug.c
  21  * @author  Gibyoung Kim (lastkgb.kim@samsung.com)
  22  * @version 0.1
  23  */
  24
  25
  26 #ifndef UG_MODULE_API
  27 #define UG_MODULE_API __attribute__ ((visibility("default")))
  28 #endif
  29
  30
  31 #include <sys/time.h>
  32 #include <libintl.h>
  33 #include <sys/utsname.h>
  34
  35 #include <Elementary.h>
  36 #include <ui-gadget-module.h>
  37 #include <wifi-direct.h>
  38
  39 #include "wfd_ug.h"
  40 #include "wfd_ug_view.h"
  41 #include "wfd_client.h"
  42
  43
  44 static Evas_Object *_create_bg(Evas_Object *parent, char *style)
  45 {
  46     __FUNC_ENTER__;
  47     Evas_Object *bg;
  48
  49     bg = elm_bg_add(parent);
  50     evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  51     elm_object_style_set(bg, style);
  52     elm_win_resize_object_add(parent, bg);
  53     evas_object_show(bg);
  54
  55     __FUNC_EXIT__;
  56     return bg;
  57 }
  58
  59 static Evas_Object *_create_fullview(Evas_Object *parent, struct ug_data *ugd)
  60 {
  61     __FUNC_ENTER__;
  62     Evas_Object *base;
  63
  64     if (parent == NULL)
  65     {
  66         DBG(LOG_ERROR, "Incorrenct parameter");
  67         return NULL;
  68     }
  69
  70     base = elm_layout_add(parent);
  71     if (!base)
  72     {
  73         DBG(LOG_ERROR, "Failed to add layout");
  74         return NULL;
  75     }
  76
  77     elm_layout_theme_set(base, "layout", "application", "default");
  78     evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  79     evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
  80
  81     __FUNC_EXIT__;
  82     return base;
  83 }
  84
  85 static Evas_Object *_create_frameview(Evas_Object * parent, struct ug_data *ugd)
  86 {
  87     __FUNC_ENTER__;
  88     Evas_Object *base;
  89
  90     if (parent == NULL)
  91     {
  92         DBG(LOG_ERROR, "Incorrenct parameter");
  93         return NULL;
  94     }
  95
  96     base = elm_layout_add(parent);
  97     if (!base)
  98     {
  99         DBG(LOG_ERROR, "Failed to add layout");
 100         return NULL;
 101     }
 102
 103     elm_layout_theme_set(base, "layout", "application", "default");
 104     evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 105     evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
 106
 107     __FUNC_EXIT__;
 108     return base;
 109 }
 110
 111 static void *on_create(struct ui_gadget *ug, enum ug_mode mode, bundle * data,
 112                        void *priv)
 113 {
 114     __FUNC_ENTER__;
 115     struct ug_data *ugd;
 116
 117     if (!ug || !priv)
 118         return NULL;
 119
 120     ugd = priv;
 121     ugd->ug = ug;
 122
 123     bindtextdomain(PACKAGE, LOCALEDIR);
 124
 125     ugd->win = ug_get_parent_layout(ug);
 126     if (!ugd->win)
 127         return NULL;
 128
 129     if (mode == UG_MODE_FULLVIEW)
 130         ugd->base = _create_fullview(ugd->win, ugd);
 131     else
 132         ugd->base = _create_frameview(ugd->win, ugd);
 133
 134     if (ugd->base)
 135     {
 136         ugd->bg = _create_bg(ugd->win, "group_list");
 137         elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg);
 138     }
 139     else
 140     {
 141         DBG(LOG_ERROR, "Failed to create base layout\n");
 142         return NULL;
 143     }
 144
 145     wfd_get_vconf_status(ugd);
 146
 147     create_wfd_ug_view(ugd);
 148     evas_object_show(ugd->base);
 149
 150     __FUNC_EXIT__;
 151     return ugd->base;
 152 }
 153
 154 static void on_start(struct ui_gadget *ug, bundle * data, void *priv)
 155 {
 156     __FUNC_ENTER__;
 157     struct ug_data *ugd;
 158     int res;
 159
 160     if (!ug || !priv)
 161         return;
 162
 163     ugd = priv;
 164
 165     struct utsname kernel_info;
 166     res = uname(&kernel_info);
 167     if(res != 0)
 168     {
 169         DBG(LOG_ERROR, "Failed to detect target type\n");
 170     }
 171     else
 172     {
 173         DBG(LOG_VERBOSE, "Node name of this device [%s]\n", kernel_info.nodename);
 174         DBG(LOG_VERBOSE, "HW ID of this device [%s]\n", kernel_info.machine);
 175         if(strcmp(kernel_info.nodename, "SLP_PQ") == 0 ||
 176             strncmp(kernel_info.machine, "arm", 3) != 0)
 177         {
 178             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_NOT_SUPPORTED_DEVICE"), POPUP_TYPE_TERMINATE);
 179             return;
 180         }
 181     }
 182
 183     res = init_wfd_client(ugd);
 184     if(res != 0)
 185     {
 186         DBG(LOG_ERROR, "Failed to initialize WFD client library\n");
 187         wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_PROBLEM_WITH_WFD"), POPUP_TYPE_TERMINATE);
 188     }
 189
 190     __FUNC_EXIT__;
 191 }
 192
 193 static void on_pause(struct ui_gadget *ug, bundle * data, void *priv)
 194 {
 195     __FUNC_ENTER__;
 196     __FUNC_EXIT__;
 197 }
 198
 199 static void on_resume(struct ui_gadget *ug, bundle * data, void *priv)
 200 {
 201     __FUNC_ENTER__;
 202     __FUNC_EXIT__;
 203 }
 204
 205 static void on_destroy(struct ui_gadget *ug, bundle * data, void *priv)
 206 {
 207     __FUNC_ENTER__;
 208
 209     if (!ug || !priv)
 210     {
 211         DBG(LOG_ERROR, "The param is NULL\n");
 212         return;
 213     }
 214
 215     struct ug_data *ugd = priv;
 216     if (ugd == NULL || ugd->base == NULL)
 217     {
 218         DBG(LOG_ERROR, "The param is NULL\n");
 219         return;
 220     }
 221
 222     deinit_wfd_client(ugd);
 223     DBG(LOG_VERBOSE, "WFD client deregistered");
 224
 225     destroy_wfd_ug_view(ugd);
 226
 227     if (ugd->bg)
 228     {
 229         evas_object_del(ugd->bg);
 230         ugd->bg = NULL;
 231     }
 232
 233     if (ugd->base)
 234     {
 235         evas_object_del(ugd->base);
 236         ugd->base = NULL;
 237     }
 238
 239     __FUNC_EXIT__;
 240     return;
 241 }
 242
 243 static void on_message(struct ui_gadget *ug, bundle * msg, bundle * data,
 244                        void *priv)
 245 {
 246     __FUNC_ENTER__;
 247     __FUNC_EXIT__;
 248 }
 249
 250 static void on_event(struct ui_gadget *ug, enum ug_event event, bundle * data,
 251                      void *priv)
 252 {
 253     __FUNC_ENTER__;
 254
 255     if (!ug || !priv)
 256     {
 257         DBG(LOG_ERROR, "The param is NULL\n");
 258         return;
 259     }
 260
 261     switch (event)
 262     {
 263     case UG_EVENT_LOW_MEMORY:
 264         DBG(LOG_VERBOSE, "UG_EVENT_LOW_MEMORY\n");
 265         break;
 266     case UG_EVENT_LOW_BATTERY:
 267         DBG(LOG_VERBOSE, "UG_EVENT_LOW_BATTERY\n");
 268         break;
 269     case UG_EVENT_LANG_CHANGE:
 270         DBG(LOG_VERBOSE, "UG_EVENT_LANG_CHANGE\n");
 271         break;
 272     case UG_EVENT_ROTATE_PORTRAIT:
 273         DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT\n");
 274         break;
 275     case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 276         DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN\n");
 277         break;
 278     case UG_EVENT_ROTATE_LANDSCAPE:
 279         DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE\n");
 280         break;
 281     case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 282         DBG(LOG_VERBOSE, "UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN\n");
 283         break;
 284     default:
 285         DBG(LOG_VERBOSE, "default\n");
 286         break;
 287     }
 288
 289     __FUNC_EXIT__;
 290 }
 291
 292 static void on_key_event(struct ui_gadget *ug, enum ug_key_event event,
 293                          bundle * data, void *priv)
 294 {
 295     __FUNC_ENTER__;
 296
 297     if (!ug || !priv)
 298     {
 299         DBG(LOG_ERROR, "The param is NULL\n");
 300         return;
 301     }
 302
 303     switch (event)
 304     {
 305     case UG_KEY_EVENT_END:
 306         DBG(LOG_VERBOSE, "UG_KEY_EVENT_END\n");
 307         break;
 308     default:
 309         break;
 310     }
 311
 312     __FUNC_EXIT__;
 313 }
 314
 315 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 316 {
 317     __FUNC_ENTER__;
 318     struct ug_data *ugd;
 319
 320     if (!ops)
 321     {
 322         DBG(LOG_ERROR, "The param is NULL\n");
 323         return -1;
 324     }
 325
 326     ugd = calloc(1, sizeof(struct ug_data));
 327     if (ugd == NULL)
 328     {
 329         DBG(LOG_ERROR, "Failed to allocate memory for UG data\n");
 330         return -1;
 331     }
 332
 333     ops->create = on_create;
 334     ops->start = on_start;
 335     ops->pause = on_pause;
 336     ops->resume = on_resume;
 337     ops->destroy = on_destroy;
 338     ops->message = on_message;
 339     ops->event = on_event;
 340     ops->key_event = on_key_event;
 341     ops->priv = ugd;
 342     ops->opt = UG_OPT_INDICATOR_ENABLE;
 343
 344     __FUNC_EXIT__;
 345     return 0;
 346 }
 347
 348 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 349 {
 350     __FUNC_ENTER__;
 351
 352     struct ug_data *ugd;
 353
 354     if (!ops)
 355     {
 356         DBG(LOG_ERROR, "The param is NULL\n");
 357         return;
 358     }
 359
 360     ugd = ops->priv;
 361
 362     if (ugd)
 363         free(ugd);
 364
 365     __FUNC_EXIT__;
 366 }