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.
25 #include "app_signal.h"
27 #include "simple_util.h"
31 static int (*_app_dead_handler) (int pid, void *data);
32 static void *_app_dead_data;
34 static int (*_app_launch_handler) (int pid, void *data);
35 static void *_app_launch_data;
37 static int (*_booting_done_handler) (int pid, void *data);
38 static void *_booting_done_data;
40 static int (*_status_handler) (int pid, int status, void *data);
41 static void *_status_data;
43 static int (*_cooldown_handler) (const char *cooldown_status, void *data);
44 static void *_cooldown_data;
46 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
47 static int (*_lcd_status_handler) (const char *lcd_status, void *data);
48 static void *_lcd_status_data;
51 static DBusConnection *bus;
52 static int app_dbus_signal_handler_initialized = 0;
54 static DBusHandlerResult
55 __app_dbus_signal_filter(DBusConnection *conn, DBusMessage *message,
59 const char *interface;
60 const char *cooldown_status;
65 dbus_error_init(&error);
67 sender = dbus_message_get_sender(message);
69 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
71 /*if (dbus_bus_get_unix_user(conn, sender, &error) != 0) {
72 _E("reject by security issue - no allowed sender\n");
73 dbus_error_free(&error);
74 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
77 interface = dbus_message_get_interface(message);
78 if (interface == NULL) {
79 _E("reject by security issue - no interface\n");
80 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
83 if (dbus_message_is_signal(
84 message, interface, AUL_DBUS_APPDEAD_SIGNAL)) {
85 if (dbus_message_get_args(message, &error, DBUS_TYPE_UINT32,
86 &pid, DBUS_TYPE_INVALID) == FALSE) {
87 _E("Failed to get data: %s", error.message);
88 dbus_error_free(&error);
89 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
91 if (_app_dead_handler)
92 _app_dead_handler(pid, _app_dead_data);
93 } else if (dbus_message_is_signal(
94 message, interface, AUL_DBUS_APPLAUNCH_SIGNAL)) {
95 if (dbus_message_get_args(message, &error, DBUS_TYPE_UINT32,
96 &pid, DBUS_TYPE_INVALID) == FALSE) {
97 _E("Failed to get data: %s", error.message);
98 dbus_error_free(&error);
99 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
101 if (_app_launch_handler)
102 _app_launch_handler(pid, _app_launch_data);
103 } else if (dbus_message_is_signal(
104 message, interface, SYSTEM_SIGNAL_BOOTING_DONE)) {
105 if (_booting_done_handler)
106 _booting_done_handler(pid, _booting_done_data);
107 } else if (dbus_message_is_signal(
108 message, interface, RESOURCED_SIGNAL_PROCESS_STATUS)) {
109 if (dbus_message_get_args(message, &error, DBUS_TYPE_INT32,&status,
110 DBUS_TYPE_INT32,&pid, DBUS_TYPE_INVALID) == FALSE) {
111 _E("Failed to get data: %s", error.message);
112 dbus_error_free(&error);
113 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
116 _status_handler(pid, status, _status_data);
117 } else if (dbus_message_is_signal(
118 message, interface, SYSTEM_SIGNAL_COOLDOWN_CHANGED)) {
119 if (dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &cooldown_status,
120 DBUS_TYPE_INVALID) == FALSE) {
121 _E("Failed to get data: %s", error.message);
122 dbus_error_free(&error);
123 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
125 if (_cooldown_handler)
126 _cooldown_handler(cooldown_status, _cooldown_data);
128 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
129 else if (dbus_message_is_signal(
130 message, interface, DEVICED_SIGNAL_LCD_ON)) {
131 if (_lcd_status_handler)
132 _lcd_status_handler(DEVICED_SIGNAL_LCD_ON, _lcd_status_data);
133 } else if (dbus_message_is_signal(
134 message, interface, DEVICED_SIGNAL_LCD_OFF)) {
135 if (_lcd_status_handler)
136 _lcd_status_handler(DEVICED_SIGNAL_LCD_OFF, _lcd_status_data);
140 return DBUS_HANDLER_RESULT_HANDLED;
143 int __app_dbus_signal_handler_init(void)
147 if (app_dbus_signal_handler_initialized)
150 ret = __app_dbus_signal_handler_init_with_param(AUL_DBUS_PATH, AUL_DBUS_SIGNAL_INTERFACE);
152 app_dbus_signal_handler_initialized = 1;
157 int __app_dbus_signal_handler_init_with_param(const char* path, const char* interface)
160 char rule[MAX_LOCAL_BUFSZ];
162 dbus_error_init(&error);
163 bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
165 _E("Failed to connect to the D-BUS daemon: %s", error.message);
166 dbus_error_free(&error);
169 dbus_connection_setup_with_g_main(bus, NULL);
171 snprintf(rule, MAX_LOCAL_BUFSZ,
172 "path='%s',type='signal',interface='%s'", path, interface);
173 /* listening to messages */
174 dbus_bus_add_match(bus, rule, &error);
175 if (dbus_error_is_set(&error)) {
176 _E("Fail to rule set: %s", error.message);
177 dbus_error_free(&error);
181 if (dbus_connection_add_filter(bus,
182 __app_dbus_signal_filter, NULL, NULL) == FALSE) {
183 _E("add filter fail");
187 _D("app signal initialized");
192 int __app_dbus_signal_handler_fini(void)
196 if (!app_dbus_signal_handler_initialized)
199 ret = __app_dbus_signal_handler_fini_with_param(AUL_DBUS_PATH, AUL_DBUS_SIGNAL_INTERFACE);
201 app_dbus_signal_handler_initialized = 0;
206 int __app_dbus_signal_handler_fini_with_param(const char* path, const char* interface)
209 char rule[MAX_LOCAL_BUFSZ];
212 dbus_error_init(&error);
214 dbus_connection_remove_filter(bus, __app_dbus_signal_filter, NULL);
216 snprintf(rule, MAX_LOCAL_BUFSZ,
217 "path='%s',type='signal',interface='%s'", path, interface);
218 dbus_bus_remove_match(bus, rule, &error);
219 if (dbus_error_is_set(&error)) {
220 _E("Fail to rule unset: %s", error.message);
221 dbus_error_free(&error);
225 dbus_connection_close(bus);
226 dbus_connection_unref(bus);
228 _D("app signal finialized");
233 SLPAPI int aul_listen_app_dead_signal(int (*func) (int, void *), void *data)
236 if (__app_dbus_signal_handler_init() < 0) {
237 _E("error app signal init");
240 } else if (_app_launch_handler == NULL) {
241 if (__app_dbus_signal_handler_fini() < 0) {
242 _E("error app signal fini");
246 _app_dead_handler = func;
247 _app_dead_data = data;
252 SLPAPI int aul_listen_app_launch_signal(int (*func) (int, void *), void *data)
255 if (__app_dbus_signal_handler_init() < 0) {
256 _E("error app signal init");
259 } else if (_app_dead_handler == NULL) {
260 if (__app_dbus_signal_handler_fini() < 0) {
261 _E("error app signal fini");
265 _app_launch_handler = func;
266 _app_launch_data = data;
271 SLPAPI int aul_listen_booting_done_signal(int (*func) (int, void *), void *data)
274 if (__app_dbus_signal_handler_init_with_param(SYSTEM_PATH_CORE, SYSTEM_INTERFACE_CORE) < 0) {
275 _E("error app signal init");
278 } else if (_booting_done_handler == NULL) {
279 if (__app_dbus_signal_handler_fini_with_param(SYSTEM_PATH_CORE, SYSTEM_INTERFACE_CORE) < 0) {
280 _E("error app signal fini");
284 _booting_done_handler = func;
285 _booting_done_data = data;
291 SLPAPI int aul_listen_cooldown_signal(int (*func) (const char *, void *), void *data)
294 if (__app_dbus_signal_handler_init_with_param(SYSTEM_PATH_SYSNOTI, SYSTEM_INTERFACE_SYSNOTI) < 0) {
295 _E("error app signal init");
298 } else if (_cooldown_handler == NULL) {
299 if (__app_dbus_signal_handler_fini_with_param(SYSTEM_PATH_SYSNOTI, SYSTEM_INTERFACE_SYSNOTI) < 0) {
300 _E("error app signal fini");
304 _cooldown_handler = func;
305 _cooldown_data = data;
311 SLPAPI int aul_listen_e17_status_signal(int (*func) (int, int, void *), void *data)
314 if (__app_dbus_signal_handler_init_with_param(RESOURCED_PATH_CORE, RESOURCED_INTERFACE_CORE) < 0) {
315 _E("error app signal init");
319 _status_handler = func;
325 #ifdef _APPFW_FEATURE_VISIBILITY_CHECK_BY_LCD_STATUS
326 SLPAPI int aul_listen_lcd_status_signal(int (*func) (const char *, void *), void *data)
329 if (__app_dbus_signal_handler_init_with_param(DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY) < 0) {
330 _E("error app signal init");
334 _lcd_status_handler = func;
335 _lcd_status_data = data;
341 SLPAPI int aul_update_freezer_status(int pid, const char* type)
344 DBusConnection* conn = NULL;
345 DBusMessage* msg = NULL;
346 dbus_uint32_t serial = 0;
350 dbus_error_init(&err);
352 conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
354 _E("Fail to dbus_bus_get : %s", err.message);
358 msg = dbus_message_new_signal(RESOURCED_PROC_OBJECT,
359 RESOURCED_PROC_INTERFACE,
360 RESOURCED_PROC_METHOD);
362 _E("Could not create DBus Message.");
367 if (!dbus_message_append_args(msg,
368 DBUS_TYPE_STRING, &type,
369 DBUS_TYPE_INT32, &pid,
370 DBUS_TYPE_INVALID)) {
371 _E("Failed to append a D-Bus Message.");
375 _D("Send a freezer signal pid: %d, type: %s", pid, type);
377 if (!dbus_connection_send(conn, msg, &serial)) {
378 _E("Failed to send a D-Bus Message.");
382 dbus_connection_flush(conn);
385 dbus_error_free(&err);
388 dbus_message_unref(msg);
392 dbus_connection_unref(conn);