am_daemon/amd_status.c

   1 /*
   2  *  aul
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <glib.h>
  25 #include <aul.h>
  26 #include <string.h>
  27 #include <Ecore.h>
  28 #include <proc_stat.h>
  29 #include <pkgmgr-info.h>
  30 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
  31 #include <Ecore_X.h>
  32 #include <vconf/vconf.h>
  33 #endif
  34
  35 #include "amd_config.h"
  36 #include "amd_status.h"
  37 #include "amd_appinfo.h"
  38 #include "aul_util.h"
  39 #include "simple_util.h"
  40 #include "app_sock.h"
  41 #include "menu_db_util.h"
  42
  43 GSList *app_status_info_list = NULL;
  44 struct appinfomgr *_saf = NULL;
  45
  46 GHashTable *cooldown_tbl;
  47
  48 GHashTable *cooldown_black_tbl;
  49
  50 char *cooldown_list[] = {
  51 };
  52
  53 char *cooldown_black_list[] = {
  54 };
  55
  56 int cooldown_status = 0;
  57
  58 #define WHITE_LIST_COUNT 0
  59 #define BLACK_LIST_COUNT 0
  60
  61 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
  62 #define LCD_ON  "LCDOn"
  63 #define LCD_OFF "LCDOff"
  64 #define PROC_SIZE       256
  65 #define WAKE_UP_GESTURE_CLOCK           1
  66 #endif
  67
  68 int _status_add_app_info_list(char *appid, char *app_path, const char *caller, int pid, int pad_pid)
  69 {
  70         GSList *iter = NULL;
  71         app_status_info_t *info_t = NULL;
  72
  73         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
  74         {
  75                 info_t = (app_status_info_t *)iter->data;
  76                 if(pid == info_t->pid) {
  77                         return 0;
  78                 }
  79         }
  80
  81         info_t = malloc(sizeof(app_status_info_t));
  82         if (info_t == NULL) {
  83                 _E("out of memory");
  84                 return -1;
  85         }
  86
  87         memset(info_t, 0, sizeof(app_status_info_t));
  88
  89         strncpy(info_t->appid, appid, MAX_PACKAGE_STR_SIZE-1);
  90         strncpy(info_t->app_path, app_path, MAX_PACKAGE_APP_PATH_SIZE-1);
  91         if(caller)
  92                 strncpy(info_t->caller, caller, MAX_PACKAGE_STR_SIZE-1);
  93         info_t->status = STATUS_LAUNCHING;
  94         info_t->pid = pid;
  95         info_t->pad_pid = pad_pid;
  96         app_status_info_list = g_slist_append(app_status_info_list, info_t);
  97
  98         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
  99         {
 100                 info_t = (app_status_info_t *)iter->data;
 101
 102                 //SECURE_LOGD("%s, %d, %d", info_t->appid, info_t->pid, info_t->status);
 103         }
 104
 105         return 0;
 106 }
 107
 108 static Eina_Bool __app_terminate_timer_cb(void *data)
 109 {
 110         int pid = (int)data;
 111         int ret = 0;
 112
 113         _D("pid(%d)", pid);
 114
 115         ret = kill(pid, SIGKILL);
 116         if (ret == -1)
 117                 _D("send SIGKILL: %s", strerror(errno));
 118
 119         return ECORE_CALLBACK_CANCEL;
 120 }
 121
 122 int _status_update_app_info_list(int pid, int status)
 123 {
 124         GSList *iter = NULL;
 125         app_status_info_t *info_t = NULL;
 126
 127         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 128         {
 129                 info_t = (app_status_info_t *)iter->data;
 130                 if(pid == info_t->pid) {
 131                         info_t->status = status;
 132                         if(status == STATUS_DYING) {
 133                                 if(info_t->pad_pid != DEBUG_LAUNCHPAD_PID)
 134                                         ecore_timer_add(2, __app_terminate_timer_cb, info_t->pid);
 135                         }
 136                         break;
 137                 }
 138         }
 139
 140         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 141         {
 142                 info_t = (app_status_info_t *)iter->data;
 143
 144                 //SECURE_LOGD("%s, %d, %d", info_t->appid, info_t->pid, info_t->status);
 145         }
 146
 147         return 0;
 148 }
 149
 150 int _status_remove_app_info_list(int pid)
 151 {
 152         GSList *iter = NULL;
 153         app_status_info_t *info_t = NULL;
 154
 155         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 156         {
 157                 info_t = (app_status_info_t *)iter->data;
 158                 if(pid == info_t->pid) {
 159                         app_status_info_list = g_slist_remove(app_status_info_list, info_t);
 160                         free(info_t);
 161                         break;
 162                 }
 163         }
 164
 165         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 166         {
 167                 info_t = (app_status_info_t *)iter->data;
 168
 169                 //SECURE_LOGD("%s, %d, %d", info_t->appid, info_t->pid, info_t->status);
 170         }
 171
 172         return 0;
 173 }
 174
 175 int _status_get_app_info_status(int pid)
 176 {
 177         GSList *iter = NULL;
 178         app_status_info_t *info_t = NULL;
 179
 180         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 181         {
 182                 info_t = (app_status_info_t *)iter->data;
 183                 if(pid == info_t->pid) {
 184                         return info_t->status;
 185                 }
 186         }
 187
 188         return -1;
 189 }
 190
 191
 192 int _status_app_is_running(char *appid)
 193 {
 194         GSList *iter = NULL;
 195         app_status_info_t *info_t = NULL;
 196
 197         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 198         {
 199                 info_t = (app_status_info_t *)iter->data;
 200                 if( strncmp(appid, info_t->appid, MAX_PACKAGE_STR_SIZE) == 0 ) {
 201                         return info_t->pid;
 202                 }
 203         }
 204         return -1;
 205 }
 206
 207 char* _status_app_get_appid_bypid(int pid)
 208 {
 209         GSList *iter = NULL;
 210         app_status_info_t *info_t = NULL;
 211
 212         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 213         {
 214                 info_t = (app_status_info_t *)iter->data;
 215                 if( pid == info_t->pid ) {
 216                         return info_t->appid;
 217                 }
 218         }
 219         return NULL;
 220 }
 221
 222 char* _status_get_caller_by_appid(const char *appid)
 223 {
 224         GSList *iter = NULL;
 225         app_status_info_t *info_t = NULL;
 226
 227         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 228         {
 229                 info_t = (app_status_info_t *)iter->data;
 230                 if( strncmp(appid, info_t->appid, MAX_PACKAGE_STR_SIZE-1) == 0) {
 231                         return info_t->caller;
 232                 }
 233         }
 234
 235         return NULL;
 236 }
 237
 238 int _status_send_running_appinfo(int fd)
 239 {
 240         GSList *iter = NULL;
 241         app_status_info_t *info_t = NULL;
 242         app_pkt_t *pkt = NULL;
 243         int len;
 244         char tmp_pid[MAX_PID_STR_BUFSZ];
 245
 246         pkt = (app_pkt_t *) malloc(sizeof(char) * AUL_SOCK_MAXBUFF);
 247         if(!pkt) {
 248                 _E("malloc fail");
 249                 return 0;
 250         }
 251
 252         memset(pkt, 0, AUL_SOCK_MAXBUFF);
 253
 254         for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 255         {
 256                 info_t = (app_status_info_t *)iter->data;
 257                 snprintf(tmp_pid, MAX_PID_STR_BUFSZ, "%d", info_t->pid);
 258                 strncat((char *)pkt->data, tmp_pid, MAX_PID_STR_BUFSZ);
 259                 strncat((char *)pkt->data, ":", 1);
 260                 strncat((char *)pkt->data, info_t->appid, MAX_PACKAGE_STR_SIZE);
 261                 strncat((char *)pkt->data, ":", 1);
 262                 strncat((char *)pkt->data, info_t->app_path, MAX_PACKAGE_APP_PATH_SIZE);
 263                 strncat((char *)pkt->data, ";", 1);
 264         }
 265
 266         pkt->cmd = APP_RUNNING_INFO_RESULT;
 267         pkt->len = strlen((char *)pkt->data) + 1;
 268
 269         if ((len = send(fd, pkt, pkt->len + 8, 0)) != pkt->len + 8) {
 270                 if (errno == EPIPE)
 271                         _E("send failed due to EPIPE.\n");
 272                 _E("send fail to client");
 273         }
 274
 275         if(pkt)
 276                 free(pkt);
 277
 278         close(fd);
 279
 280         return 0;
 281 }
 282
 283 int _status_app_is_running_v2(char *appid)
 284 {
 285         char *apppath = NULL;
 286         int ret = 0;
 287         int i = 0;
 288         const char *ae;
 289         const struct appinfo *ai;
 290
 291         if(appid == NULL)
 292                 return -1;
 293
 294         ai = appinfo_find(_saf, appid);
 295
 296         if (ai == NULL)
 297                 return -1;
 298
 299         ae = appinfo_get_value(ai, AIT_EXEC);
 300         if (ae == NULL)
 301                 return -1;
 302
 303         apppath = strdup(ae);
 304         if (apppath == NULL) {
 305                 _E("out of memory");
 306                 return -1;
 307         }
 308
 309         /*truncate apppath if it includes default bundles */
 310         while (apppath[i] != 0) {
 311                 if (apppath[i] == ' ' || apppath[i] == '\t') {
 312                         apppath[i]='\0';
 313                         break;
 314                 }
 315                 i++;
 316         }
 317
 318         ret = __proc_iter_cmdline(NULL, apppath);
 319
 320         free(apppath);
 321
 322         return ret;
 323 }
 324
 325 static int __get_pkginfo(const char *dname, const char *cmdline, void *priv)
 326 {
 327         app_info_from_db *menu_info;
 328         char *r_info;
 329         char *pkgname = NULL;
 330         char *app_path = NULL;
 331
 332         r_info = (char *)priv;
 333
 334         if ((menu_info = _get_app_info_from_db_by_apppath(cmdline)) == NULL)
 335                 goto out;
 336         else {
 337                 pkgname = _get_pkgname(menu_info);
 338                 if (pkgname == NULL)
 339                         goto out;
 340
 341                 app_path = _get_app_path(menu_info);
 342                 if (app_path == NULL)
 343                         goto out;
 344
 345                 strncat(r_info, dname, 8);
 346                 strncat(r_info, ":", 1);
 347                 strncat(r_info, pkgname, MAX_PACKAGE_STR_SIZE);
 348                 strncat(r_info, ":", 1);
 349                 strncat(r_info, app_path, MAX_PACKAGE_APP_PATH_SIZE);
 350                 strncat(r_info, ";", 1);
 351         }
 352
 353  out:
 354         if (menu_info != NULL)
 355                 _free_app_info_from_db(menu_info);
 356         return 0;
 357 }
 358
 359 int _status_send_running_appinfo_v2(int fd)
 360 {
 361         app_pkt_t *pkt = NULL;
 362         int len;
 363
 364         pkt = (app_pkt_t *) malloc(sizeof(char) * AUL_SOCK_MAXBUFF);
 365         if(!pkt) {
 366                 _E("malloc fail");
 367                 close(fd);
 368                 return 0;
 369         }
 370
 371         memset(pkt, 0, AUL_SOCK_MAXBUFF);
 372
 373         __proc_iter_cmdline(__get_pkginfo, pkt->data);
 374
 375         pkt->cmd = APP_RUNNING_INFO_RESULT;
 376         pkt->len = strlen((char *)pkt->data) + 1;
 377
 378         if ((len = send(fd, pkt, pkt->len + 8, 0)) != pkt->len + 8) {
 379                 if (errno == EPIPE)
 380                         _E("send failed due to EPIPE.\n");
 381                 _E("send fail to client");
 382         }
 383
 384         if(pkt)
 385                 free(pkt);
 386
 387         close(fd);
 388
 389         return 0;
 390 }
 391
 392 int _status_get_pkgname_bypid(int pid, char *pkgname, int len)
 393 {
 394         char *cmdline;
 395         app_info_from_db *menu_info;
 396
 397         cmdline = __proc_get_cmdline_bypid(pid);
 398         if (cmdline == NULL)
 399                 return -1;
 400
 401         if ((menu_info = _get_app_info_from_db_by_apppath(cmdline)) == NULL) {
 402                 free(cmdline);
 403                 return -1;
 404         } else {
 405                 snprintf(pkgname, len, "%s", _get_pkgname(menu_info));
 406         }
 407
 408         free(cmdline);
 409         _free_app_info_from_db(menu_info);
 410
 411         return 0;
 412 }
 413
 414 int _status_get_appid_bypid(int fd, int pid)
 415 {
 416         app_pkt_t *pkt = NULL;
 417         int len;
 418         int pgid;
 419
 420         pkt = (app_pkt_t *) malloc(sizeof(char) * AUL_SOCK_MAXBUFF);
 421         if(!pkt) {
 422                 _E("malloc fail");
 423                 close(fd);
 424                 return 0;
 425         }
 426
 427         memset(pkt, 0, AUL_SOCK_MAXBUFF);
 428
 429         pkt->cmd = APP_GET_INFO_ERROR;
 430
 431         if (_status_get_pkgname_bypid(pid, (char *)pkt->data, MAX_PACKAGE_STR_SIZE) == 0) {
 432                 SECURE_LOGD("appid for %d is %s", pid, pkt->data);
 433                 pkt->cmd = APP_GET_INFO_OK;
 434                 goto out;
 435         }
 436         /* support app launched by shell script*/
 437         _D("second chance");
 438         pgid = getpgid(pid);
 439         if (pgid <= 1)
 440                 goto out;
 441
 442         _D("second change pgid = %d, pid = %d", pgid, pid);
 443         if (_status_get_pkgname_bypid(pgid, (char *)pkt->data, MAX_PACKAGE_STR_SIZE) == 0)
 444                 pkt->cmd = APP_GET_INFO_OK;
 445
 446  out:
 447         pkt->len = strlen((char *)pkt->data) + 1;
 448
 449         if ((len = send(fd, pkt, pkt->len + 8, 0)) != pkt->len + 8) {
 450                 if (errno == EPIPE)
 451                         _E("send failed due to EPIPE.\n");
 452                 _E("send fail to client");
 453         }
 454
 455         if(pkt)
 456                 free(pkt);
 457
 458         close(fd);
 459
 460         return 0;
 461 }
 462
 463 static int __get_pkgid_bypid(int pid, char *pkgid, int len)
 464 {
 465         char *cmdline;
 466         app_info_from_db *menu_info;
 467
 468         cmdline = __proc_get_cmdline_bypid(pid);
 469         if (cmdline == NULL)
 470                 return -1;
 471
 472         if ((menu_info = _get_app_info_from_db_by_apppath(cmdline)) == NULL) {
 473                 free(cmdline);
 474                 return -1;
 475         } else
 476                 snprintf(pkgid, len, "%s", _get_pkgid(menu_info));
 477
 478         free(cmdline);
 479         _free_app_info_from_db(menu_info);
 480
 481         return 0;
 482 }
 483
 484 int _status_get_pkgid_bypid(int fd, int pid)
 485 {
 486         app_pkt_t *pkt = NULL;
 487         int len;
 488         int pgid;
 489
 490         pkt = (app_pkt_t *) malloc(sizeof(char) * AUL_SOCK_MAXBUFF);
 491         if(!pkt) {
 492                 _E("malloc fail");
 493                 close(fd);
 494                 return 0;
 495         }
 496
 497         memset(pkt, 0, AUL_SOCK_MAXBUFF);
 498
 499         pkt->cmd = APP_GET_INFO_ERROR;
 500
 501         if (__get_pkgid_bypid(pid, (char *)pkt->data, MAX_PACKAGE_STR_SIZE) == 0) {
 502                 SECURE_LOGD("appid for %d is %s", pid, pkt->data);
 503                 pkt->cmd = APP_GET_INFO_OK;
 504                 goto out;
 505         }
 506         /* support app launched by shell script*/
 507         _D("second chance");
 508         pgid = getpgid(pid);
 509         if (pgid <= 1)
 510                 goto out;
 511
 512         _D("second change pgid = %d, pid = %d", pgid, pid);
 513         if (__get_pkgid_bypid(pgid, (char *)pkt->data, MAX_PACKAGE_STR_SIZE) == 0)
 514                 pkt->cmd = APP_GET_INFO_OK;
 515
 516  out:
 517         pkt->len = strlen((char *)pkt->data) + 1;
 518
 519         if ((len = send(fd, pkt, pkt->len + 8, 0)) != pkt->len + 8) {
 520                 if (errno == EPIPE)
 521                         _E("send failed due to EPIPE.\n");
 522                 _E("send fail to client");
 523         }
 524
 525         if(pkt)
 526                 free(pkt);
 527
 528         close(fd);
 529
 530         return 0;
 531 }
 532
 533 int _status_get_cmdline(int fd, int pid)
 534 {
 535         app_pkt_t *pkt = NULL;
 536         int len;
 537         int pgid;
 538         char *cmdline;
 539
 540         pkt = (app_pkt_t *) malloc(sizeof(char) * AUL_SOCK_MAXBUFF);
 541         if(!pkt) {
 542                 _E("malloc fail");
 543                 close(fd);
 544                 return 0;
 545         }
 546
 547         memset(pkt, 0, AUL_SOCK_MAXBUFF);
 548
 549         pkt->cmd = APP_GET_INFO_ERROR;
 550
 551         cmdline = __proc_get_cmdline_bypid(pid);
 552         if (cmdline == NULL)
 553                 goto out;
 554         _E("cmdline : %s", cmdline);
 555
 556         snprintf((char *)pkt->data, MAX_PACKAGE_STR_SIZE, cmdline);
 557         _E("pkt->data : %s", pkt->data);
 558         pkt->cmd = APP_GET_INFO_OK;
 559
 560  out:
 561         pkt->len = strlen((char *)pkt->data) + 1;
 562
 563         if ((len = send(fd, pkt, pkt->len + 8, 0)) != pkt->len + 8) {
 564                 if (errno == EPIPE)
 565                         _E("send failed due to EPIPE.\n");
 566                 _E("send fail to client");
 567         }
 568
 569         free(cmdline);
 570
 571         if(pkt)
 572                 free(pkt);
 573
 574         close(fd);
 575
 576         return 0;
 577 }
 578
 579
 580 static void __app_info_iter_limit_cb(void *user_data, const char *appid, const struct appinfo *ai)
 581 {
 582         if(!g_hash_table_lookup(cooldown_tbl, appid)) {
 583                 appinfo_set_value(ai, AIT_STATUS, "blocking");
 584         }
 585 }
 586
 587 static void __app_info_iter_waring_cb(void *user_data, const char *appid, const struct appinfo *ai)
 588 {
 589         if(g_hash_table_lookup(cooldown_black_tbl, appid)) {
 590                 appinfo_set_value(ai, AIT_STATUS, "blocking");
 591         }
 592 }
 593
 594 static void __app_info_iter_release_cb(void *user_data, const char *appid, const struct appinfo *ai)
 595 {
 596         const char *component = NULL;
 597         int onboot = 0;
 598         int restart = 0;
 599
 600         if(!g_hash_table_lookup(cooldown_tbl, appid)) {
 601                 component = appinfo_get_value(ai, AIT_COMPTYPE);
 602                 onboot = appinfo_get_boolean(ai, AIT_ONBOOT);
 603                 restart = appinfo_get_boolean(ai, AIT_RESTART);
 604                 if (onboot == 1 && restart == 1 && component && strncmp(component, "svcapp", 6) == 0)
 605                 {
 606                         if (_status_app_is_running(appid) < 0)
 607                         {
 608                                 _I("start service (cooldown release) - %s", appid);
 609                                 _start_srv(ai, NULL);
 610                         }
 611                         else
 612                         {
 613                                 _E("service: %s is already running", appid);
 614                         }
 615                 }
 616                 appinfo_set_value(ai, AIT_STATUS, "installed");
 617         }
 618 }
 619
 620
 621
 622 static int __cooldown_cb(const char* status, void *data)
 623 {
 624         GSList *iter = NULL;
 625         app_status_info_t *info_t = NULL;
 626         int ret;
 627         int dummy;
 628
 629         _I("__cooldown_cb, status: %s", status);
 630
 631         if(strncmp(status, "LimitAction", 11) == 0) {
 632                 appinfo_foreach(_saf, __app_info_iter_limit_cb, NULL);
 633                 for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 634                 {
 635                         info_t = (app_status_info_t *)iter->data;
 636                         if(!g_hash_table_lookup(cooldown_tbl, info_t->appid)) {
 637                                 proc_group_change_status(PROC_CGROUP_SET_TERMINATE_REQUEST, info_t->pid, NULL);
 638                                 ret = __app_send_raw_with_noreply(info_t->pid, APP_TERM_BY_PID_ASYNC, (unsigned char *)&dummy, sizeof(int) );
 639                         }
 640                 }
 641                 cooldown_status = COOLDOWN_LIMIT;
 642         } else if(strncmp(status, "WarningAction", 13) == 0) {
 643                 appinfo_foreach(_saf, __app_info_iter_waring_cb, NULL);
 644                 for (iter = app_status_info_list; iter != NULL; iter = g_slist_next(iter))
 645                 {
 646                         info_t = (app_status_info_t *)iter->data;
 647                         if(g_hash_table_lookup(cooldown_black_tbl, info_t->appid)) {
 648                                 proc_group_change_status(PROC_CGROUP_SET_TERMINATE_REQUEST, info_t->pid, NULL);
 649                                 ret = __app_send_raw_with_noreply(info_t->pid, APP_TERM_BY_PID_ASYNC, (unsigned char *)&dummy, sizeof(int) );
 650                         }
 651                 }
 652                 cooldown_status = COOLDOWN_WARNING;
 653         } else if (strncmp(status, "Release", 7) == 0){
 654                 appinfo_foreach(_saf, __app_info_iter_release_cb, NULL);
 655                 cooldown_status = COOLDOWN_RELEASE;
 656         }
 657
 658         return 0;
 659 }
 660
 661 int _status_get_cooldown_status(void)
 662 {
 663         return cooldown_status;
 664 }
 665
 666 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
 667 static int __lcd_status_cb(const char *lcd_status, void *data)
 668 {
 669         int gesture = -1;
 670         Ecore_X_Window win;
 671         int pid = 0;
 672         bundle *kb = NULL;
 673         char proc_file[PROC_SIZE] = {0, };
 674         static int paused_pid = 0;
 675
 676         // Check the wake-up gesture is a clock or not.
 677         // 0: Off, 1: Clock, 2: Last viewed screen
 678         if (vconf_get_int(VCONFKEY_WMS_WAKEUP_BY_GESTURE_SETTING, &gesture) < 0) {
 679                 _E("Failed to get VCONFKEY_WMS_WAKEUP_BY_GESTURE_SETTING");
 680                 return 0;
 681         }
 682
 683         if (gesture == WAKE_UP_GESTURE_CLOCK) {
 684                 SECURE_LOGD("Skip when wake-up gesture is a Clock.");
 685                 return 0;
 686         }
 687
 688         // Get the topmost app
 689         win = ecore_x_window_focus_get();
 690         if (ecore_x_netwm_pid_get(win, &pid) != 1) {
 691                 _E("Can't get pid for focus x window (%x)", win);
 692                 return 0;
 693         }
 694         SECURE_LOGD("The topmost app's pid is %d.", pid);
 695
 696         // Pause or Resume the app when the lcd becomes On/Off
 697         if (lcd_status && (strncmp(lcd_status, LCD_OFF, strlen(LCD_OFF)) == 0)) {
 698                 SECURE_LOGD("LCD status becomes Off. Pause the topmose app, %d", pid);
 699                 paused_pid = pid;
 700                 kb = bundle_create();
 701                 app_send_cmd_with_noreply(pid, APP_PAUSE_LCD_OFF, kb);
 702         }
 703         else if (lcd_status && (strncmp(lcd_status, LCD_ON, strlen(LCD_ON)) == 0)) {
 704                 if (paused_pid != pid) {
 705                         SECURE_LOGE("The topmost app(%d) is different with the paused app(%d).", pid, paused_pid);
 706                 }
 707
 708                 // Check whether the paused app is running or Not
 709                 snprintf(proc_file, PROC_SIZE, "/proc/%d/cmdline", paused_pid);
 710                 if (access(proc_file, F_OK) != 0) {
 711                         SECURE_LOGE("paused app(%d) seems to be killed.", paused_pid);
 712                         if (paused_pid != pid) {
 713                                 paused_pid = pid;
 714                         } else {
 715                                 return 0;
 716                         }
 717                 }
 718
 719                 SECURE_LOGD("LCD status becomes On. Resume the paused app, %d", paused_pid);
 720                 kb = bundle_create();
 721                 app_send_cmd_with_noreply(paused_pid, APP_RESUME_LCD_ON, kb);
 722         }
 723         else {
 724                 _E("Invalid input param for lcd_status.");
 725         }
 726
 727         bundle_free(kb);
 728         return 0;
 729 }
 730 #endif
 731
 732 static int __app_info_handler (const pkgmgrinfo_appinfo_h handle, void *data)
 733 {
 734         char *tmp_appid;
 735         char *appid;
 736
 737         pkgmgrinfo_appinfo_get_appid(handle, &tmp_appid);
 738
 739         appid = strdup(tmp_appid);
 740
 741         g_hash_table_insert(cooldown_tbl, appid, appid);
 742
 743         SECURE_LOGD("white_list : %s", appid);
 744
 745         return 0;
 746 }
 747
 748 static int __blacklist_app_info_handler (const pkgmgrinfo_appinfo_h handle, void *data)
 749 {
 750         char *tmp_appid;
 751         char *appid;
 752
 753         pkgmgrinfo_appinfo_get_appid(handle, &tmp_appid);
 754
 755         appid = strdup(tmp_appid);
 756
 757         g_hash_table_insert(cooldown_black_tbl, appid, appid);
 758
 759         SECURE_LOGD("white_list : %s", appid);
 760
 761         return 0;
 762 }
 763
 764 int _status_init(struct amdmgr* amd)
 765 {
 766         int i;
 767         pkgmgrinfo_appinfo_h handle = NULL;
 768
 769         _saf = amd->af;
 770
 771         aul_listen_cooldown_signal(__cooldown_cb, NULL);
 772
 773         cooldown_tbl = g_hash_table_new(g_str_hash, g_str_equal);
 774         for(i = 0; i < WHITE_LIST_COUNT; i++) {
 775                 SECURE_LOGD("pkgid %s", cooldown_list[i]);
 776                 if (pkgmgrinfo_pkginfo_get_pkginfo(cooldown_list[i], &handle) == PMINFO_R_OK){
 777                         pkgmgrinfo_appinfo_get_list(handle, PMINFO_SVC_APP, __app_info_handler, NULL);
 778                         pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, __app_info_handler, NULL);
 779                         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 780                 }
 781         }
 782
 783         cooldown_black_tbl = g_hash_table_new(g_str_hash, g_str_equal);
 784         for(i = 0; i < BLACK_LIST_COUNT; i++) {
 785                 SECURE_LOGD("pkgid %s", cooldown_black_list[i]);
 786                 if (pkgmgrinfo_pkginfo_get_pkginfo(cooldown_black_list[i], &handle) == PMINFO_R_OK){
 787                         pkgmgrinfo_appinfo_get_list(handle, PMINFO_SVC_APP, __blacklist_app_info_handler, NULL);
 788                         pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, __blacklist_app_info_handler, NULL);
 789                         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 790                 }
 791         }
 792
 793 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
 794         // Register callback for LCD On/Off
 795         aul_listen_lcd_status_signal(__lcd_status_cb, NULL);
 796 #endif
 797         return 0;
 798 }
 799