daemon/idletxt/idletxt.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://floralicense.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 #include <Ecore_X.h>
  18 #include <vconf.h>
  19 #include "common.h"
  20 #include "quickpanel-ui.h"
  21 #include "quickpanel_def.h"
  22
  23 #define QP_ENABLE_SLIDING_TEXT 0
  24 #define QP_ENABLE_SAT 0
  25 #define QP_IDLETXT_PART         "qp.noti.swallow.spn"
  26
  27 #define QP_SPN_BASE_PART        "qp.base.spn.swallow"
  28 #define QP_SPN_BOX_PART         "qp.spn.swallow"
  29 #define QP_BUTTON_PART          "qp.button.swallow"
  30
  31 #define QP_IDLETXT_MAX_KEY      4
  32 #define QP_IDLETXT_MAX_LEN      1024
  33 #define QP_IDLETXT_SLIDE_LEN    130
  34
  35 #define QP_IDLETXT_LABEL_STRING \
  36         "<font_size=36 font_weight=Medium color=#959494FF align=left>%s</>"
  37
  38 static int quickpanel_idletxt_init(void *data);
  39 static int quickpanel_idletxt_fini(void *data);
  40 static int quickpanel_idletxt_suspend(void *data);
  41 static int quickpanel_idletxt_resume(void *data);
  42 static void quickpanel_idletxt_lang_changed(void *data);
  43
  44 QP_Module idletxt = {
  45         .name = "idletxt",
  46         .init = quickpanel_idletxt_init,
  47         .fini = quickpanel_idletxt_fini,
  48         .suspend = quickpanel_idletxt_suspend,
  49         .resume = quickpanel_idletxt_resume,
  50         .lang_changed = quickpanel_idletxt_lang_changed
  51 };
  52
  53 static int _quickpanel_idletxt_map_exceptional_nwname(char *txt, char *map_txt, int map_txt_len)
  54 {
  55         int is_mapped = 0;
  56
  57         if (txt == NULL || map_txt == NULL) {
  58                 return is_mapped;
  59         }
  60
  61         if (strncasecmp(txt, "No Service", strlen("No Service")) == 0) {
  62                 strncpy(map_txt, _S("IDS_COM_BODY_NO_SERVICE"), map_txt_len);
  63                 is_mapped = 1;
  64         } else if (strncasecmp(txt, "EMERGENCY", strlen("EMERGENCY")) == 0) {
  65                 strncpy(map_txt, _("IDS_CALL_POP_CALLING_EMERG_ONLY"), map_txt_len);
  66                 is_mapped = 1;
  67         } else if (strncasecmp(txt, "Searching", strlen("Searching")) == 0) {
  68                 strncpy(map_txt, _S("IDS_COM_BODY_SEARCHING"), map_txt_len);
  69                 is_mapped = 1;
  70         } else if (strncasecmp(txt, "SIM Error", strlen("SIM Error")) == 0) {
  71                 strncpy(map_txt, _S("IDS_COM_BODY_INVALID_SIM_CARD"), map_txt_len);
  72                 is_mapped = 1;
  73         } else if (strncasecmp(txt, "NO SIM", strlen("NO SIM")) == 0) {
  74                 strncpy(map_txt, _S("IDS_COM_BODY_NO_SIM"), map_txt_len);
  75                 is_mapped = 1;
  76         }
  77
  78         return is_mapped;
  79 }
  80
  81 static Evas_Object *_quickpanel_idletxt_create_label(Evas_Object * parent,
  82                                                      char *txt)
  83 {
  84         Evas_Object *obj = NULL;
  85         char buf[QP_IDLETXT_MAX_LEN] = { 0, };
  86         char localized_txt[QP_IDLETXT_MAX_LEN] = { 0, };
  87         int len = 0;
  88
  89         retif(parent == NULL || txt == NULL, NULL, "Invalid parameter!");
  90
  91         memset(buf, 0x00, sizeof(buf));
  92
  93         if (_quickpanel_idletxt_map_exceptional_nwname(txt, localized_txt, QP_IDLETXT_MAX_LEN) == 1) {
  94                 len = snprintf(buf, sizeof(buf), QP_IDLETXT_LABEL_STRING, localized_txt);
  95         } else {
  96                 len = snprintf(buf, sizeof(buf), QP_IDLETXT_LABEL_STRING, txt);
  97         }
  98
  99         retif(len < 0, NULL, "len < 0");
 100
 101         obj = elm_label_add(parent);
 102         if (obj != NULL) {
 103                 struct appdata *ad = quickpanel_get_app_data();
 104
 105                 if (ad != NULL)
 106                         elm_label_wrap_width_set(obj, QP_SPN_TEXT_W * ad->scale);
 107                 else
 108                         elm_label_wrap_width_set(obj, QP_SPN_TEXT_W);
 109
 110 #if QP_ENABLE_SLIDING_TEXT
 111                 elm_label_slide_mode_set(obj, ELM_LABEL_SLIDE_MODE_AUTO);
 112                 elm_label_slide_duration_set(obj, 3);
 113                 elm_object_style_set(obj, "slide_bounce");
 114 #else
 115                 elm_label_ellipsis_set(obj, EINA_TRUE);
 116 #endif
 117
 118                 elm_object_text_set(obj, buf);
 119
 120                 evas_object_size_hint_weight_set(obj, EVAS_HINT_EXPAND,
 121                                                  EVAS_HINT_EXPAND);
 122                 evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, 0.5);
 123
 124                 evas_object_show(obj);
 125         }
 126
 127         return obj;
 128 }
 129
 130 static Evas_Object *_quickpanel_idletxt_create_box(Evas_Object * parent)
 131 {
 132         Evas_Object *box = NULL;
 133
 134         retif(parent == NULL, NULL, "Invalid parameter!");
 135
 136         box = elm_box_add(parent);
 137         if (box != NULL) {
 138                 elm_box_horizontal_set(box, EINA_FALSE);
 139
 140                 evas_object_show(box);
 141         }
 142
 143         return box;
 144 }
 145
 146 static int _quickpanel_idletxt_get_txt(const char *key, char *txt, int size)
 147 {
 148         int len = 0;
 149         char *str = NULL;
 150         int i = 0;
 151
 152         str = vconf_get_str(key);
 153         if (str == NULL || str[0] == '\0')
 154                 return 0;
 155
 156         /* check ASCII code */
 157         for (i = strlen(str) - 1; i >= 0; i--) {
 158                 if (str[i] <= 31 || str[i] >= 127)
 159                         goto failed;
 160         }
 161
 162         len = snprintf(txt, size, "%s", str);
 163
 164  failed:
 165         if (str)
 166                 free(str);
 167
 168         return len;
 169 }
 170
 171 static Evas_Object *_quickpanel_idletxt_add_label(Evas_Object * box,
 172                                                   char *key[])
 173 {
 174         char txt[QP_IDLETXT_MAX_LEN] = { 0, };
 175         char buf[QP_IDLETXT_MAX_LEN] = { 0, };
 176         int len = 0;
 177         int i = 0;
 178         Evas_Object *obj = NULL;
 179
 180         retif(key == NULL || key[0] == '\0', NULL, "Invalid parameter!");
 181
 182         memset(txt, 0x00, sizeof(txt));
 183
 184         for (i = 0; key[i]; i++) {
 185                 memset(buf, 0x00, sizeof(buf));
 186
 187                 /* get next key string */
 188                 if (_quickpanel_idletxt_get_txt(key[i], buf, sizeof(buf))) {
 189                         INFO("VCONFKEY(%s) = %s", key[i], buf);
 190
 191                         len = strlen(txt);
 192
 193                         snprintf(&txt[len], sizeof(txt) - len, "%s%s",
 194                                  len ? " - " : "", buf);
 195                 }
 196         }
 197
 198         len = strlen(txt);
 199
 200         if (len) {
 201                 obj = _quickpanel_idletxt_create_label(box, txt);
 202
 203                 if (obj != NULL) {
 204                         return obj;
 205                 }
 206         }
 207
 208         return NULL;
 209 }
 210
 211 static Evas_Object *_quickpanel_idletxt_exception_add_label(Evas_Object * box)
 212 {
 213         int service_type = VCONFKEY_TELEPHONY_SVCTYPE_SEARCH;
 214         char *text = NULL;
 215         Evas_Object *obj = NULL;
 216
 217         if (vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &service_type) != 0) {
 218                 DBG("fail to get VCONFKEY_TELEPHONY_SVCTYPE");
 219         }
 220
 221         switch(service_type) {
 222                 case VCONFKEY_TELEPHONY_SVCTYPE_NOSVC:
 223                         text = _S("IDS_COM_BODY_NO_SERVICE");
 224                         break;
 225                 case VCONFKEY_TELEPHONY_SVCTYPE_EMERGENCY:
 226                         text = _("IDS_CALL_POP_CALLING_EMERG_ONLY");
 227                         break;
 228                 default:
 229                         if (service_type > VCONFKEY_TELEPHONY_SVCTYPE_SEARCH) {
 230                                 text = vconf_get_str(VCONFKEY_TELEPHONY_NWNAME);
 231                         } else if (service_type == VCONFKEY_TELEPHONY_SVCTYPE_SEARCH)  {
 232                                 text = _S("IDS_COM_BODY_SEARCHING");
 233                         } else {
 234                                 return NULL;
 235                         }
 236                         break;
 237         }
 238
 239         if (text != NULL) {
 240                 obj = _quickpanel_idletxt_create_label(box, text);
 241
 242                 if (obj != NULL) {
 243                         return obj;
 244                 }
 245         }
 246
 247         return NULL;
 248 }
 249
 250 static Evas_Object *_quickpanel_idletxt_get_spn(Evas_Object * box)
 251 {
 252         Evas_Object *label = NULL;
 253         char *keylist[QP_IDLETXT_MAX_KEY] = { 0, };
 254         int ret = 0;
 255         int state = 0;
 256         int i = 0;
 257         int service_type = VCONFKEY_TELEPHONY_SVCTYPE_NONE;
 258
 259         /* make keylist */
 260         if (vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &service_type) != 0) {
 261                 DBG("fail to get VCONFKEY_TELEPHONY_SVCTYPE");
 262         }
 263
 264         ret = vconf_get_int(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION, &state);
 265         if (ret == 0) {
 266                 INFO("VCONFKEY(%s) = %d",
 267                      VCONFKEY_TELEPHONY_SPN_DISP_CONDITION, state);
 268
 269                 if (state != VCONFKEY_TELEPHONY_DISP_INVALID
 270                                 && service_type > VCONFKEY_TELEPHONY_SVCTYPE_SEARCH) {
 271                         if (i < QP_IDLETXT_MAX_KEY) {
 272                                 if (state & VCONFKEY_TELEPHONY_DISP_SPN) {
 273                                         keylist[i++] =
 274                                             strdup(VCONFKEY_TELEPHONY_SPN_NAME);
 275                                 }
 276
 277                                 if (state & VCONFKEY_TELEPHONY_DISP_PLMN) {
 278                                         keylist[i++] =
 279                                             strdup(VCONFKEY_TELEPHONY_NWNAME);
 280                                 }
 281                         }
 282
 283                         if (i > 0) {
 284                                 /* get string with keylist */
 285                                 label = _quickpanel_idletxt_add_label(box, keylist);
 286
 287                                 /* free keylist */
 288                                 while (i > 0) {
 289                                         if (keylist[i])
 290                                                 free(keylist[i]);
 291
 292                                         i--;
 293                                 }
 294                         }
 295                 } else {
 296                         label = _quickpanel_idletxt_exception_add_label(box);
 297                 }
 298         }
 299
 300         return label;
 301 }
 302
 303 static Evas_Object *_quickpanel_idletxt_get_sat_text(Evas_Object * box)
 304 {
 305         Evas_Object *label = NULL;
 306         char *keylist[] = { VCONFKEY_SAT_IDLE_TEXT, 0 };
 307
 308         /* get string with keylist */
 309         label = _quickpanel_idletxt_add_label(box, keylist);
 310
 311         return label;
 312 }
 313
 314 static Eina_Bool _quickpanel_idletxt_button_clicked_timer_cb(void *data)
 315 {
 316         if (quickpanel_is_emul())
 317                 quickpanel_launch_app(QP_SETTING_PKG_SETTING_EMUL, NULL);
 318         else
 319                 quickpanel_launch_app(QP_SETTING_PKG_SETTING, NULL);
 320
 321         quickpanel_close_quickpanel(true);
 322
 323         return ECORE_CALLBACK_CANCEL;
 324 }
 325
 326
 327 static void _quickpanel_idletxt_button_clicked(void *data, Evas_Object * obj, void *event_info)
 328 {
 329         struct appdata *ad = data;
 330
 331         quickpanel_play_feedback();
 332
 333         retif(obj == NULL, , "Invalid parameter!");
 334         retif(ad == NULL, , "Invalid parameter!");
 335         retif(ad->win == NULL, , "ad->win is NULL");
 336
 337         ecore_idler_add(_quickpanel_idletxt_button_clicked_timer_cb, NULL);
 338 }
 339
 340 static void quickpanel_idletxt_update(void *data)
 341 {
 342         struct appdata *ad = NULL;
 343         Evas_Object *label = NULL;
 344         Evas_Object *idletxtbox = NULL;
 345         Evas_Object *button_settings = NULL;
 346         Evas_Object *spn = NULL;
 347
 348         retif(!data, , "Invalid parameter!");
 349         ad = data;
 350
 351         retif(!ad->ly, , "layout is NULL!");
 352
 353         spn = elm_object_part_content_get(ad->ly, QP_SPN_BASE_PART);
 354         retif(!spn, , "spn layout is NULL!");
 355
 356         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 357         button_settings = elm_object_part_content_get(spn, QP_BUTTON_PART);
 358
 359         if (idletxtbox == NULL) {
 360                 idletxtbox = _quickpanel_idletxt_create_box(spn);
 361                 retif(idletxtbox == NULL, , "Failed to create box!");
 362                 elm_object_part_content_set(spn,
 363                                 QP_SPN_BOX_PART, idletxtbox);
 364         }
 365
 366         elm_box_clear(idletxtbox);
 367
 368         /* get spn */
 369         label = _quickpanel_idletxt_get_spn(idletxtbox);
 370         if (label != NULL)
 371                 elm_box_pack_end(idletxtbox, label);
 372
 373         /* get sat idle text */
 374 #if QP_ENABLE_SAT
 375         label = _quickpanel_idletxt_get_sat_text(idletxtbox);
 376         if (label != NULL)
 377                 elm_box_pack_end(idletxtbox, label);
 378 #endif
 379
 380         if (button_settings == NULL) {
 381                 button_settings = elm_button_add(spn);
 382                 retif(button_settings == NULL, , "Failed to create clear button!");
 383                 elm_object_style_set(button_settings, "quickpanel_standard");
 384                 elm_object_part_content_set(spn,
 385                                 QP_BUTTON_PART, button_settings);
 386                 evas_object_smart_callback_add(button_settings, "clicked",
 387                                 _quickpanel_idletxt_button_clicked, ad);
 388         }
 389
 390         elm_object_text_set(button_settings, _S("IDS_COM_BODY_SETTINGS"));
 391 }
 392
 393 static void quickpanel_idletxt_changed_cb(keynode_t *node, void *data)
 394 {
 395         quickpanel_idletxt_update(data);
 396 }
 397
 398 static int _quickpanel_idletxt_register_event_handler(void *data)
 399 {
 400         int ret = 0;
 401
 402         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
 403                                 quickpanel_idletxt_changed_cb, data);
 404         if (ret != 0)
 405                 ERR("Failed to register [%s]",
 406                                 VCONFKEY_TELEPHONY_SVCTYPE);
 407
 408         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION,
 409                                 quickpanel_idletxt_changed_cb, data);
 410         if (ret != 0)
 411                 ERR("Failed to register [%s]",
 412                         VCONFKEY_TELEPHONY_SPN_DISP_CONDITION);
 413
 414         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SPN_NAME,
 415                                 quickpanel_idletxt_changed_cb, data);
 416         if (ret != 0)
 417                 ERR("Failed to register [%s]",
 418                         VCONFKEY_TELEPHONY_SPN_NAME);
 419
 420
 421         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_NWNAME,
 422                                 quickpanel_idletxt_changed_cb, data);
 423         if (ret != 0)
 424                 ERR("Failed to register [%s]",
 425                         VCONFKEY_TELEPHONY_NWNAME);
 426
 427         ret = vconf_notify_key_changed(VCONFKEY_SAT_IDLE_TEXT,
 428                                 quickpanel_idletxt_changed_cb, data);
 429         if (ret != 0)
 430                 ERR("Failed to register [%s]",
 431                         VCONFKEY_SAT_IDLE_TEXT);
 432
 433
 434         return QP_OK;
 435 }
 436
 437 static int _quickpanel_idletxt_unregister_event_handler(void)
 438 {
 439         int ret = 0;
 440
 441         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
 442                                      quickpanel_idletxt_changed_cb);
 443         if (ret != 0)
 444                 ERR("Failed to unregister [%s]",
 445                                 VCONFKEY_TELEPHONY_SVCTYPE);
 446
 447         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION,
 448                                      quickpanel_idletxt_changed_cb);
 449         if (ret != 0)
 450                 ERR("Failed to unregister [%s]",
 451                         VCONFKEY_TELEPHONY_SPN_DISP_CONDITION);
 452
 453         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SPN_NAME,
 454                                      quickpanel_idletxt_changed_cb);
 455         if (ret != 0)
 456                 ERR("Failed to unregister [%s]",
 457                         VCONFKEY_TELEPHONY_SPN_NAME);
 458
 459
 460         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NWNAME,
 461                                      quickpanel_idletxt_changed_cb);
 462         if (ret != 0)
 463                 ERR("Failed to unregister [%s]",
 464                         VCONFKEY_TELEPHONY_NWNAME);
 465
 466         ret = vconf_ignore_key_changed(VCONFKEY_SAT_IDLE_TEXT,
 467                                      quickpanel_idletxt_changed_cb);
 468         if (ret != 0)
 469                 ERR("Failed to unregister [%s]",
 470                         VCONFKEY_SAT_IDLE_TEXT);
 471
 472         return QP_OK;
 473 }
 474
 475 static Evas_Object *_idletxt_load_edj(Evas_Object * parent, const char *file,
 476                                 const char *group)
 477 {
 478         Eina_Bool r;
 479         Evas_Object *eo = NULL;
 480
 481         retif(parent == NULL, NULL, "Invalid parameter!");
 482
 483         eo = elm_layout_add(parent);
 484         retif(eo == NULL, NULL, "Failed to add layout object!");
 485
 486         r = elm_layout_file_set(eo, file, group);
 487         retif(r != EINA_TRUE, NULL, "Failed to set edje object file!");
 488
 489         evas_object_size_hint_weight_set(eo,
 490                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 491         evas_object_show(eo);
 492
 493         return eo;
 494 }
 495
 496 static int quickpanel_idletxt_init(void *data)
 497 {
 498         struct appdata *ad = NULL;
 499         Evas_Object *spn = NULL;
 500
 501         retif(!data, QP_FAIL, "Invalid parameter!");
 502         ad = data;
 503
 504         spn = _idletxt_load_edj(ad->ly, DEFAULT_EDJ, "quickpanel/spn");
 505         retif(!spn, QP_FAIL, "fail to load spn layout");
 506
 507         elm_object_part_content_set(ad->ly, QP_SPN_BASE_PART, spn);
 508
 509         quickpanel_idletxt_update(data);
 510
 511         _quickpanel_idletxt_register_event_handler(data);
 512
 513         return QP_OK;
 514 }
 515
 516 static int quickpanel_idletxt_fini(void *data)
 517 {
 518         struct appdata *ad = (struct appdata *)data;
 519         Evas_Object *spn = NULL;
 520         Evas_Object *idletxtbox = NULL;
 521
 522         retif(ad == NULL, QP_FAIL, "Invalid parameter!");
 523
 524         _quickpanel_idletxt_unregister_event_handler();
 525
 526         retif(!ad->ly, QP_FAIL, "Invalid parameter!");
 527
 528         spn = elm_object_part_content_unset(ad->ly, QP_SPN_BASE_PART);
 529         retif(!spn, QP_OK, "spn is NULL");
 530
 531         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 532         if (idletxtbox) {
 533                 elm_object_part_content_unset(spn, QP_SPN_BOX_PART);
 534                 evas_object_del(idletxtbox);
 535         }
 536
 537         evas_object_del(spn);
 538
 539         return QP_OK;
 540 }
 541
 542 #if QP_ENABLE_SLIDING_TEXT
 543 static Evas_Object *_quickpanel_spn_label_get(void *data)
 544 {
 545         Evas_Object *spn = NULL;
 546         Evas_Object *label = NULL;
 547         Evas_Object *idletxtbox = NULL;
 548         struct appdata *ad = NULL;
 549         retif(!data, NULL, "Invalid parameter!");
 550         ad = data;
 551
 552         retif(!ad->ly, NULL, "layout is NULL!");
 553
 554         spn = elm_object_part_content_get(ad->ly, QP_SPN_BASE_PART);
 555         retif(!spn, NULL, "spn layout is NULL!");
 556
 557         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 558         retif(!idletxtbox, NULL, "idletxtbox is NULL!");
 559
 560         Eina_List *list = elm_box_children_get(idletxtbox);
 561         retif(!list, NULL, "list is NULL!");
 562
 563         label = eina_list_nth(list, 0);
 564
 565         return label;
 566 }
 567 #endif
 568
 569 static int quickpanel_idletxt_suspend(void *data)
 570 {
 571 #if QP_ENABLE_SLIDING_TEXT
 572         Evas_Object *label = _quickpanel_spn_label_get(data);
 573
 574         if (label != NULL) {
 575                 elm_label_slide_mode_set(label, ELM_LABEL_SLIDE_MODE_NONE);
 576         }
 577 #endif
 578
 579         return QP_OK;
 580 }
 581
 582 static int quickpanel_idletxt_resume(void *data)
 583 {
 584 #if QP_ENABLE_SLIDING_TEXT
 585         Evas_Object *label = _quickpanel_spn_label_get(data);
 586
 587         if (label != NULL) {
 588                 elm_label_slide_mode_set(label, ELM_LABEL_SLIDE_MODE_AUTO);
 589         }
 590 #endif
 591
 592         return QP_OK;
 593 }
 594
 595 static void quickpanel_idletxt_lang_changed(void *data)
 596 {
 597         retif(data == NULL, , "Invalid parameter!");
 598
 599         quickpanel_idletxt_update(data);
 600 }