src/mobile/home_mgr.c

   1 /*
   2  * Copyright (c) 2000 - 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 <aul.h>
  18 #include <app.h>
  19 #include <db-util.h>
  20 #include <Elementary.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <pkgmgr-info.h>
  24 #include <stdio.h>
  25 #include <dd-deviced.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <unistd.h>
  29 #include <vconf.h>
  30
  31 #include "util.h"
  32 #include "dbus_util.h"
  33 #include "status.h"
  34 #include "process_mgr.h"
  35 #include "popup.h"
  36
  37 #define HOME_TERMINATED "home_terminated"
  38 #define ISTRUE "TRUE"
  39 #define SYSPOPUPID_VOLUME "volume"
  40
  41 #define DEAD_TIMER_SEC 10.0
  42 #define DEAD_TIMER_COUNT_MAX 2
  43
  44
  45
  46 int errno;
  47 static struct {
  48         pid_t home_pid;
  49         pid_t volume_pid;
  50         int power_off;
  51
  52         Ecore_Timer *dead_timer;
  53         int dead_count;
  54
  55         Evas_Object *popup;
  56 } s_home_mgr = {
  57         .home_pid = (pid_t)-1,
  58         .volume_pid = (pid_t)-1,
  59         .power_off = 0,
  60
  61         .dead_timer = NULL,
  62         .dead_count = 0,
  63
  64         .popup = NULL,
  65 };
  66
  67
  68 int home_mgr_get_home_pid(void)
  69 {
  70         return s_home_mgr.home_pid;
  71 }
  72
  73
  74
  75 int home_mgr_get_volume_pid(void)
  76 {
  77         return s_home_mgr.volume_pid;
  78 }
  79
  80
  81
  82 static void _after_launch_home(int pid)
  83 {
  84         if (dbus_util_send_oomadj(pid, OOM_ADJ_VALUE_HOMESCREEN) < 0){
  85                 _E("failed to send oom dbus signal");
  86         }
  87         s_home_mgr.home_pid = pid;
  88 }
  89
  90
  91
  92 static int _change_home_cb(const char *appid, const char *key, const char *value, void *cfn, void *afn)
  93 {
  94         if (!strcmp(appid, MENU_SCREEN_PKG_NAME)) {
  95                 _E("We cannot do anything anymore.");
  96         } else if (!strcmp(appid, status_active_get()->setappl_selected_package_name)) {
  97                 if (vconf_set_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, MENU_SCREEN_PKG_NAME) != 0) {
  98                         _E("cannot set the vconf key as %s", MENU_SCREEN_PKG_NAME);
  99                 }
 100                 /* change_home func will be called by changing the home */
 101                 return 0;
 102         }
 103         _E("cannot change home");
 104         return -1;
 105 }
 106
 107
 108
 109 #define SERVICE_OPERATION_MAIN_KEY "__APP_SVC_OP_TYPE__"
 110 #define SERVICE_OPERATION_MAIN_VALUE "http://tizen.org/appcontrol/operation/main"
 111 void home_mgr_open_home(const char *appid)
 112 {
 113         char *home_appid = NULL;
 114
 115         if (status_passive_get()->idle_screen_safemode) {
 116                 _D("SAFE MODE is enabled");
 117                 home_appid = MENU_SCREEN_PKG_NAME;
 118         } else if (!appid) {
 119                 home_appid = status_active_get()->setappl_selected_package_name;
 120         } else {
 121                 home_appid = (char *) appid;
 122         }
 123         ret_if(!home_appid);
 124
 125         process_mgr_must_launch(home_appid, SERVICE_OPERATION_MAIN_KEY, SERVICE_OPERATION_MAIN_VALUE, _change_home_cb, _after_launch_home);
 126 }
 127
 128
 129
 130 static int _show_home_cb(status_active_key_e key, void *data)
 131 {
 132         int seq = status_active_get()->starter_sequence;
 133         int is_fallback = 0;
 134
 135         _D("[MENU_DAEMON] _show_home_cb is invoked(%d)", seq);
 136
 137         switch (seq) {
 138         case 0:
 139                 if (s_home_mgr.home_pid > 0) {
 140                         _D("Home[%d] has to be terminated.", s_home_mgr.home_pid);
 141                         if (aul_terminate_pid(s_home_mgr.home_pid) != AUL_R_OK) {
 142                                 _E("Failed to terminate %d", s_home_mgr.home_pid);
 143                         }
 144                         s_home_mgr.home_pid = -1; /* to freeze the dead_cb */
 145                 }
 146                 break;
 147         case 1:
 148                 if (vconf_get_int(VCONFKEY_STARTER_IS_FALLBACK, &is_fallback) < 0) {
 149                         _E("Failed to get vconfkey : %s", VCONFKEY_STARTER_IS_FALLBACK);
 150                 }
 151
 152                 if (is_fallback) {
 153                         if (vconf_set_int(VCONFKEY_STARTER_IS_FALLBACK, 0)) {
 154                                 _E("Failed to set vconfkey : %s", VCONFKEY_STARTER_IS_FALLBACK);
 155                         }
 156
 157                         if (!strcmp(status_active_get()->setappl_selected_package_name, MENU_SCREEN_PKG_NAME)) {
 158                                 char *fallback_pkg;
 159
 160                                 fallback_pkg = vconf_get_str(VCONFKEY_STARTER_FALLBACK_PKG);
 161                                 _D("fallback pkg : %s", fallback_pkg);
 162                                 if (fallback_pkg) {
 163                                         int status;
 164
 165                                         status = vconf_set_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, fallback_pkg);
 166                                         free(fallback_pkg);
 167                                         if (status == 0) {
 168                                                 break;
 169                                         }
 170                                         _E("Failed to set vconfkey : %s (%d)", VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, status);
 171                                 } else {
 172                                         _E("Failed to get vconfkey : %s", VCONFKEY_STARTER_FALLBACK_PKG);
 173                                 }
 174                         }
 175                 }
 176
 177                 home_mgr_open_home(NULL);
 178                 break;
 179         default:
 180                 _E("False sequence [%d]", seq);
 181                 break;
 182         }
 183
 184         return 1;
 185 }
 186
 187
 188
 189 static int _change_selected_package_name(status_active_key_e key, void *data)
 190 {
 191         char *appid = NULL;
 192         int seq = status_active_get()->starter_sequence;
 193
 194         /**
 195          * @todo
 196          * Sequence is not changed. it should be managed by WHO?
 197          */
 198         seq = 1;
 199
 200         if (seq < 1) {
 201                 _E("Sequence is not ready yet, do nothing");
 202                 return 1;
 203         }
 204
 205         _D("_change_selected_package_name is invoked");
 206
 207         appid = status_active_get()->setappl_selected_package_name;
 208         if (!appid) {
 209                 return 1;
 210         }
 211         _SECURE_D("pkg_name : %s", appid);
 212
 213         if (s_home_mgr.home_pid > 0) {
 214                 char old_appid[BUF_SIZE_512] = { 0 , };
 215
 216                 if (aul_app_get_pkgname_bypid(s_home_mgr.home_pid, old_appid, sizeof(old_appid)) == AUL_R_OK) {
 217                         if (!strcmp(appid, old_appid)) {
 218                                 _D("Package is changed but same package is selected");
 219                                 return 1;
 220                         }
 221                 }
 222
 223                 if (AUL_R_OK != aul_terminate_pid(s_home_mgr.home_pid)) {
 224                         _D("Failed to terminate pid %d", s_home_mgr.home_pid);
 225                 }
 226                 s_home_mgr.home_pid = -1;
 227                 s_home_mgr.dead_count = 0;
 228                 if (s_home_mgr.dead_timer) {
 229                         ecore_timer_del(s_home_mgr.dead_timer);
 230                         s_home_mgr.dead_timer = NULL;
 231                 }
 232         }
 233
 234         home_mgr_open_home(appid);
 235
 236         return 1;
 237 }
 238
 239
 240
 241 static void _after_launch_volume(int pid)
 242 {
 243         if (dbus_util_send_oomadj(pid, OOM_ADJ_VALUE_DEFAULT) < 0){
 244                 _E("failed to send oom dbus signal");
 245         }
 246         s_home_mgr.volume_pid = pid;
 247 }
 248
 249
 250
 251 static void _launch_after_home(int pid)
 252 {
 253         if (pid > 0) {
 254                 if(dbus_util_send_oomadj(pid, OOM_ADJ_VALUE_HOMESCREEN) < 0){
 255                         _E("failed to send oom dbus signal");
 256                 }
 257         }
 258         s_home_mgr.home_pid = pid;
 259 }
 260
 261
 262
 263 static void _launch_home(const char *appid)
 264 {
 265         const char *home_appid = NULL;
 266
 267         if (status_passive_get()->idle_screen_safemode) {
 268                 home_appid = MENU_SCREEN_PKG_NAME;
 269         } else if (!appid) {
 270                 home_appid = status_active_get()->setappl_selected_package_name;
 271         } else {
 272                 home_appid = (char *) appid;
 273         }
 274         ret_if(!home_appid);
 275
 276         process_mgr_must_launch(home_appid, HOME_TERMINATED, ISTRUE, _change_home_cb, _launch_after_home);
 277 }
 278
 279
 280
 281 static void _popup_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 282 {
 283         _D("popup is deleted");
 284
 285         s_home_mgr.popup = NULL;
 286 }
 287
 288
 289
 290 static Eina_Bool _dead_timer_cb(void *data)
 291 {
 292         Evas_Object *popup = NULL;
 293         char title[BUF_SIZE_128] = { 0, };
 294         char text[BUF_SIZE_1024] = { 0, };
 295         char *appid = NULL;
 296
 297         appid = status_active_get()->setappl_selected_package_name;
 298         if (!appid) {
 299                 _E("appid is NULL");
 300                 return ECORE_CALLBACK_CANCEL;
 301         }
 302
 303         _D("dead count : %s(%d)", appid, s_home_mgr.dead_count);
 304
 305         if (s_home_mgr.dead_count >= DEAD_TIMER_COUNT_MAX) {
 306                 _D("Change homescreen package to default");
 307
 308                 if (vconf_set_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, MENU_SCREEN_PKG_NAME) != 0) {
 309                         _E("cannot set the vconf key as %s", MENU_SCREEN_PKG_NAME);
 310                         return ECORE_CALLBACK_RENEW;
 311                 }
 312
 313                 strncpy(title, _("IDS_COM_POP_WARNING"), sizeof(title));
 314                 title[sizeof(title) - 1] = '\0';
 315
 316                 snprintf(text, sizeof(text), _("IDS_IDLE_POP_UNABLE_TO_LAUNCH_PS"), appid);
 317                 _D("title : %s / text : %s", title, text);
 318
 319                 if (!s_home_mgr.popup) {
 320                         popup = popup_create(title, text);
 321                         if (!popup) {
 322                                 _E("Failed to create popup");
 323                         } else {
 324                                 s_home_mgr.popup = popup;
 325                                 evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _popup_del_cb, NULL);
 326                         }
 327                 }
 328
 329                 /* set fallback status */
 330                 if (vconf_set_int(VCONFKEY_STARTER_IS_FALLBACK, 1) < 0) {
 331                         _E("Failed to set vconfkey : %s", VCONFKEY_STARTER_IS_FALLBACK);
 332                 }
 333
 334                 if (vconf_set_str(VCONFKEY_STARTER_FALLBACK_PKG, appid) < 0) {
 335                         _E("Failed to set vconfkey : %s", VCONFKEY_STARTER_FALLBACK_PKG);
 336                 }
 337         }
 338
 339         s_home_mgr.dead_timer = NULL;
 340         s_home_mgr.dead_count = 0;
 341
 342         return ECORE_CALLBACK_CANCEL;
 343 }
 344
 345
 346
 347 void home_mgr_relaunch_homescreen(void)
 348 {
 349         char *appid = NULL;
 350
 351         if (s_home_mgr.power_off) {
 352                 _E("power off");
 353                 return;
 354         }
 355
 356         appid = status_active_get()->setappl_selected_package_name;
 357         if (!appid) {
 358                 _E("appid is NULL");
 359                 return;
 360         }
 361
 362         s_home_mgr.dead_count++;
 363         _D("home dead count : %d", s_home_mgr.dead_count);
 364
 365         if (!s_home_mgr.dead_timer) {
 366                 _D("Add dead timer");
 367                 s_home_mgr.dead_timer = ecore_timer_add(DEAD_TIMER_SEC, _dead_timer_cb, NULL);
 368                 if (!s_home_mgr.dead_timer) {
 369                         _E("Failed to add a dead timer");
 370                 }
 371         }
 372
 373         _launch_home(appid);
 374 }
 375
 376
 377
 378 void home_mgr_relaunch_volume(void)
 379 {
 380         process_mgr_must_syspopup_launch(SYSPOPUPID_VOLUME, NULL, NULL, NULL, _after_launch_volume);
 381 }
 382
 383
 384
 385 static int _power_off_cb(status_active_key_e key, void *data)
 386 {
 387         int val = status_active_get()->sysman_power_off_status;
 388
 389         if (val == VCONFKEY_SYSMAN_POWER_OFF_DIRECT || val == VCONFKEY_SYSMAN_POWER_OFF_RESTART) {
 390                 s_home_mgr.power_off = 1;
 391         } else {
 392                 s_home_mgr.power_off = 0;
 393         }
 394
 395         _D("power off status : %d", s_home_mgr.power_off);
 396
 397         return 1;
 398 }
 399
 400
 401
 402 static Eina_Bool _launch_volume_idler_cb(void *data)
 403 {
 404         process_mgr_must_syspopup_launch(SYSPOPUPID_VOLUME, NULL, NULL, NULL, _after_launch_volume);
 405         return ECORE_CALLBACK_CANCEL;
 406 }
 407
 408
 409
 410 void home_mgr_init(void *data)
 411 {
 412         _D( "[MENU_DAEMON]home_mgr_init is invoked");
 413
 414         status_active_register_cb(STATUS_ACTIVE_KEY_STARTER_SEQUENCE, _show_home_cb, NULL);
 415         status_active_register_cb(STATUS_ACTIVE_KEY_SYSMAN_POWER_OFF_STATUS, _power_off_cb, NULL);
 416         status_active_register_cb(STATUS_ACTIVE_KEY_SETAPPL_SELECTED_PACKAGE_NAME, _change_selected_package_name, NULL);
 417         _change_selected_package_name(STATUS_ACTIVE_KEY_SETAPPL_SELECTED_PACKAGE_NAME, NULL);
 418
 419         ecore_idler_add(_launch_volume_idler_cb, NULL);
 420 }
 421
 422
 423
 424 void home_mgr_fini(void)
 425 {
 426         if (s_home_mgr.volume_pid > 0) {
 427                 process_mgr_terminate_app(s_home_mgr.volume_pid, 1);
 428                 s_home_mgr.volume_pid = -1;
 429         }
 430
 431         status_active_unregister_cb(STATUS_ACTIVE_KEY_STARTER_SEQUENCE, _show_home_cb);
 432         status_active_unregister_cb(STATUS_ACTIVE_KEY_SYSMAN_POWER_OFF_STATUS, _power_off_cb);
 433         status_active_unregister_cb(STATUS_ACTIVE_KEY_SETAPPL_SELECTED_PACKAGE_NAME, _change_selected_package_name);
 434 }
 435
 436
 437
 438 // End of a file