daemon/idletxt/idletxt.c

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