4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <dbus/dbus-glib-lowlevel.h>
26 #include "app_signal.h"
28 #include "simple_util.h"
32 static int (*_app_dead_handler) (int pid, void *data);
33 static void *_app_dead_data;
35 static int (*_app_launch_handler) (int pid, void *data);
36 static void *_app_launch_data;
38 static int (*_app_launch_handler2) (int pid, const char *app_id, void *data);
39 static void *_app_launch_data2;
41 static int (*_booting_done_handler) (int pid, void *data);
42 static void *_booting_done_data;
44 static int (*_status_handler) (int pid, int status, void *data);
45 static void *_status_data;
47 static int (*_cooldown_handler) (const char *cooldown_status, void *data);
48 static void *_cooldown_data;
50 static DBusConnection *bus;
51 static int app_dbus_signal_handler_initialized = 0;
54 DBusConnection* conn = NULL;
56 static DBusHandlerResult
57 __app_dbus_signal_filter(DBusConnection *conn, DBusMessage *message,
61 const char *interface;
62 const char *cooldown_status;
67 dbus_error_init(&error);
69 sender = dbus_message_get_sender(message);
71 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
73 /*if (dbus_bus_get_unix_user(conn, sender, &error) != 0) {
74 _E("reject by security issue - no allowed sender\n");
75 dbus_error_free(&error);
76 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
79 interface = dbus_message_get_interface(message);
80 if (interface == NULL) {
81 _E("reject by security issue - no interface\n");
82 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
85 if (dbus_message_is_signal(
86 message, interface, AUL_DBUS_APPDEAD_SIGNAL)) {
87 if (_app_dead_handler) {
88 if (dbus_message_get_args(message, &error,
89 DBUS_TYPE_UINT32, &pid,
90 DBUS_TYPE_INVALID) == FALSE) {
91 _E("Failed to get data: %s", error.message);
92 dbus_error_free(&error);
93 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
95 _app_dead_handler(pid, _app_dead_data);
97 } else if (dbus_message_is_signal(
98 message, interface, AUL_DBUS_APPLAUNCH_SIGNAL)) {
99 if (_app_launch_handler || _app_launch_handler2) {
100 const char *app_id = NULL;
102 if (dbus_message_get_args(message, &error,
103 DBUS_TYPE_UINT32, &pid,
104 DBUS_TYPE_STRING, &app_id,
105 DBUS_TYPE_INVALID) == FALSE) {
106 _E("Failed to get data: %s", error.message);
107 dbus_error_free(&error);
108 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
111 if (_app_launch_handler)
112 _app_launch_handler(pid, _app_launch_data);
114 if (_app_launch_handler2)
115 _app_launch_handler2(pid, app_id, _app_launch_data2);
117 } else if (dbus_message_is_signal(
118 message, interface, SYSTEM_SIGNAL_BOOTING_DONE)) {
119 if (_booting_done_handler)
120 _booting_done_handler(pid, _booting_done_data);
121 } else if (dbus_message_is_signal(
122 message, interface, RESOURCED_SIGNAL_PROCESS_STATUS)) {
123 if (_status_handler) {
124 if (dbus_message_get_args(message, &error,
125 DBUS_TYPE_INT32,&status,
126 DBUS_TYPE_INT32,&pid,
127 DBUS_TYPE_INVALID) == FALSE) {
128 _E("Failed to get data: %s", error.message);
129 dbus_error_free(&error);
130 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
132 _status_handler(pid, status, _status_data);
134 } else if (dbus_message_is_signal(
135 message, interface, SYSTEM_SIGNAL_COOLDOWN_CHANGED)) {
136 if (_cooldown_handler) {
137 if (dbus_message_get_args(message, &error,
138 DBUS_TYPE_STRING, &cooldown_status,
139 DBUS_TYPE_INVALID) == FALSE) {
140 _E("Failed to get data: %s", error.message);
141 dbus_error_free(&error);
142 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
144 _cooldown_handler(cooldown_status, _cooldown_data);
148 return DBUS_HANDLER_RESULT_HANDLED;
151 static int __app_dbus_signal_handler_init_with_param(const char* path, const char* interface)
154 char rule[MAX_LOCAL_BUFSZ];
156 dbus_error_init(&error);
157 bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
159 _E("Failed to connect to the D-BUS daemon: %s", error.message);
160 dbus_error_free(&error);
163 dbus_connection_setup_with_g_main(bus, NULL);
165 snprintf(rule, MAX_LOCAL_BUFSZ,
166 "path='%s',type='signal',interface='%s'", path, interface);
167 /* listening to messages */
168 dbus_bus_add_match(bus, rule, &error);
169 if (dbus_error_is_set(&error)) {
170 _E("Fail to rule set: %s", error.message);
171 dbus_error_free(&error);
175 if (dbus_connection_add_filter(bus,
176 __app_dbus_signal_filter, NULL, NULL) == FALSE) {
177 _E("add filter fail");
181 _D("app signal initialized");
186 static int __app_dbus_signal_handler_init(void)
190 if (app_dbus_signal_handler_initialized)
193 ret = __app_dbus_signal_handler_init_with_param(AUL_DBUS_PATH, AUL_DBUS_SIGNAL_INTERFACE);
195 app_dbus_signal_handler_initialized = 1;
200 static int __app_dbus_signal_handler_fini_with_param(const char* path, const char* interface)
203 char rule[MAX_LOCAL_BUFSZ];
206 dbus_error_init(&error);
208 dbus_connection_remove_filter(bus, __app_dbus_signal_filter, NULL);
210 snprintf(rule, MAX_LOCAL_BUFSZ,
211 "path='%s',type='signal',interface='%s'", path, interface);
212 dbus_bus_remove_match(bus, rule, &error);
213 if (dbus_error_is_set(&error)) {
214 _E("Fail to rule unset: %s", error.message);
215 dbus_error_free(&error);
219 dbus_connection_close(bus);
220 dbus_connection_unref(bus);
222 _D("app signal finialized");
227 static int __app_dbus_signal_handler_fini(void)
231 if (!app_dbus_signal_handler_initialized)
234 ret = __app_dbus_signal_handler_fini_with_param(AUL_DBUS_PATH, AUL_DBUS_SIGNAL_INTERFACE);
236 app_dbus_signal_handler_initialized = 0;
241 SLPAPI int aul_listen_app_dead_signal(int (*func) (int, void *), void *data)
244 if (__app_dbus_signal_handler_init() < 0) {
245 _E("error app signal init");
248 } else if (_app_launch_handler == NULL && _app_launch_handler2 == NULL) {
249 if (__app_dbus_signal_handler_fini() < 0) {
250 _E("error app signal fini");
254 _app_dead_handler = func;
255 _app_dead_data = data;
260 SLPAPI int aul_listen_app_launch_signal(int (*func) (int, void *), void *data)
263 if (__app_dbus_signal_handler_init() < 0) {
264 _E("error app signal init");
267 } else if (_app_launch_handler2 == NULL && _app_dead_handler == NULL) {
268 if (__app_dbus_signal_handler_fini() < 0) {
269 _E("error app signal fini");
273 _app_launch_handler = func;
274 _app_launch_data = data;
279 SLPAPI int aul_listen_app_launch_signal_v2(int (*func) (int, const char *, void *), void *data)
282 if (__app_dbus_signal_handler_init() < 0) {
283 _E("error app signal init");
286 } else if (_app_launch_handler == NULL && _app_dead_handler == NULL) {
287 if (__app_dbus_signal_handler_fini() < 0) {
288 _E("error app signal fini");
293 _app_launch_handler2 = func;
294 _app_launch_data2 = data;
299 SLPAPI int aul_listen_booting_done_signal(int (*func) (int, void *), void *data)
302 if (__app_dbus_signal_handler_init_with_param(SYSTEM_PATH_CORE, SYSTEM_INTERFACE_CORE) < 0) {
303 _E("error app signal init");
306 } else if (_booting_done_handler == NULL) {
307 if (__app_dbus_signal_handler_fini_with_param(SYSTEM_PATH_CORE, SYSTEM_INTERFACE_CORE) < 0) {
308 _E("error app signal fini");
312 _booting_done_handler = func;
313 _booting_done_data = data;
319 SLPAPI int aul_listen_cooldown_signal(int (*func) (const char *, void *), void *data)
322 if (__app_dbus_signal_handler_init_with_param(SYSTEM_PATH_SYSNOTI, SYSTEM_INTERFACE_SYSNOTI) < 0) {
323 _E("error app signal init");
326 } else if (_cooldown_handler == NULL) {
327 if (__app_dbus_signal_handler_fini_with_param(SYSTEM_PATH_SYSNOTI, SYSTEM_INTERFACE_SYSNOTI) < 0) {
328 _E("error app signal fini");
332 _cooldown_handler = func;
333 _cooldown_data = data;
339 SLPAPI int aul_listen_e17_status_signal(int (*func) (int, int, void *), void *data)
342 if (__app_dbus_signal_handler_init_with_param(RESOURCED_PATH_CORE, RESOURCED_INTERFACE_CORE) < 0) {
343 _E("error app signal init");
347 _status_handler = func;
353 SLPAPI int aul_update_freezer_status(int pid, const char* type)
356 DBusConnection* conn = NULL;
357 DBusMessage* msg = NULL;
358 dbus_uint32_t serial = 0;
362 dbus_error_init(&err);
364 _W("send_update_freezer_status, pid: %d, type: %s", pid, type);
366 conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
368 _E("Fail to dbus_bus_get : %s", err.message);
372 msg = dbus_message_new_signal(RESOURCED_PROC_OBJECT,
373 RESOURCED_PROC_INTERFACE,
374 RESOURCED_PROC_METHOD);
376 _E("Could not create DBus Message.");
381 if (!dbus_message_append_args(msg,
382 DBUS_TYPE_STRING, &type,
383 DBUS_TYPE_INT32, &pid,
384 DBUS_TYPE_INVALID)) {
385 _E("Failed to append a D-Bus Message.");
389 if (!dbus_connection_send(conn, msg, &serial)) {
390 _E("Failed to send a D-Bus Message.");
394 dbus_connection_flush(conn);
397 dbus_error_free(&err);
400 dbus_message_unref(msg);
404 dbus_connection_unref(conn);
411 int __app_status_dbus_init(void)
418 dbus_error_init(&err);
419 conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
424 SLPAPI int aul_send_app_launch_request_signal(int pid, const char* appid, const char* pkgid, const char* type)
426 DBusMessage* msg = NULL;
427 dbus_uint32_t serial = 0;
431 __app_status_dbus_init();
433 _W("send_app_launch_signal, pid: %d, appid: %s", pid, appid);
435 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
436 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
437 AUL_APP_STATUS_DBUS_LAUNCH_REQUEST);
439 _E("Could not create DBus Message.");
444 if (!dbus_message_append_args(msg,
445 DBUS_TYPE_INT32, &pid,
446 DBUS_TYPE_STRING, &appid,
447 DBUS_TYPE_STRING, &pkgid,
448 DBUS_TYPE_STRING, &type,
449 DBUS_TYPE_INVALID)) {
450 _E("Failed to append a D-Bus Message.");
454 if (!dbus_connection_send(conn, msg, &serial)) {
455 _E("Failed to send a D-Bus Message.");
459 dbus_connection_flush(conn);
463 dbus_message_unref(msg);
468 SLPAPI int aul_send_app_resume_request_signal(int pid, const char* appid, const char* pkgid, const char* type)
470 DBusMessage* msg = NULL;
471 dbus_uint32_t serial = 0;
472 const char *empty_string = "";
476 __app_status_dbus_init();
478 _W("send_app_resume_signal, pid: %d, appid: %s", pid, appid);
480 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
481 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
482 AUL_APP_STATUS_DBUS_RESUME_REQUEST);
484 _E("Could not create DBus Message.");
490 if (!dbus_message_append_args(msg,
491 DBUS_TYPE_INT32, &pid,
492 DBUS_TYPE_STRING, &appid,
493 DBUS_TYPE_STRING, &pkgid,
494 DBUS_TYPE_STRING, &type,
495 DBUS_TYPE_INVALID)) {
496 _E("Failed to append a D-Bus Message.");
500 if (!dbus_message_append_args(msg,
501 DBUS_TYPE_INT32, &pid,
502 DBUS_TYPE_STRING, &empty_string,
503 DBUS_TYPE_STRING, &empty_string,
504 DBUS_TYPE_STRING, &empty_string,
505 DBUS_TYPE_INVALID)) {
506 _E("Failed to append a D-Bus Message.");
511 if (!dbus_connection_send(conn, msg, &serial)) {
512 _E("Failed to send a D-Bus Message.");
516 dbus_connection_flush(conn);
520 dbus_message_unref(msg);
526 SLPAPI int aul_send_app_terminate_request_signal(int pid, const char* appid, const char* pkgid, const char *type)
528 DBusMessage* msg = NULL;
529 dbus_uint32_t serial = 0;
530 const char *empty_string = "";
534 __app_status_dbus_init();
536 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
537 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
538 AUL_APP_STATUS_DBUS_TERMINATE_REQUEST);
540 _E("Could not create DBus Message.");
546 if (!dbus_message_append_args(msg,
547 DBUS_TYPE_INT32, &pid,
548 DBUS_TYPE_STRING, &appid,
549 DBUS_TYPE_STRING, &pkgid,
550 DBUS_TYPE_STRING, &type,
551 DBUS_TYPE_INVALID)) {
552 _E("Failed to append a D-Bus Message.");
556 if (!dbus_message_append_args(msg,
557 DBUS_TYPE_INT32, &pid,
558 DBUS_TYPE_STRING, &empty_string,
559 DBUS_TYPE_STRING, &empty_string,
560 DBUS_TYPE_STRING, &empty_string,
561 DBUS_TYPE_INVALID)) {
562 _E("Failed to append a D-Bus Message.");
567 if (!dbus_connection_send(conn, msg, &serial)) {
568 _E("Failed to send a D-Bus Message.");
572 dbus_connection_flush(conn);
576 dbus_message_unref(msg);
583 SLPAPI int aul_send_app_status_change_signal(int pid, const char* appid, const char* pkgid, const char* status, const char *type)
585 DBusMessage* msg = NULL;
586 dbus_uint32_t serial = 0;
587 const char *empty_string = "";
591 _W("send_app_status_change_signal, pid: %d, appid: %s, status: %s", pid, appid, status);
593 __app_status_dbus_init();
595 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
596 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
597 AUL_APP_STATUS_DBUS_STATUS_CHANGE);
599 _E("Could not create DBus Message.");
605 if (!dbus_message_append_args(msg,
606 DBUS_TYPE_INT32, &pid,
607 DBUS_TYPE_STRING, &appid,
608 DBUS_TYPE_STRING, &pkgid,
609 DBUS_TYPE_STRING, &status,
610 DBUS_TYPE_STRING, &type,
611 DBUS_TYPE_INVALID)) {
612 _E("Failed to append a D-Bus Message.");
616 if (!dbus_message_append_args(msg,
617 DBUS_TYPE_INT32, &pid,
618 DBUS_TYPE_STRING, &empty_string,
619 DBUS_TYPE_STRING, &empty_string,
620 DBUS_TYPE_STRING, &status,
621 DBUS_TYPE_STRING, &type,
622 DBUS_TYPE_INVALID)) {
623 _E("Failed to append a D-Bus Message.");
628 if (!dbus_connection_send(conn, msg, &serial)) {
629 _E("Failed to send a D-Bus Message.");
633 dbus_connection_flush(conn);
637 dbus_message_unref(msg);
643 SLPAPI int aul_send_app_terminated_signal(int pid)
645 DBusMessage* msg = NULL;
646 dbus_uint32_t serial = 0;
650 __app_status_dbus_init();
652 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
653 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
654 AUL_APP_STATUS_DBUS_TERMINATED);
656 _E("Could not create DBus Message.");
661 if (!dbus_message_append_args(msg,
662 DBUS_TYPE_INT32, &pid,
663 DBUS_TYPE_INVALID)) {
664 _E("Failed to append a D-Bus Message.");
668 if (!dbus_connection_send(conn, msg, &serial)) {
669 _E("Failed to send a D-Bus Message.");
673 dbus_connection_flush(conn);
677 dbus_message_unref(msg);
682 SLPAPI int aul_send_app_group_signal(int owner_pid, int child_pid, const char *child_pkgid)
684 DBusMessage* msg = NULL;
685 dbus_uint32_t serial = 0;
686 const char *empty_string = "";
690 _W("send_app_group_signal, owner: %d, child: %d", owner_pid, child_pid);
692 __app_status_dbus_init();
694 msg = dbus_message_new_signal(AUL_APP_STATUS_DBUS_PATH,
695 AUL_APP_STATUS_DBUS_SIGNAL_INTERFACE,
696 AUL_APP_STATUS_DBUS_GROUP);
698 _E("Could not create DBus Message.");
704 if (!dbus_message_append_args(msg,
705 DBUS_TYPE_INT32, &owner_pid,
706 DBUS_TYPE_INT32, &child_pid,
707 DBUS_TYPE_STRING, &child_pkgid,
708 DBUS_TYPE_INVALID)) {
709 _E("Failed to append a D-Bus Message.");
713 if (!dbus_message_append_args(msg,
714 DBUS_TYPE_INT32, &owner_pid,
715 DBUS_TYPE_INT32, &child_pid,
716 DBUS_TYPE_STRING, &empty_string,
717 DBUS_TYPE_INVALID)) {
718 _E("Failed to append a D-Bus Message.");
723 if (!dbus_connection_send(conn, msg, &serial)) {
724 _E("Failed to send a D-Bus Message.");
728 dbus_connection_flush(conn);
732 dbus_message_unref(msg);