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         quickpanel_launch_app(QP_SETTING_PKG_SETTING_EMUL, NULL);
 317
 318         quickpanel_close_quickpanel(true);
 319
 320         return ECORE_CALLBACK_CANCEL;
 321 }
 322
 323
 324 static void _quickpanel_idletxt_button_clicked(void *data, Evas_Object * obj, void *event_info)
 325 {
 326         struct appdata *ad = data;
 327
 328         quickpanel_play_feedback();
 329
 330         retif(obj == NULL, , "Invalid parameter!");
 331         retif(ad == NULL, , "Invalid parameter!");
 332         retif(ad->win == NULL, , "ad->win is NULL");
 333
 334         ecore_idler_add(_quickpanel_idletxt_button_clicked_timer_cb, NULL);
 335 }
 336
 337 static void quickpanel_idletxt_update(void *data)
 338 {
 339         struct appdata *ad = NULL;
 340         Evas_Object *label = NULL;
 341         Evas_Object *idletxtbox = NULL;
 342         Evas_Object *button_settings = NULL;
 343         Evas_Object *spn = NULL;
 344
 345         retif(!data, , "Invalid parameter!");
 346         ad = data;
 347
 348         retif(!ad->ly, , "layout is NULL!");
 349
 350         spn = elm_object_part_content_get(ad->ly, QP_SPN_BASE_PART);
 351         retif(!spn, , "spn layout is NULL!");
 352
 353         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 354         button_settings = elm_object_part_content_get(spn, QP_BUTTON_PART);
 355
 356         if (idletxtbox == NULL) {
 357                 idletxtbox = _quickpanel_idletxt_create_box(spn);
 358                 retif(idletxtbox == NULL, , "Failed to create box!");
 359                 elm_object_part_content_set(spn,
 360                                 QP_SPN_BOX_PART, idletxtbox);
 361         }
 362
 363         elm_box_clear(idletxtbox);
 364
 365         /* get spn */
 366         label = _quickpanel_idletxt_get_spn(idletxtbox);
 367         if (label != NULL)
 368                 elm_box_pack_end(idletxtbox, label);
 369
 370         /* get sat idle text */
 371 #if QP_ENABLE_SAT
 372         label = _quickpanel_idletxt_get_sat_text(idletxtbox);
 373         if (label != NULL)
 374                 elm_box_pack_end(idletxtbox, label);
 375 #endif
 376
 377         if (button_settings == NULL) {
 378                 button_settings = elm_button_add(spn);
 379                 retif(button_settings == NULL, , "Failed to create clear button!");
 380                 elm_object_style_set(button_settings, "quickpanel_standard");
 381                 elm_object_part_content_set(spn,
 382                                 QP_BUTTON_PART, button_settings);
 383                 evas_object_smart_callback_add(button_settings, "clicked",
 384                                 _quickpanel_idletxt_button_clicked, ad);
 385         }
 386
 387         elm_object_text_set(button_settings, _S("IDS_COM_BODY_SETTINGS"));
 388 }
 389
 390 static void quickpanel_idletxt_changed_cb(keynode_t *node, void *data)
 391 {
 392         quickpanel_idletxt_update(data);
 393 }
 394
 395 static int _quickpanel_idletxt_register_event_handler(void *data)
 396 {
 397         int ret = 0;
 398
 399         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
 400                                 quickpanel_idletxt_changed_cb, data);
 401         if (ret != 0)
 402                 ERR("Failed to register [%s]",
 403                                 VCONFKEY_TELEPHONY_SVCTYPE);
 404
 405         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION,
 406                                 quickpanel_idletxt_changed_cb, data);
 407         if (ret != 0)
 408                 ERR("Failed to register [%s]",
 409                         VCONFKEY_TELEPHONY_SPN_DISP_CONDITION);
 410
 411         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SPN_NAME,
 412                                 quickpanel_idletxt_changed_cb, data);
 413         if (ret != 0)
 414                 ERR("Failed to register [%s]",
 415                         VCONFKEY_TELEPHONY_SPN_NAME);
 416
 417
 418         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_NWNAME,
 419                                 quickpanel_idletxt_changed_cb, data);
 420         if (ret != 0)
 421                 ERR("Failed to register [%s]",
 422                         VCONFKEY_TELEPHONY_NWNAME);
 423
 424         ret = vconf_notify_key_changed(VCONFKEY_SAT_IDLE_TEXT,
 425                                 quickpanel_idletxt_changed_cb, data);
 426         if (ret != 0)
 427                 ERR("Failed to register [%s]",
 428                         VCONFKEY_SAT_IDLE_TEXT);
 429
 430
 431         return QP_OK;
 432 }
 433
 434 static int _quickpanel_idletxt_unregister_event_handler(void)
 435 {
 436         int ret = 0;
 437
 438         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVCTYPE,
 439                                      quickpanel_idletxt_changed_cb);
 440         if (ret != 0)
 441                 ERR("Failed to unregister [%s]",
 442                                 VCONFKEY_TELEPHONY_SVCTYPE);
 443
 444         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION,
 445                                      quickpanel_idletxt_changed_cb);
 446         if (ret != 0)
 447                 ERR("Failed to unregister [%s]",
 448                         VCONFKEY_TELEPHONY_SPN_DISP_CONDITION);
 449
 450         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SPN_NAME,
 451                                      quickpanel_idletxt_changed_cb);
 452         if (ret != 0)
 453                 ERR("Failed to unregister [%s]",
 454                         VCONFKEY_TELEPHONY_SPN_NAME);
 455
 456
 457         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NWNAME,
 458                                      quickpanel_idletxt_changed_cb);
 459         if (ret != 0)
 460                 ERR("Failed to unregister [%s]",
 461                         VCONFKEY_TELEPHONY_NWNAME);
 462
 463         ret = vconf_ignore_key_changed(VCONFKEY_SAT_IDLE_TEXT,
 464                                      quickpanel_idletxt_changed_cb);
 465         if (ret != 0)
 466                 ERR("Failed to unregister [%s]",
 467                         VCONFKEY_SAT_IDLE_TEXT);
 468
 469         return QP_OK;
 470 }
 471
 472 static Evas_Object *_idletxt_load_edj(Evas_Object * parent, const char *file,
 473                                 const char *group)
 474 {
 475         Eina_Bool r;
 476         Evas_Object *eo = NULL;
 477
 478         retif(parent == NULL, NULL, "Invalid parameter!");
 479
 480         eo = elm_layout_add(parent);
 481         retif(eo == NULL, NULL, "Failed to add layout object!");
 482
 483         r = elm_layout_file_set(eo, file, group);
 484         retif(r != EINA_TRUE, NULL, "Failed to set edje object file!");
 485
 486         evas_object_size_hint_weight_set(eo,
 487                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 488         evas_object_show(eo);
 489
 490         return eo;
 491 }
 492
 493 static int quickpanel_idletxt_init(void *data)
 494 {
 495         struct appdata *ad = NULL;
 496         Evas_Object *spn = NULL;
 497
 498         retif(!data, QP_FAIL, "Invalid parameter!");
 499         ad = data;
 500
 501         spn = _idletxt_load_edj(ad->ly, DEFAULT_EDJ, "quickpanel/spn");
 502         retif(!spn, QP_FAIL, "fail to load spn layout");
 503
 504         elm_object_part_content_set(ad->ly, QP_SPN_BASE_PART, spn);
 505
 506         quickpanel_idletxt_update(data);
 507
 508         _quickpanel_idletxt_register_event_handler(data);
 509
 510         return QP_OK;
 511 }
 512
 513 static int quickpanel_idletxt_fini(void *data)
 514 {
 515         struct appdata *ad = (struct appdata *)data;
 516         Evas_Object *spn = NULL;
 517         Evas_Object *idletxtbox = NULL;
 518
 519         retif(ad == NULL, QP_FAIL, "Invalid parameter!");
 520
 521         _quickpanel_idletxt_unregister_event_handler();
 522
 523         retif(!ad->ly, QP_FAIL, "Invalid parameter!");
 524
 525         spn = elm_object_part_content_unset(ad->ly, QP_SPN_BASE_PART);
 526         retif(!spn, QP_OK, "spn is NULL");
 527
 528         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 529         if (idletxtbox) {
 530                 elm_object_part_content_unset(spn, QP_SPN_BOX_PART);
 531                 evas_object_del(idletxtbox);
 532         }
 533
 534         evas_object_del(spn);
 535
 536         return QP_OK;
 537 }
 538
 539 #if QP_ENABLE_SLIDING_TEXT
 540 static Evas_Object *_quickpanel_spn_label_get(void *data)
 541 {
 542         Evas_Object *spn = NULL;
 543         Evas_Object *label = NULL;
 544         Evas_Object *idletxtbox = NULL;
 545         struct appdata *ad = NULL;
 546         retif(!data, NULL, "Invalid parameter!");
 547         ad = data;
 548
 549         retif(!ad->ly, NULL, "layout is NULL!");
 550
 551         spn = elm_object_part_content_get(ad->ly, QP_SPN_BASE_PART);
 552         retif(!spn, NULL, "spn layout is NULL!");
 553
 554         idletxtbox = elm_object_part_content_get(spn, QP_SPN_BOX_PART);
 555         retif(!idletxtbox, NULL, "idletxtbox is NULL!");
 556
 557         Eina_List *list = elm_box_children_get(idletxtbox);
 558         retif(!list, NULL, "list is NULL!");
 559
 560         label = eina_list_nth(list, 0);
 561
 562         return label;
 563 }
 564 #endif
 565
 566 static int quickpanel_idletxt_suspend(void *data)
 567 {
 568 #if QP_ENABLE_SLIDING_TEXT
 569         Evas_Object *label = _quickpanel_spn_label_get(data);
 570
 571         if (label != NULL) {
 572                 elm_label_slide_mode_set(label, ELM_LABEL_SLIDE_MODE_NONE);
 573         }
 574 #endif
 575
 576         return QP_OK;
 577 }
 578
 579 static int quickpanel_idletxt_resume(void *data)
 580 {
 581 #if QP_ENABLE_SLIDING_TEXT
 582         Evas_Object *label = _quickpanel_spn_label_get(data);
 583
 584         if (label != NULL) {
 585                 elm_label_slide_mode_set(label, ELM_LABEL_SLIDE_MODE_AUTO);
 586         }
 587 #endif
 588
 589         return QP_OK;
 590 }
 591
 592 static void quickpanel_idletxt_lang_changed(void *data)
 593 {
 594         retif(data == NULL, , "Invalid parameter!");
 595
 596         quickpanel_idletxt_update(data);
 597 }