src/control-panel.c

   1 /*
   2  * Copyright (c) 2009-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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 <Evas.h>
  18 #include <math.h>
  19 #include <stdbool.h>
  20
  21 #include <vconf.h>
  22 #include <aul.h>
  23 #include <app_control.h>
  24
  25 #include <utilX.h>
  26 #include <ui-gadget.h>
  27
  28 #include "lockscreen-lite.h"
  29 #include "control-panel.h"
  30 #include "progress_circle.h"
  31 #include "sim-state.h"
  32 #include "notification-item.h"
  33 #include "tizen-account.h"
  34 #include "control-panel-password.h"
  35 #include "simple-password.h"
  36
  37 #define CONTROL_PANEL_PROPORTION 0.2
  38 #define CAM_ICON_W 90
  39 #define CAM_ICON_H 90
  40 #define CAM_ICON_X 390
  41 #define CAM_ICON_Y 710
  42
  43 #define MAX_SCALE 3.0
  44 #define CAM_ICOM_MAX_W CAM_ICON_W * MAX_SCALE
  45 #define CAM_ICON_MAX_H CAM_ICON_H * MAX_SCALE
  46
  47 #define CAMERA_APP_ID "com.samsung.camera-app-lite"
  48
  49 #define UNLOCK_TEXT _("IDS_LCKSCN_BUTTON3_UNLOCK_VIA_TIZEN_ACCOUNT")
  50
  51 #define PLMN_LABEL_STYLE "<style=far_shadow,bottom><shadow_color=#00000033><font_size=24><align=left><color=#FFFFFF><text_class=ATO007><color_class=ATO007><wrap=none>"
  52
  53 #define EPS 0.00001
  54
  55 #define PLMN_LENGTH 6
  56 #define PLMN_SPN_LENGTH 32
  57 #define EMG_BUTTON_WIDTH 322
  58
  59 #define BUS_NAME "org.tizen.system.deviced"
  60 #define DEVICED_PATH_DISPLAY "/Org/Tizen/System/DeviceD/Display"
  61 #define DEVICED_INTERFACE_DISPLAY "org.tizen.system.deviced.display"
  62 #define METHOD_LOCKSCREEN_BG_ON "LockScreenBgOn"
  63 #define DBUS_REPLY_TIMEOUT -1
  64
  65 extern LKD_Module  g_mod_control_panel;
  66 static const char *bool_str[2] = {"false", "true"};
  67
  68 static struct {
  69         Evas_Object *control_panel_layout;
  70         Evas_Object *camera_icon;
  71         Evas_Object *unlock_circle;
  72         Evas_Object *unlock_background;
  73         Evas_Object *operator_name;
  74
  75         bool is_password_panel_visible;
  76
  77         struct {
  78                 int x;
  79                 int y;
  80                 int w;
  81                 int h;
  82         } camera_icon_geometry;
  83
  84         struct {
  85                 int x;
  86                 int y;
  87                 int w;
  88                 int h;
  89         } camera_bg_geometry;
  90
  91 } s_control_panel_info = {
  92         .control_panel_layout = NULL,
  93         .camera_icon = NULL,
  94         .unlock_circle = NULL,
  95         .unlock_background = NULL,
  96
  97         .is_password_panel_visible = false,
  98
  99         .camera_icon_geometry.x = 0,
 100         .camera_icon_geometry.y = 0,
 101         .camera_icon_geometry.w = 0,
 102         .camera_icon_geometry.h = 0,
 103
 104         .camera_bg_geometry.x = 0,
 105         .camera_bg_geometry.y = 0,
 106         .camera_bg_geometry.w = 0,
 107         .camera_bg_geometry.h = 0,
 108 };
 109
 110 //Unlock function
 111 static char* _plmn_spn_get();
 112
 113 static void __emg_button_clicked_cb(void *data, Evas_Object *obj, void *event_info);
 114
 115 static void __launch_emgcall(void);
 116 // static void __sim_status_print(TelSimCardStatus_t sim_status, int card_changed);
 117
 118 static void _operator_name_slide_mode_set(Evas_Object *name)
 119 {
 120         Evas_Object *name_edje;
 121         Evas_Object *tb;
 122         Evas_Coord tb_w=0;
 123
 124         if(name == NULL) {
 125                 LOCK_SCREEN_TRACE_ERR("paramter error!");
 126         }
 127
 128         elm_label_slide_mode_set(name, ELM_LABEL_SLIDE_MODE_NONE);
 129
 130         name_edje = elm_layout_edje_get(name);
 131         if(!name_edje)
 132         {
 133                 LOGE("Failed to get label edje");
 134                 return;
 135         }
 136
 137         tb = (Evas_Object*)edje_object_part_object_get(name_edje, "elm.text");
 138         if(!tb)
 139         {
 140                 LOGE("Failed to get label tb");
 141                 return;
 142         }
 143
 144         evas_object_textblock_size_native_get(tb, &tb_w, NULL);
 145
 146         if((tb_w>0) && (tb_w>ELM_SCALE_SIZE(EMG_BUTTON_WIDTH)))
 147         {
 148                 elm_label_slide_mode_set(name, ELM_LABEL_SLIDE_MODE_AUTO);
 149         }
 150         elm_label_slide_go(name);
 151 }
 152 static void _operator_sliding_label_create(Evas_Object *layout, char *text)
 153 {
 154         char buf[512] = {0,};
 155         Evas_Object *label = elm_label_add(layout);
 156         if(!label)
 157         {
 158                 LOGE("Failed to add label");
 159                 return;
 160         }
 161
 162         char *markup_text = elm_entry_utf8_to_markup(text);
 163         snprintf(buf, sizeof(buf), "%s%s</wrap></color_class></text_class></color></align></font_size></shadow_color></style>", PLMN_LABEL_STYLE, markup_text);
 164         free(markup_text);
 165
 166         elm_object_style_set(label, "slide_short");
 167         elm_label_wrap_width_set(label, 100);
 168         elm_label_ellipsis_set(label, EINA_TRUE);
 169         elm_label_slide_duration_set(label, 2);
 170         _operator_name_slide_mode_set(label);
 171
 172         elm_object_text_set(label, buf);
 173
 174         elm_object_part_content_set(layout, "emg_call_button", label);
 175         evas_object_show(label);
 176
 177         s_control_panel_info.operator_name = label;
 178 }
 179
 180 Evas_Object* control_panel_create()
 181 {
 182         LOCK_SCREEN_TRACE_DBG("");
 183
 184         Evas_Object *main_window = NULL;
 185         Evas_Object *control_panel_layout = NULL;
 186         char *operator_name = NULL;
 187
 188         main_window = lockscreen_get_window();
 189         if(!main_window)
 190         {
 191                 LOCK_SCREEN_TRACE_DBG("Failed to get the main window");
 192                 return NULL;
 193         }
 194
 195         control_panel_layout = elm_layout_add(main_window);
 196         if(!control_panel_layout)
 197         {
 198                 LOCK_SCREEN_TRACE_DBG("Failed to create control panel layout");
 199                 return NULL;
 200         }
 201
 202         if(!elm_layout_file_set(control_panel_layout, EDJE_DIR"control-panel.edj", "control_panel_layout_dual_text"))
 203         {
 204                 LOCK_SCREEN_TRACE_DBG("Failed to set file for control panel layout");
 205                 evas_object_del(control_panel_layout);
 206                 return NULL;
 207         }
 208
 209         const int w = lockscreen_get_window_width();
 210         const int h = lockscreen_get_window_height() * CONTROL_PANEL_PROPORTION;
 211
 212         evas_object_size_hint_min_set(control_panel_layout, w, h);
 213         evas_object_size_hint_max_set(control_panel_layout, w, h);
 214         evas_object_resize(control_panel_layout, w, h);
 215
 216         s_control_panel_info.control_panel_layout = control_panel_layout;
 217         evas_object_show(control_panel_layout);
 218
 219         operator_name = sim_status_network_name_get();
 220
 221         if(!operator_name || !strlen(operator_name))
 222         {
 223                 LOCK_SCREEN_TRACE_DBG("Unknown network name - setting plmn/spn");
 224                 if (operator_name)
 225                 {
 226                         free(operator_name);
 227                 }
 228                 operator_name = _plmn_spn_get();
 229         }
 230
 231         if (operator_name)
 232         {
 233                 LOCK_SCREEN_TRACE_DBG("Final network name : [%s]", operator_name);
 234                 _operator_sliding_label_create(control_panel_layout, operator_name);
 235                 free(operator_name);
 236         }
 237         else
 238         {
 239                 LOCK_SCREEN_TRACE_DBG("Unknown plmn/spn - setting empty name");
 240                 _operator_sliding_label_create(control_panel_layout, "");
 241         }
 242
 243         if (elm_object_text_get(s_control_panel_info.operator_name) == NULL)
 244         {
 245                 LOCK_SCREEN_TRACE_DBG("Failed to set network info in layout");
 246                 evas_object_del(control_panel_layout);
 247                 evas_object_del(s_control_panel_info.operator_name);
 248                 s_control_panel_info.operator_name = NULL;
 249
 250                 return NULL;
 251         }
 252
 253         control_panel_operator_name_show();
 254
 255         elm_object_part_text_set(s_control_panel_info.control_panel_layout, "unlock,text", UNLOCK_TEXT);
 256
 257         // show_unlock_text();
 258
 259         return control_panel_layout;
 260 }
 261
 262 void control_panel_sim_state_changed()
 263 {
 264         LOCK_SCREEN_TRACE_DBG("");
 265
 266         char *name = NULL;
 267
 268         if(!s_control_panel_info.control_panel_layout)
 269         {
 270                 LOCK_SCREEN_TRACE_ERR("invalid state of app : layout is NULL");
 271                 return;
 272         }
 273
 274         if(!s_control_panel_info.operator_name)
 275         {
 276                 LOCK_SCREEN_TRACE_ERR("invalid state of app : operator name label is NULL");
 277                 return;
 278         }
 279
 280         if(s_control_panel_info.operator_name)
 281         {
 282                 evas_object_del(s_control_panel_info.operator_name);
 283         }
 284
 285         name = sim_status_network_name_get();
 286         if (name) {
 287                 if (strlen(name) <= 0) {
 288                         free(name);
 289                         name = _plmn_spn_get();
 290                 }
 291         }
 292
 293         if (name) {
 294                 LOCK_SCREEN_TRACE_DBG("Final network name : [%s]", name);
 295
 296                 _operator_sliding_label_create(s_control_panel_info.control_panel_layout, name);
 297                 control_panel_operator_name_show();
 298
 299                 free(name);
 300         } else {
 301                 LOCK_SCREEN_TRACE_DBG("Unknown plmn/spn - setting empty name");
 302                 _operator_sliding_label_create(s_control_panel_info.control_panel_layout, "");
 303         }
 304
 305         _operator_name_slide_mode_set(s_control_panel_info.operator_name);
 306 }
 307
 308 void hide_emg_call_btn(void)
 309 {
 310         ret_if(s_control_panel_info.control_panel_layout == NULL);
 311
 312         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "hide,emg,btn", "");
 313 }
 314
 315 void show_emg_call_btn(void)
 316 {
 317         ret_if(s_control_panel_info.control_panel_layout == NULL);
 318
 319         hide_dual_text();
 320         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "show,emg,btn", "");
 321 }
 322
 323 void show_unlock_text(void)
 324 {
 325         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "show,unlock,text", "");
 326 }
 327
 328 void hide_unlock_text(void)
 329 {
 330         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "hide,unlock,text", "");
 331 }
 332
 333 Eina_Bool is_camera_visible(void)
 334 {
 335 #if DISABLE_CAMERA_SHORTCUT
 336         return EINA_FALSE;
 337 #else
 338         int enabled = 0;
 339         property_get_bool(LKD_PROP_ID_CAMERA_SHORTCUT_ENABLED, &enabled);
 340
 341         int emergency = 0;
 342         property_get_int(LKD_PROP_ID_ULTRA_POWER_SAVING_ENABLED, &emergency);
 343
 344         if (enabled && 2 != emergency) {
 345                 return EINA_TRUE;
 346         } else {
 347                 return EINA_FALSE;
 348         }
 349 #endif
 350 }
 351
 352 void control_panel_operator_name_hide(void)
 353 {
 354         if(s_control_panel_info.operator_name)
 355         {
 356                 evas_object_hide(s_control_panel_info.operator_name);
 357         }
 358 }
 359
 360 void control_panel_operator_name_show(void)
 361 {
 362         if(s_control_panel_info.operator_name)
 363         {
 364                 evas_object_show(s_control_panel_info.operator_name);
 365         }
 366 }
 367
 368 void control_panel_password_panel_visible_flag_set(bool state)
 369 {
 370         s_control_panel_info.is_password_panel_visible = state;
 371 }
 372
 373 void hide_dual_text(void)
 374 {
 375         // elm_layout_signal_emit(s_control_panel_info.control_panel_layout, "hide.dual.text", "default_unlock");
 376         control_panel_operator_name_show();
 377 }
 378
 379 void destroy_emg_button(void)
 380 {
 381         LOCK_SCREEN_TRACE_DBG("");
 382
 383         Evas_Object *emg_button = elm_object_part_content_get(s_control_panel_info.control_panel_layout, "emg_call_button");
 384         if(emg_button)
 385         {
 386                 evas_object_del(emg_button);
 387         }
 388 }
 389
 390 void create_emg_button(void)
 391 {
 392         elm_theme_extension_add(NULL, EDJE_DIR"lockscreen-button.edj");
 393         Evas_Object *emg_button = elm_button_add(s_control_panel_info.control_panel_layout);
 394         if(!emg_button)
 395         {
 396                 LOCK_SCREEN_TRACE_ERR("Failed to create emergency button");
 397                 return;
 398         }
 399         elm_object_part_content_set(s_control_panel_info.control_panel_layout, "emg_call_button", emg_button);
 400         if(!elm_object_part_content_get(s_control_panel_info.control_panel_layout, "emg_call_button"))
 401         {
 402                 LOCK_SCREEN_TRACE_ERR("Failed to set emergency button in swallow part");
 403                 evas_object_del(emg_button);
 404                 return;
 405         }
 406         elm_object_style_set(emg_button, "emg_cal_btn");
 407         elm_object_text_set(emg_button, _("IDS_LCKSCN_BODY_EMERGENCY_CALL"));
 408         evas_object_smart_callback_add(emg_button, "clicked", __emg_button_clicked_cb, NULL);
 409
 410         LOCK_SCREEN_TRACE_DBG("emg_button(%p)", emg_button);
 411 }
 412
 413 void control_panel_create_tizen_account_button(void)
 414 {
 415         LOCK_SCREEN_TRACE_DBG("");
 416
 417         elm_theme_extension_add(NULL, EDJE_DIR"lockscreen-button.edj");
 418
 419         Evas_Object *tizen_account_button = elm_button_add(s_control_panel_info.control_panel_layout);
 420         if(!tizen_account_button)
 421         {
 422                 LOCK_SCREEN_TRACE_ERR("Failed to create tizen account button");
 423                 return;
 424         }
 425
 426         elm_object_part_content_set(s_control_panel_info.control_panel_layout, "tizen.account.button", tizen_account_button);
 427         if(!elm_object_part_content_get(s_control_panel_info.control_panel_layout, "tizen.account.button"))
 428         {
 429                 LOCK_SCREEN_TRACE_ERR("Failed to set emergency button in swallow part");
 430                 evas_object_del(tizen_account_button);
 431                 return;
 432         }
 433
 434         elm_object_style_set(tizen_account_button, "tizen_account_btn");
 435         elm_object_text_set(tizen_account_button, _("IDS_LCKSCN_BUTTON3_UNLOCK_VIA_TIZEN_ACCOUNT"));
 436         evas_object_smart_callback_add(tizen_account_button, "clicked", (Evas_Smart_Cb)tizen_account_launch_cb, NULL);
 437 }
 438
 439 void control_panel_tizen_account_btn_show(void)
 440 {
 441         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "show.tizen.account.button", "default_unlock");
 442 }
 443
 444 void control_panel_tizen_account_btn_hide(void)
 445 {
 446         elm_object_signal_emit(s_control_panel_info.control_panel_layout, "hide.tizen.account.button", "default_unlock");
 447 }
 448
 449 static char* _plmn_spn_get()
 450 {
 451         char *ret_str = NULL;
 452         int plmn = 0;
 453         char *spn = NULL;
 454         char plmn_buf[PLMN_LENGTH] = {0, };
 455         int spn_disp_cond = VCONFKEY_TELEPHONY_DISP_INVALID;
 456
 457         if(vconf_get_int(VCONFKEY_TELEPHONY_SPN_DISP_CONDITION, &spn_disp_cond) < 0)
 458         {
 459                 LOCK_SCREEN_TRACE_DBG("Failed to get spn display condition");
 460                 goto END;
 461         }
 462
 463         if(spn_disp_cond == VCONFKEY_TELEPHONY_DISP_INVALID)
 464         {
 465                 LOCK_SCREEN_TRACE_DBG("Invalid spn display condition");
 466                 goto END;
 467         }
 468
 469         spn = vconf_get_str(VCONFKEY_TELEPHONY_SPN_NAME);
 470         if(!spn)
 471         {
 472                 LOCK_SCREEN_TRACE_DBG("Failed to get spn vconfkey");
 473                 goto END;
 474         }
 475
 476         if(vconf_get_int(VCONFKEY_TELEPHONY_PLMN, &plmn) < 0)
 477         {
 478                 LOCK_SCREEN_TRACE_DBG("Failed to get plmn vconfkey");
 479                 goto END;
 480         }
 481
 482         if(!plmn)
 483         {
 484                 LOCK_SCREEN_TRACE_DBG("Failed to get plmn");
 485                 goto END;
 486         }
 487
 488         if(snprintf(plmn_buf, PLMN_LENGTH, "%d", plmn) < 0)
 489         {
 490                 goto END;
 491         }
 492
 493         if(spn_disp_cond == VCONFKEY_TELEPHONY_DISP_SPN)
 494         {
 495                 ret_str = strdup(spn);
 496                 goto END;
 497         }
 498         else if(spn_disp_cond == VCONFKEY_TELEPHONY_DISP_PLMN)
 499         {
 500                 ret_str = strdup(plmn_buf);
 501                 goto END;
 502         }
 503         else
 504         {
 505                 char plmn_spn_buf[PLMN_SPN_LENGTH];
 506                 strcpy(plmn_spn_buf, plmn_buf);
 507                 strncat(plmn_spn_buf, "/", 1);
 508                 strncat(plmn_spn_buf, spn, strlen(spn));
 509
 510                 ret_str = strdup(plmn_spn_buf);
 511                 goto END;
 512         }
 513
 514 END:
 515         free(spn);
 516
 517         return ret_str;
 518 }
 519
 520 static void __emg_button_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 521 {
 522         lockscreen_play_tap_feedback();
 523         __launch_emgcall();
 524 }
 525
 526 void emg_button_clicked_event_emit(void)
 527 {
 528         __emg_button_clicked_cb(NULL, NULL, NULL);
 529 }
 530
 531 static void __launch_emgcall(void)
 532 {
 533         app_control_h service;
 534         app_control_create(&service);
 535
 536         UG_INIT_EFL(lockscreen_get_window(), UG_OPT_INDICATOR_ENABLE);
 537
 538         if (!service)
 539         {
 540                 LOCK_SCREEN_TRACE_DBG("Error creating application control handle");
 541                 return;
 542         }
 543
 544         if (app_control_set_operation(service, APP_CONTROL_OPERATION_DEFAULT) != APP_CONTROL_ERROR_NONE)
 545         {
 546                 LOCK_SCREEN_TRACE_DBG("Can not set operation for application control handle");
 547                 app_control_destroy(service);
 548                 return;
 549         }
 550
 551         if (app_control_set_app_id(service, "dialer-efl") != APP_CONTROL_ERROR_NONE)
 552         {
 553                 LOCK_SCREEN_TRACE_DBG("Can not launch dialer-efl");
 554                 app_control_destroy(service);
 555                 return;
 556         }
 557
 558         Ecore_X_Window xwin = 0;
 559         Ecore_X_Window_Type type = ECORE_X_WINDOW_TYPE_UNKNOWN;
 560         Utilx_Notification_Level level = UTILX_NOTIFICATION_LEVEL_LOW;
 561
 562         xwin = elm_win_xwindow_get(lockscreen_get_window());
 563         if(xwin == 0)
 564         {
 565                 LOCK_SCREEN_TRACE_DBG("elm_win_xwindow_get() failed");
 566                 app_control_destroy(service);
 567                 return;
 568         }
 569         if(ecore_x_netwm_window_type_get(xwin, &type) != EINA_TRUE)
 570         {
 571                 LOCK_SCREEN_TRACE_DBG("ecore_x_netwm_window_type_get() failed");
 572                 app_control_destroy(service);
 573                 return;
 574         }
 575
 576         if(type != ECORE_X_WINDOW_TYPE_NOTIFICATION)
 577         {
 578                 LOCK_SCREEN_TRACE_DBG("current window type is not NOTIFICATION");
 579                 app_control_add_extra_data(service, "window_property", "notification_normal");
 580         }
 581         else
 582         {
 583                 level = utilx_get_system_notification_level(ecore_x_display_get(), xwin);
 584                 if(level == UTILX_NOTIFICATION_LEVEL_HIGH)
 585                 {
 586                         app_control_add_extra_data(service, "window_property", "notification_high");
 587                 }
 588                 else
 589                 {
 590                         app_control_add_extra_data(service, "window_property", "notification_normal");
 591                 }
 592         }
 593
 594         app_control_add_extra_data(service, "emergency_dialer", "emergency");
 595
 596         if(app_control_send_launch_request(service, NULL, NULL) != APP_CONTROL_ERROR_NONE)
 597         {
 598                 LOCK_SCREEN_TRACE_DBG("service_send_request() failed");
 599         }
 600
 601         app_control_destroy(service);
 602 }
 603
 604 static void _log_dbus_error(const char *msg, DBusError *err)
 605 {
 606         if (err && dbus_error_is_set(err))
 607         {
 608                 LOCK_SCREEN_TRACE_ERR("dbus error(%s:%s)", err->name, err->message);
 609         }
 610         else if (msg)
 611         {
 612                 LOCK_SCREEN_TRACE_ERR("%s",msg);
 613         }
 614 }
 615
 616 static void _dbus_clean(DBusConnection *conn, DBusMessage *msg, DBusError *err)
 617 {
 618         if (conn)
 619         {
 620                 dbus_connection_unref(conn);
 621                 conn = NULL;
 622         }
 623         if (msg)
 624         {
 625                 dbus_message_unref(msg);
 626                 msg = NULL;
 627         }
 628         dbus_error_free(err);
 629 }
 630
 631 static DBusMessage *_invoke_dbus_method_sync(const char *dest, const char *path,
 632                 const char *interface, const char *method, const char *param)
 633 {
 634         DBusConnection *conn = NULL;
 635         DBusMessage *msg = NULL;
 636         DBusMessage *reply = NULL;
 637         dbus_bool_t is_ok = 0;
 638         DBusError err;
 639
 640         dbus_error_init(&err);
 641
 642         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 643         if (!conn)
 644         {
 645                 _log_dbus_error("Failed to connect to bus deamon",NULL);
 646                 _dbus_clean(NULL, msg, &err);
 647                 return NULL;
 648         }
 649
 650         msg = dbus_message_new_method_call(dest, path, interface, method);
 651         if (!msg)
 652         {
 653                 _log_dbus_error("Failed to create dbus message",NULL);
 654                 _dbus_clean(conn, NULL, &err);
 655                 return NULL;
 656         }
 657
 658         is_ok = dbus_message_append_args(msg, DBUS_TYPE_STRING, &param, DBUS_TYPE_INVALID);
 659         if (!is_ok)
 660         {
 661                 _log_dbus_error("Failed to create dbus message parameters",NULL);
 662                 _dbus_clean(conn, msg, &err);
 663                 return NULL;
 664         }
 665
 666         reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_REPLY_TIMEOUT, &err);
 667
 668         _log_dbus_error(NULL, &err);
 669         _dbus_clean(conn, msg, &err);
 670         return reply;
 671 }
 672
 673 static int _lockscreen_set_bg(const char *param)
 674 {
 675         DBusError err;
 676         DBusMessage *msg = NULL;
 677         bool is_ok = 0;
 678         int ret_val = 0;
 679
 680         dbus_error_init(&err);
 681
 682         msg = _invoke_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 683                         METHOD_LOCKSCREEN_BG_ON, param);
 684         if (!msg)
 685         {
 686                 _dbus_clean(NULL, NULL, &err);
 687                 return -EBADMSG;
 688         }
 689
 690         is_ok = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 691         if (!is_ok)
 692         {
 693                 ret_val = -EBADMSG;
 694                 _log_dbus_error(NULL,&err);
 695         }
 696         else
 697         {
 698                 LOCK_SCREEN_TRACE_DBG("%s-%s : %s(%d) ", DEVICED_INTERFACE_DISPLAY, METHOD_LOCKSCREEN_BG_ON, param, ret_val);
 699         }
 700
 701         _dbus_clean(NULL, msg, &err);
 702         return ret_val;
 703 }
 704
 705 void lockscreen_set_bg_on(void)
 706 {
 707         _lockscreen_set_bg(bool_str[true]);
 708 }
 709
 710 void lockscreen_set_bg_off(void)
 711 {
 712         _lockscreen_set_bg(bool_str[false]);
 713 }
 714
 715 Evas_Object *control_panel_layout_get(void)
 716 {
 717         return s_control_panel_info.control_panel_layout;
 718 }
 719
 720 void control_panel_view_init(void)
 721 {
 722         module_init(&g_mod_control_panel, NULL);
 723 }
 724
 725 void control_panel_view_fini(void)
 726 {
 727         module_fini(&g_mod_control_panel);
 728 }
 729
 730 /*!
 731  * module
 732  */
 733 static int _init(LKD_Module_Data *md)
 734 {
 735         return LKD_RET_OK;
 736 }
 737
 738 static int _fini(LKD_Module_Data *md)
 739 {
 740         return LKD_RET_OK;
 741 }
 742
 743 static void _language_changed(LKD_Module_Data * md)
 744 {
 745         control_panel_sim_state_changed();
 746 }
 747
 748 static void _property_changed(LKD_Module_Data *md, int property_id)
 749 {
 750 }
 751
 752 static void _resume(LKD_Module_Data *md)
 753 {
 754          //elm_label_slide_mode_set(s_control_panel_info.operator_name, ELM_LABEL_SLIDE_MODE_AUTO);
 755          //elm_label_slide_go(s_control_panel_info.operator_name);
 756         _operator_name_slide_mode_set(s_control_panel_info.operator_name);
 757 }
 758
 759 static void _pause(LKD_Module_Data *md)
 760 {
 761         elm_label_slide_mode_set(s_control_panel_info.operator_name, ELM_LABEL_SLIDE_MODE_NONE);
 762         elm_label_slide_go(s_control_panel_info.operator_name);
 763 }
 764
 765 LKD_Module  g_mod_control_panel = {
 766         .id = "control-panel",
 767         .notifying = 1,
 768         .property_list = LKD_PROP_ID_CAMERA_SHORTCUT_ENABLED | LKD_PROP_ID_ULTRA_POWER_SAVING_ENABLED,
 769         .init = _init,
 770         .fini = _fini,
 771         .resume = _resume,
 772         .pause = _pause,
 773         .language_changed = _language_changed,
 774         .property_changed = _property_changed,
 775 };