src/mh_connected_client.c

   1 /*
   2  * mh_connected_client.c
   3  *
   4  *  Created on: 05-Sep-2014
   5  *      Author: sach.sharma
   6  */
   7 #include <time.h>
   8
   9 #include "mh_view_main.h"
  10 #include "mobile_hotspot.h"
  11 #include "mh_string.h"
  12
  13 #ifdef TIZEN_FEATURE_EMULATOR
  14 static int emul_no_of_clients;
  15 static time_t emul_timestamp[TETHERING_TYPE_MAX];
  16 #endif
  17
  18 static void __remove_conn_clients(mh_appdata_t *ad)
  19 {
  20         __MOBILE_AP_FUNC_ENTER__;
  21
  22         mh_main_view_t *mv = &ad->main;
  23         int connected_clients = 0;
  24         int i = 0;
  25
  26         if (_get_no_of_connected_device(ad, &connected_clients,
  27                                         TETHERING_TYPE_ALL) == EINA_FALSE)
  28                 ERR("Getting the number of connected device is failed");
  29
  30         for (i = 0; i < MAX_CONNECTED_STA; i++)
  31                 _free_genlist_item(&ad->main.station_items[i]);
  32
  33         _free_genlist_itc(&mv->dev_itc[TETHERING_TYPE_WIFI]);
  34         _free_genlist_itc(&mv->dev_itc[TETHERING_TYPE_BT]);
  35         _free_genlist_itc(&mv->dev_itc[TETHERING_TYPE_USB]);
  36
  37         _stop_update_device_conn_time(ad);
  38
  39         __MOBILE_AP_FUNC_EXIT__;
  40 }
  41
  42 static void __update_connected_clients(mh_appdata_t *ad)
  43 {
  44         __MOBILE_AP_FUNC_ENTER__;
  45
  46         if (ad == NULL) {
  47                 ERR("Invalid param\n");
  48                 return;
  49         }
  50
  51         Elm_Object_Item *item = NULL;
  52         tethering_type_e connection_type = 0;
  53         GSList *l = NULL;
  54         tethering_client_h *handle;
  55         int count = 0;
  56         mh_main_view_t *main_view = &(ad->main);
  57         int i = 0;
  58         int connected_clients = 0;
  59
  60         if (_get_no_of_connected_device(ad, &connected_clients,
  61                                         TETHERING_TYPE_ALL) == EINA_FALSE)
  62                 ERR("Getting the number of connected device is failed");
  63
  64         for (i = 0; i < MAX_CONNECTED_STA; i++)
  65                 _free_genlist_item(&ad->main.station_items[i]);
  66
  67         for (l = ad->client_list; l != NULL; l = g_slist_next(l)) {
  68                 handle = (tethering_client_h *)l->data;
  69                 tethering_client_get_tethering_type(handle, &connection_type);
  70
  71                 item = elm_genlist_item_append(main_view->genlist,
  72                                 main_view->dev_itc[connection_type],
  73                                 (void *)handle,
  74                                 NULL, ELM_GENLIST_ITEM_NONE,
  75                                 NULL, NULL);
  76                 if (item == NULL) {
  77                         ERR("elm_genlist_item_append is failed\n");
  78                         continue;
  79                 }
  80                 main_view->station_items[count++] = item;
  81                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
  82         }
  83         main_view->no_of_clients = count;
  84         _start_update_device_conn_time(ad);
  85         __MOBILE_AP_FUNC_EXIT__;
  86         return;
  87 }
  88
  89 void _update_conn_clients(mh_appdata_t *ad)
  90 {
  91         __MOBILE_AP_FUNC_ENTER__;
  92
  93         if (ad == NULL) {
  94                 ERR("Invalid param\n");
  95                 return;
  96         }
  97         int connected_clients = 0;
  98         if (_get_no_of_connected_device(ad, &connected_clients,
  99                                         TETHERING_TYPE_ALL) == EINA_FALSE)
 100                 ERR("Getting the number of connected device is failed");
 101
 102         if (connected_clients == 0)
 103                 __remove_conn_clients(ad);
 104         else
 105                 __update_connected_clients(ad);
 106
 107         __MOBILE_AP_FUNC_EXIT__;
 108         return;
 109 }
 110
 111 static char *__get_diff_time(time_t connection_time)
 112 {
 113         time_t current_time;
 114         char buf[MH_LABEL_LENGTH_MAX] = {0, };
 115         int day;
 116         int hour;
 117         int min;
 118         int sec;
 119         double diff;
 120
 121         time(&current_time);
 122         diff = difftime(current_time, connection_time);
 123         day = diff / (60 * 60 * 24);
 124         diff = diff - (day * 60 * 60 * 24);
 125         hour = diff / (60 * 60);
 126         diff = diff - (hour * 60 * 60);
 127         min = diff / 60;
 128         diff = diff - (min * 60);
 129         sec = diff;
 130
 131         if (day > 0)
 132                 hour = hour + day * 24;
 133
 134         if (hour > 0)
 135                 snprintf(buf, sizeof(buf), "%02d:%02d:%02d", hour, min, sec);
 136         else
 137                 snprintf(buf, sizeof(buf), "%02d:%02d", min, sec);
 138
 139         return g_strdup(buf);
 140 }
 141
 142 static char *__gl_get_dev_label(void *data, Evas_Object *obj, const char *part)
 143 {
 144         __MOBILE_AP_FUNC_ENTER__;
 145
 146 #ifndef TIZEN_FEATURE_EMULATOR
 147         tethering_client_h client = (tethering_client_h)data;
 148         char *name = NULL;
 149         char *dev_name = NULL;
 150         time_t tm;
 151
 152         if (data == NULL || obj == NULL || part == NULL) {
 153                 ERR("Invalid param\n");
 154                 return NULL;
 155         }
 156
 157         if (!strcmp("elm.text", part)) {
 158                 tethering_client_get_name(client, &name);
 159                 if (NULL == name)
 160                         return NULL;
 161
 162                 if (!strcmp(name, "UNKNOWN")) {
 163                         free(name);
 164                         return strdup(STR_NO_NAME);
 165                 }
 166
 167                 dev_name = elm_entry_utf8_to_markup(name);
 168                 free(name);
 169                 return dev_name;
 170         } else if (!strcmp("elm.text.sub", part)) {
 171                 tethering_client_get_time(client, &tm);
 172                 return __get_diff_time(tm);
 173         }
 174 #else
 175         tethering_type_e selected_type = _get_selected_type();
 176         tethering_type_e updated_type = _get_updated_type();
 177         if (obj == NULL) {
 178                 ERR("Invalid param\n");
 179                 return NULL;
 180         }
 181
 182         if (!strcmp("elm.text", part)) {
 183                 if (selected_type == TETHERING_TYPE_WIFI)
 184                         return strdup("wifi_tethering_client");
 185                 else if (selected_type == TETHERING_TYPE_BT)
 186                         return strdup("bt_tethering_client");
 187                 else
 188                         return strdup("usb_tethering_client");
 189         } else if (!strcmp("elm.text.sub", part)) {
 190                 if (updated_type == TETHERING_TYPE_ALL)
 191                         return __get_diff_time(emul_timestamp[selected_type]);
 192                 else
 193                         return __get_diff_time(emul_timestamp[updated_type]);
 194         }
 195
 196 #endif
 197         __MOBILE_AP_FUNC_EXIT__;
 198         return NULL;
 199 }
 200
 201 static Evas_Object *__gl_get_dev_wifi_icon(void *data, Evas_Object *obj,
 202                                                         const char *part)
 203 {
 204         Evas_Object *icon = NULL;
 205
 206         if (!strcmp("elm.swallow.icon", part)) {
 207                 icon = elm_icon_add(obj);
 208                 elm_image_file_set(icon, EDJDIR"/"TETHERING_IMAGES_EDJ, WIFI_ICON);
 209                 evas_object_color_set(icon, 2, 61, 132, 204);
 210                 evas_object_size_hint_min_set(icon, ELM_SCALE_SIZE(DEFAULT_ICON_SIZE), ELM_SCALE_SIZE(DEFAULT_ICON_SIZE));
 211         }
 212         return icon;
 213 }
 214
 215 static Evas_Object *__gl_get_dev_usb_icon(void *data, Evas_Object *obj,
 216                                                         const char *part)
 217 {
 218         Evas_Object *icon = NULL;
 219
 220         if (!strcmp("elm.swallow.icon", part)) {
 221                 icon = elm_icon_add(obj);
 222                 elm_image_file_set(icon, EDJDIR"/"TETHERING_IMAGES_EDJ, USB_ICON);
 223                 evas_object_color_set(icon, 2, 61, 132, 204);
 224                 evas_object_size_hint_min_set(icon, ELM_SCALE_SIZE(DEFAULT_ICON_SIZE), ELM_SCALE_SIZE(DEFAULT_ICON_SIZE));
 225         }
 226         return icon;
 227 }
 228
 229 static Evas_Object *__gl_get_dev_bt_icon(void *data, Evas_Object *obj,
 230                                                         const char *part)
 231 {
 232         Evas_Object *icon = NULL;
 233
 234         if (!strcmp("elm.swallow.icon", part)) {
 235                 icon = elm_image_add(obj);
 236                 elm_image_file_set(icon, EDJDIR"/"TETHERING_IMAGES_EDJ, BT_ICON);
 237                 evas_object_color_set(icon, 2, 61, 132, 204);
 238                 evas_object_size_hint_min_set(icon, ELM_SCALE_SIZE(DEFAULT_ICON_SIZE), ELM_SCALE_SIZE(DEFAULT_ICON_SIZE));
 239         }
 240         return icon;
 241 }
 242
 243 static void __set_genlist_itc(mh_appdata_t *ad)
 244 {
 245         __MOBILE_AP_FUNC_ENTER__;
 246
 247         ad->main.dev_itc[TETHERING_TYPE_WIFI] = elm_genlist_item_class_new();
 248         ad->main.dev_itc[TETHERING_TYPE_WIFI]->item_style = MH_GENLIST_2LINE_TOP_TEXT_ICON_STYLE;
 249         ad->main.dev_itc[TETHERING_TYPE_WIFI]->func.text_get = __gl_get_dev_label;
 250         ad->main.dev_itc[TETHERING_TYPE_WIFI]->func.content_get = __gl_get_dev_wifi_icon;
 251         ad->main.dev_itc[TETHERING_TYPE_WIFI]->func.state_get = NULL;
 252         ad->main.dev_itc[TETHERING_TYPE_WIFI]->func.del = NULL;
 253
 254         ad->main.dev_itc[TETHERING_TYPE_USB] = elm_genlist_item_class_new();
 255         ad->main.dev_itc[TETHERING_TYPE_USB]->item_style = MH_GENLIST_2LINE_TOP_TEXT_ICON_STYLE;
 256         ad->main.dev_itc[TETHERING_TYPE_USB]->func.text_get = __gl_get_dev_label;
 257         ad->main.dev_itc[TETHERING_TYPE_USB]->func.content_get = __gl_get_dev_usb_icon;
 258         ad->main.dev_itc[TETHERING_TYPE_USB]->func.state_get = NULL;
 259         ad->main.dev_itc[TETHERING_TYPE_USB]->func.del = NULL;
 260
 261         ad->main.dev_itc[TETHERING_TYPE_BT] = elm_genlist_item_class_new();
 262         ad->main.dev_itc[TETHERING_TYPE_BT]->item_style = MH_GENLIST_2LINE_TOP_TEXT_ICON_STYLE;
 263         ad->main.dev_itc[TETHERING_TYPE_BT]->func.text_get = __gl_get_dev_label;
 264         ad->main.dev_itc[TETHERING_TYPE_BT]->func.content_get = __gl_get_dev_bt_icon;
 265         ad->main.dev_itc[TETHERING_TYPE_BT]->func.state_get = NULL;
 266         ad->main.dev_itc[TETHERING_TYPE_BT]->func.del = NULL;
 267
 268         __MOBILE_AP_FUNC_EXIT__;
 269 }
 270
 271 static void __scroll_start_cb(void *data, Evas_Object *obj, void *event_info)
 272 {
 273         __MOBILE_AP_FUNC_ENTER__;
 274
 275         _stop_update_device_conn_time((mh_appdata_t *)data);
 276         __MOBILE_AP_FUNC_EXIT__;
 277 }
 278
 279 static void __scroll_stop_cb(void *data, Evas_Object *obj, void *event_info)
 280 {
 281         __MOBILE_AP_FUNC_ENTER__;
 282
 283         _start_update_device_conn_time((mh_appdata_t *)data);
 284         __MOBILE_AP_FUNC_EXIT__;
 285 }
 286
 287 #ifdef TIZEN_FEATURE_EMULATOR
 288 void __update_emul_clients_genlist(mh_appdata_t *ad)
 289 {
 290         __MOBILE_AP_FUNC_ENTER__;
 291
 292         if (ad == NULL) {
 293                 ERR("ad is NULL\n");
 294                 return;
 295         }
 296
 297         Elm_Object_Item *item = NULL;
 298         mh_main_view_t *mv = &ad->main;
 299         tethering_type_e selected_type = _get_selected_type();
 300         Eina_Bool selected_state = _get_selected_state();
 301
 302         __set_genlist_itc(ad);
 303
 304
 305         if (selected_state && !mv->emul_station_items[selected_type]) {
 306                 mv->emul_station_items[selected_type] = elm_genlist_item_append(mv->genlist,
 307                         mv->dev_itc[selected_type],
 308                         NULL, NULL, ELM_GENLIST_ITEM_NONE,
 309                         NULL, NULL);
 310                 time(&emul_timestamp[selected_type]);
 311                 emul_no_of_clients++;
 312         } else {
 313                 if (mv->emul_station_items[selected_type]) {
 314                         elm_object_item_del(mv->emul_station_items[selected_type]);
 315                         mv->emul_station_items[selected_type] = NULL;
 316                         emul_timestamp[selected_type] = 0;
 317                         emul_no_of_clients--;
 318                 }
 319         }
 320
 321         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 322
 323         evas_object_smart_callback_add(mv->genlist, "scroll,anim,start",
 324                         __scroll_start_cb, ad);
 325         evas_object_smart_callback_add(mv->genlist, "scroll,drag,start",
 326                         __scroll_start_cb, ad);
 327         evas_object_smart_callback_add(mv->genlist, "scroll,anim,stop",
 328                         __scroll_stop_cb, ad);
 329         evas_object_smart_callback_add(mv->genlist, "scroll,drag,stop",
 330                         __scroll_stop_cb, ad);
 331
 332         if (emul_no_of_clients)
 333                 _start_update_device_conn_time(ad);
 334         else
 335                 _stop_update_device_conn_time(ad);
 336 }
 337 #endif
 338
 339 static void __append_clients_genlist(mh_appdata_t *ad)
 340 {
 341         __MOBILE_AP_FUNC_ENTER__;
 342
 343         if (ad == NULL) {
 344                 ERR("ad is NULL\n");
 345                 return;
 346         }
 347
 348         Elm_Object_Item *item = NULL;
 349         tethering_type_e connection_type = 0;
 350         GSList *l = NULL;
 351         tethering_client_h *handle;
 352         int count = 0;
 353
 354         mh_main_view_t *mv = &ad->main;
 355
 356         __set_genlist_itc(ad);
 357
 358         for (l = ad->client_list; l != NULL; l = g_slist_next(l)) {
 359                 handle = (tethering_client_h *)l->data;
 360                 tethering_client_get_tethering_type(handle, &connection_type);
 361
 362                 item = elm_genlist_item_append(mv->genlist,
 363                                 mv->dev_itc[connection_type],
 364                                 (void *)handle,
 365                                 NULL, ELM_GENLIST_ITEM_NONE,
 366                                 NULL, NULL);
 367                 if (item == NULL) {
 368                         ERR("elm_genlist_item_append is failed\n");
 369                         continue;
 370                 }
 371                 mv->station_items[count++] = item;
 372                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 373         }
 374         evas_object_smart_callback_add(mv->genlist, "scroll,anim,start",
 375                                 __scroll_start_cb, ad);
 376         evas_object_smart_callback_add(mv->genlist, "scroll,drag,start",
 377                                 __scroll_start_cb, ad);
 378         evas_object_smart_callback_add(mv->genlist, "scroll,anim,stop",
 379                                 __scroll_stop_cb, ad);
 380         evas_object_smart_callback_add(mv->genlist, "scroll,drag,stop",
 381                                 __scroll_stop_cb, ad);
 382
 383         mv->no_of_clients = count;
 384         _start_update_device_conn_time(ad);
 385
 386         __MOBILE_AP_FUNC_EXIT__;
 387 }
 388
 389 void _add_connected_clients(mh_appdata_t *ad)
 390 {
 391         DBG("+\n");
 392         if (ad == NULL) {
 393                 ERR("ad is NULL\n");
 394                 return;
 395         }
 396
 397         __append_clients_genlist(ad);
 398
 399         DBG("-\n");
 400 }