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