Python-EFL: first working dbus mainloop wrapper.

This one don't require edbus2 nor the old e_dbus, it reimplement
the dbus connection stuff that was in e_dbus (the old) in a
py module.
This commit is contained in:
Davide Andreoli 2013-04-06 12:46:52 +02:00
parent 4fb18e5674
commit 0a32be475a
9 changed files with 929 additions and 1 deletions

531
efl/dbus_mainloop/e_dbus.c Normal file
View File

@ -0,0 +1,531 @@
/*
* Copyright (C) 2007-2013 various contributors (see AUTHORS)
*
* This file is part of Python-EFL.
*
* Python-EFL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Python-EFL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this Python-EFL. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include "e_dbus.h"
int E_DBUS_EVENT_SIGNAL = 0;
static int connection_slot = -1;
static int e_dbus_idler_active = 0;
static int close_connection = 0;
static int _edbus_init_count = 0;
static void
e_dbus_fd_handler_del(E_DBus_Handler_Data *hd)
{
if (!hd->fd_handler) return;
printf("handler disabled\n");
hd->cd->fd_handlers = eina_list_remove(hd->cd->fd_handlers, hd->fd_handler);
ecore_main_fd_handler_del(hd->fd_handler);
hd->fd_handler = NULL;
}
static Eina_Bool
e_dbus_fd_handler(void *data, Ecore_Fd_Handler *fd_handler)
{
E_DBus_Handler_Data *hd;
unsigned int condition = 0;
printf("fd handler (%p)!\n", fd_handler);
hd = data;
if (!hd->enabled)
{
e_dbus_fd_handler_del(hd);
return ECORE_CALLBACK_CANCEL;
}
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ)) condition |= DBUS_WATCH_READABLE;
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_WRITE)) condition |= DBUS_WATCH_WRITABLE;
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_ERROR)) condition |= DBUS_WATCH_ERROR;
printf("fdh || READ: %d, WRITE: %d\n",
(condition & DBUS_WATCH_READABLE) == DBUS_WATCH_READABLE,
(condition & DBUS_WATCH_WRITABLE) == DBUS_WATCH_WRITABLE);
if (condition & DBUS_WATCH_ERROR) printf("DBUS watch error\n");
dbus_watch_handle(hd->watch, condition);
hd = NULL;
return ECORE_CALLBACK_RENEW;
}
static void
e_dbus_fd_handler_add(E_DBus_Handler_Data *hd)
{
unsigned int dflags;
Ecore_Fd_Handler_Flags eflags;
Eina_List *l;
Ecore_Fd_Handler *fdh;
if (hd->fd_handler) return;
dflags = dbus_watch_get_flags(hd->watch);
eflags = ECORE_FD_ERROR;
if (dflags & DBUS_WATCH_READABLE) eflags |= ECORE_FD_READ;
if (dflags & DBUS_WATCH_WRITABLE) eflags |= ECORE_FD_WRITE;
EINA_LIST_FOREACH(hd->cd->fd_handlers, l, fdh)
{
if (ecore_main_fd_handler_fd_get(fdh) == hd->fd) return;
}
printf("fd handler add (%d)\n", hd->fd);
hd->fd_handler = ecore_main_fd_handler_add(hd->fd,
eflags,
e_dbus_fd_handler,
hd,
NULL,
NULL);
hd->cd->fd_handlers = eina_list_append(hd->cd->fd_handlers, hd->fd_handler);
}
static void
e_dbus_handler_data_free(void *data)
{
E_DBus_Handler_Data *hd = data;
printf("e_dbus_handler_data_free\n");
if (hd->fd_handler)
{
hd->cd->fd_handlers = eina_list_remove(hd->cd->fd_handlers, hd->fd_handler);
ecore_main_fd_handler_del(hd->fd_handler);
}
free(hd);
}
static void
e_dbus_connection_data_watch_add(E_DBus_Connection *cd, DBusWatch *watch)
{
E_DBus_Handler_Data *hd;
hd = calloc(1, sizeof(E_DBus_Handler_Data));
dbus_watch_set_data(watch, hd, e_dbus_handler_data_free);
hd->cd = cd;
hd->watch = watch;
hd->enabled = dbus_watch_get_enabled(watch);
// #if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO>= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1)
hd->fd = dbus_watch_get_unix_fd(hd->watch);
// #else
// hd->fd = dbus_watch_get_fd(hd->watch);
// #endif
printf("watch add (enabled: %d)\n", hd->enabled);
if (hd->enabled) e_dbus_fd_handler_add(hd);
}
static void
e_dbus_message_free(void *data, void *message)
{
dbus_message_unref(message);
}
static DBusHandlerResult
e_dbus_filter(DBusConnection *conn, DBusMessage *message, void *user_data)
{
E_DBus_Connection *cd = user_data;
printf("-----------------\n");
printf("Message!\n");
printf("type: %s\n", dbus_message_type_to_string(dbus_message_get_type(message)));
printf("path: %s\n", dbus_message_get_path(message));
printf("interface: %s\n", dbus_message_get_interface(message));
printf("member: %s\n", dbus_message_get_member(message));
printf("sender: %s\n", dbus_message_get_sender(message));
switch (dbus_message_get_type(message))
{
case DBUS_MESSAGE_TYPE_METHOD_CALL:
printf("signature: %s\n", dbus_message_get_signature(message));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN:
printf("reply serial %d\n", dbus_message_get_reply_serial(message));
break;
case DBUS_MESSAGE_TYPE_ERROR:
printf("error: %s\n", dbus_message_get_error_name(message));
break;
case DBUS_MESSAGE_TYPE_SIGNAL:
dbus_message_ref(message);
if (cd->signal_dispatcher) cd->signal_dispatcher(cd, message);
ecore_event_add(E_DBUS_EVENT_SIGNAL, message, e_dbus_message_free, NULL);
break;
default:
break;
}
printf("-----------------\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static Eina_Bool
e_dbus_idler(void *data)
{
E_DBus_Connection *cd;
cd = data;
if (DBUS_DISPATCH_COMPLETE == dbus_connection_get_dispatch_status(cd->conn))
{
printf("done dispatching!\n");
cd->idler = NULL;
return ECORE_CALLBACK_CANCEL;
}
e_dbus_idler_active++;
dbus_connection_ref(cd->conn);
printf("dispatch()\n");
dbus_connection_dispatch(cd->conn);
dbus_connection_unref(cd->conn);
e_dbus_idler_active--;
// e_dbus_signal_handlers_clean(cd); // TODO XXX
if (!e_dbus_idler_active && close_connection)
{
do
{
e_dbus_connection_close(cd);
} while (--close_connection);
}
return ECORE_CALLBACK_RENEW;
}
static void
cb_dispatch_status(DBusConnection *conn, DBusDispatchStatus new_status, void *data)
{
E_DBus_Connection *cd;
printf("dispatch status: %d!\n", new_status);
cd = data;
if (new_status == DBUS_DISPATCH_DATA_REMAINS && !cd->idler)
cd->idler = ecore_idler_add(e_dbus_idler, cd);
else if (new_status != DBUS_DISPATCH_DATA_REMAINS && cd->idler)
{
ecore_idler_del(cd->idler);
cd->idler = NULL;
}
}
/* watch */
static dbus_bool_t
cb_watch_add(DBusWatch *watch, void *data)
{
E_DBus_Connection *cd;
cd = data;
printf("cb_watch_add\n");
e_dbus_connection_data_watch_add(cd, watch);
return true;
}
static void
cb_watch_del(DBusWatch *watch, void *data)
{
E_DBus_Handler_Data *hd;
printf("cb_watch_del\n");
hd = (E_DBus_Handler_Data *)dbus_watch_get_data(watch);
e_dbus_fd_handler_del(hd);
}
static void
cb_watch_toggle(DBusWatch *watch, void *data)
{
E_DBus_Handler_Data *hd;
printf("cb_watch_toggle\n");
hd = dbus_watch_get_data(watch);
if (!hd) return;
hd->enabled = dbus_watch_get_enabled(watch);
printf("watch %p is %sabled\n", hd, hd->enabled ? "en" : "dis");
if (hd->enabled) e_dbus_fd_handler_add(hd);
else e_dbus_fd_handler_del(hd);
}
/* timeout */
static Eina_Bool
e_dbus_timeout_handler(void *data)
{
E_DBus_Timeout_Data *td;
td = data;
if (!dbus_timeout_get_enabled(td->timeout))
{
printf("timeout_handler (not enabled, ending)\n");
td->handler = NULL;
return ECORE_CALLBACK_CANCEL;
}
printf("timeout handler!\n");
dbus_timeout_handle(td->timeout);
return ECORE_CALLBACK_CANCEL;
}
static void
e_dbus_timeout_data_free(void *timeout_data)
{
E_DBus_Timeout_Data *td = timeout_data;
printf("e_dbus_timeout_data_free\n");
if (td->handler) ecore_timer_del(td->handler);
free(td);
}
static dbus_bool_t
cb_timeout_add(DBusTimeout *timeout, void *data)
{
E_DBus_Connection *cd;
E_DBus_Timeout_Data *td;
cd = data;
printf("timeout add!\n");
td = calloc(1, sizeof(E_DBus_Timeout_Data));
td->cd = cd;
dbus_timeout_set_data(timeout, (void *)td, e_dbus_timeout_data_free);
td->interval = dbus_timeout_get_interval(timeout);
td->timeout = timeout;
if (dbus_timeout_get_enabled(timeout))
td->handler = ecore_timer_add(td->interval, e_dbus_timeout_handler, td);
td->cd->timeouts = eina_list_append(td->cd->timeouts, td->handler);
return true;
}
static void
cb_timeout_del(DBusTimeout *timeout, void *data)
{
E_DBus_Timeout_Data *td;
printf("timeout del!\n");
td = (E_DBus_Timeout_Data *)dbus_timeout_get_data(timeout);
if (td->handler)
{
td->cd->timeouts = eina_list_remove(td->cd->timeouts, td->handler);
ecore_timer_del(td->handler);
td->handler = NULL;
}
/* Note: timeout data gets freed when the timeout itself is freed by dbus */
}
static void
cb_timeout_toggle(DBusTimeout *timeout, void *data)
{
E_DBus_Timeout_Data *td;
printf("timeout toggle!\n");
td = (E_DBus_Timeout_Data *)dbus_timeout_get_data(timeout);
if (dbus_timeout_get_enabled(td->timeout))
{
td->interval = dbus_timeout_get_interval(timeout);
td->handler = ecore_timer_add(td->interval, e_dbus_timeout_handler, td);
}
else
{
ecore_timer_del(td->handler);
td->handler = NULL;
}
}
/* dbus connection */
static E_DBus_Connection *
e_dbus_connection_new(DBusConnection *conn)
{
E_DBus_Connection *cd;
const char *conn_name;
cd = calloc(1, sizeof(E_DBus_Connection));
if (!cd) return NULL;
cd->conn = conn;
conn_name = dbus_bus_get_unique_name(conn);
if (conn_name)
{
printf("Connected! Name: %s\n", conn_name);
cd->conn_name = strdup(conn_name);
}
else
printf("Not connected\n");
cd->shared_type = (unsigned int)-1;
cd->fd_handlers = NULL;
cd->timeouts = NULL;
return cd;
}
static void
e_dbus_connection_free(void *data)
{
E_DBus_Connection *cd = data;
Ecore_Fd_Handler *fd_handler;
Ecore_Timer *timer;
printf("e_dbus_connection free!\n");
EINA_LIST_FREE(cd->fd_handlers, fd_handler)
ecore_main_fd_handler_del(fd_handler);
EINA_LIST_FREE(cd->timeouts, timer)
ecore_timer_del(timer);
// if (cd->shared_type != (unsigned int)-1)
// shared_connections[cd->shared_type] = NULL;
// e_dbus_signal_handlers_free_all(cd);
if (cd->conn_name) free(cd->conn_name);
if (cd->idler) ecore_idler_del(cd->idler);
free(cd);
}
/* public functions */
int
e_dbus_init(void)
{
if (++_edbus_init_count != 1)
return _edbus_init_count;
if (!eina_init())
{
fprintf(stderr,"E-dbus: Enable to initialize eina\n");
return --_edbus_init_count;
}
if (!ecore_init())
{
fprintf(stderr, "E-dbus: Unable to initialize ecore\n");
eina_shutdown();
return --_edbus_init_count;
}
E_DBUS_EVENT_SIGNAL = ecore_event_type_new();
// e_dbus_object_init();
return _edbus_init_count;
}
int
e_dbus_shutdown(void)
{
if (_edbus_init_count <= 0)
{
fprintf(stderr, "Init count not greater than 0 in shutdown.\n");
return 0;
}
if (--_edbus_init_count)
return _edbus_init_count;
// e_dbus_object_shutdown();
ecore_shutdown();
eina_shutdown();
return _edbus_init_count;
}
E_DBus_Connection *
e_dbus_connection_setup(DBusConnection *conn)
{
E_DBus_Connection *cd;
cd = e_dbus_connection_new(conn);
if (!cd) return NULL;
/* connection_setup */
dbus_connection_set_exit_on_disconnect(cd->conn, EINA_FALSE);
dbus_connection_allocate_data_slot(&connection_slot);
dbus_connection_set_data(cd->conn, connection_slot, (void *)cd, e_dbus_connection_free);
dbus_connection_set_watch_functions(cd->conn,
cb_watch_add,
cb_watch_del,
cb_watch_toggle,
cd,
NULL);
dbus_connection_set_timeout_functions(cd->conn,
cb_timeout_add,
cb_timeout_del,
cb_timeout_toggle,
cd,
NULL);
dbus_connection_set_dispatch_status_function(cd->conn, cb_dispatch_status, cd, NULL);
dbus_connection_add_filter(cd->conn, e_dbus_filter, cd, NULL);
cb_dispatch_status(cd->conn, dbus_connection_get_dispatch_status(cd->conn), cd);
return cd;
}
void
e_dbus_connection_close(E_DBus_Connection *conn)
{
if (!conn) return;
printf("e_dbus_connection_close\n");
if (e_dbus_idler_active)
{
close_connection++;
return;
}
if (--(conn->refcount) != 0) return;
dbus_connection_free_data_slot(&connection_slot);
dbus_connection_remove_filter(conn->conn, e_dbus_filter, conn);
dbus_connection_set_watch_functions (conn->conn,
NULL,
NULL,
NULL,
NULL, NULL);
dbus_connection_set_timeout_functions (conn->conn,
NULL,
NULL,
NULL,
NULL, NULL);
dbus_connection_set_dispatch_status_function (conn->conn, NULL, NULL, NULL);
/* Idler functin must be cancelled when dbus connection is unreferenced */
if (conn->idler)
{
ecore_idler_del(conn->idler);
conn->idler = NULL;
}
dbus_connection_close(conn->conn);
dbus_connection_unref(conn->conn);
// Note: the E_DBus_Connection gets freed when the dbus_connection is cleaned up by the previous unref
}

View File

@ -0,0 +1,69 @@
/*
* Copyright (C) 2007-2013 various contributors (see AUTHORS)
*
* This file is part of Python-EFL.
*
* Python-EFL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Python-EFL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this Python-EFL. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Glue code to attach the Ecore main loop to D-Bus from within Python.
*/
#include <dbus/dbus.h>
#include <Ecore.h>
typedef struct E_DBus_Connection E_DBus_Connection;
typedef struct E_DBus_Handler_Data E_DBus_Handler_Data;
typedef struct E_DBus_Timeout_Data E_DBus_Timeout_Data;
struct E_DBus_Connection
{
DBusBusType shared_type;
DBusConnection *conn;
char *conn_name;
Eina_List *fd_handlers;
Eina_List *timeouts;
Eina_List *signal_handlers;
void (*signal_dispatcher)(E_DBus_Connection *conn, DBusMessage *msg);
Ecore_Idler *idler;
int refcount;
};
struct E_DBus_Handler_Data
{
int fd;
Ecore_Fd_Handler *fd_handler;
E_DBus_Connection *cd;
DBusWatch *watch;
int enabled;
};
struct E_DBus_Timeout_Data
{
Ecore_Timer *handler;
DBusTimeout *timeout;
E_DBus_Connection *cd;
int interval;
};
int e_dbus_init(void);
int e_dbus_shutdown(void);
E_DBus_Connection *e_dbus_connection_setup(DBusConnection *conn);
void e_dbus_connection_close(E_DBus_Connection *conn);

138
efl/dbus_mainloop/module.c Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright (C) 2007-2013 various contributors (see AUTHORS)
*
* This file is part of Python-EFL.
*
* Python-EFL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Python-EFL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this Python-EFL. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Glue code to attach the Ecore main loop to D-Bus from within Python.
*/
#include <Python.h>
#include <dbus/dbus-python.h>
#include "e_dbus.h"
static dbus_bool_t
dbus_py_ecore_set_up_conn(DBusConnection *conn, void *data)
{
Py_BEGIN_ALLOW_THREADS
e_dbus_connection_setup(conn);
Py_END_ALLOW_THREADS
return TRUE;
}
static PyObject *
dbus_ecore_native_mainloop(void *data)
{
return DBusPyNativeMainLoop_New4(dbus_py_ecore_set_up_conn,
NULL, NULL, NULL);
}
PyDoc_STRVAR(DBusEcoreMainLoop__doc__,
"Returns a NativeMainLoop to attach the Ecore main loop to D-Bus\n"
"from within Python.\n");
static PyObject *
dbus_ecore_main_loop(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "set_as_default", NULL };
int set_as_default = 0;
PyObject *ml;
if (PyTuple_Size(args) != 0) {
PyErr_SetString(PyExc_TypeError,
"DBusEcoreMainLoop() takes no positional arguments");
return NULL;
}
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i",
kwlist, &set_as_default))
return NULL;
ml = dbus_ecore_native_mainloop(NULL);
if (ml && set_as_default) {
PyObject *func, *res;
if (!_dbus_bindings_module) {
PyErr_SetString(PyExc_ImportError, "_dbus_bindings not imported");
Py_DECREF(ml);
return NULL;
}
func = PyObject_GetAttrString(_dbus_bindings_module,
"set_default_main_loop");
if (!func) {
Py_DECREF(ml);
return NULL;
}
res = PyObject_CallFunctionObjArgs(func, ml, NULL);
Py_DECREF(func);
if (!res) {
Py_DECREF(ml);
return NULL;
}
Py_DECREF(res);
}
return ml;
}
static PyMethodDef module_functions[] = {
{ "DBusEcoreMainLoop", (PyCFunction)dbus_ecore_main_loop,
METH_VARARGS | METH_KEYWORDS, DBusEcoreMainLoop__doc__ },
{ NULL, NULL, 0, NULL }
};
static void
module_cleanup(void)
{
e_dbus_shutdown();
ecore_shutdown();
}
PyDoc_STRVAR(module_doc,
"D-Bus python integration for Ecore main loop.\n");
#if defined(__GNUC__) && (__GNUC__ >= 4)
__attribute__ ((visibility("default")))
#endif
PyMODINIT_FUNC
initdbus_mainloop(void)
{
PyObject *mod;
if (import_dbus_bindings("efl.dbus_mainloop") < 0) {
PyErr_SetString(PyExc_ImportError, "failed to import D-Bus bindings");
return;
}
mod = Py_InitModule3("efl.dbus_mainloop", module_functions, module_doc);
if (!mod) {
PyErr_SetString(PyExc_ImportError,
"Py_InitModule3(\"efl.dbus_mainloop\") failed");
return;
}
ecore_init();
e_dbus_init();
Py_AtExit(module_cleanup);
}

View File

@ -120,6 +120,14 @@ else:
#extra_link_args = edbus_libs)
#modules.append(edbus_ext)
# dbus mainloop integration
dbus_cflags, dbus_libs = pkg_config('DBus', 'dbus-python', "0.83.0")
dbus_ml_ext = Extension("efl.dbus_mainloop",
["efl/dbus_mainloop/module.c",
"efl/dbus_mainloop/e_dbus.c"],
extra_compile_args = dbus_cflags + ecore_cflags,
extra_link_args = dbus_libs + ecore_libs)
# Elementary
elm_exts = [
Extension("efl.elementary.actionslider", ["efl/elementary/actionslider.pyx"]),
@ -220,5 +228,5 @@ if __name__ == "__main__":
#"builder": (None, "coverage"),
},
},
ext_modules = cythonize(modules, include_path=["include"]),
ext_modules = cythonize(modules, include_path=["include"]) + [dbus_ml_ext],
)

View File

@ -0,0 +1,28 @@
#!/usr/bin/env python
import sys
import dbus
from efl import dbus_mainloop
from efl import ecore
def print_remote_handles(adapter, bdaddr):
handles = [hex(int(h)) \
for h in list(adapter.GetRemoteServiceHandles(bdaddr, ""))]
print "Handles:", handles
ecore.idler_add(ecore.main_loop_quit)
return False
if len(sys.argv) != 2:
print "USAGE: %s <bdaddr>" % sys.argv[0]
sys.exit(1)
dbus_ml = dbus_mainloop.DBusEcoreMainLoop()
bus = dbus.SystemBus(mainloop=dbus_ml);
obj = bus.get_object("org.bluez", "/org/bluez/hci0")
adapter = dbus.Interface(obj, "org.bluez.Adapter")
ecore.idler_add(print_remote_handles, adapter, sys.argv[1])
ecore.main_loop_begin()

View File

@ -0,0 +1,53 @@
#!/usr/bin/env python
import dbus
from efl import dbus_mainloop
from efl import ecore
def disc_started_signal():
print "Signal: DiscoveryStarted()"
def rem_dev_found_signal(address, cls, rssi):
print "Signal: RemoteDeviceFound(%s, %s, %s)" % (address, cls, rssi)
def rem_dev_name_signal(address, name):
print "Signal: RemoteNameUpdated(%s, %s)" % (address, name)
def disc_completed_signal():
print "Signal: DiscoveryCompleted()"
ecore.idler_add(ecore.main_loop_quit)
dbus_ml = dbus_mainloop.DBusEcoreMainLoop()
bus = dbus.SystemBus(mainloop=dbus_ml)
bus.add_signal_receiver(disc_started_signal,
"DiscoveryStarted",
"org.bluez.Adapter",
"org.bluez",
"/org/bluez/hci0")
bus.add_signal_receiver(rem_dev_found_signal,
"RemoteDeviceFound",
"org.bluez.Adapter",
"org.bluez",
"/org/bluez/hci0")
bus.add_signal_receiver(rem_dev_name_signal,
"RemoteNameUpdated",
"org.bluez.Adapter",
"org.bluez",
"/org/bluez/hci0")
bus.add_signal_receiver(disc_completed_signal,
"DiscoveryCompleted",
"org.bluez.Adapter",
"org.bluez",
"/org/bluez/hci0")
obj = bus.get_object("org.bluez", "/org/bluez/hci0")
adapter = dbus.Interface(obj, "org.bluez.Adapter")
adapter.DiscoverDevices()
ecore.main_loop_begin()

View File

@ -0,0 +1,37 @@
#!/usr/bin/env python
import dbus
import dbus.service
from efl import dbus_mainloop
from efl import ecore
class TestObject(dbus.service.Object):
def __init__(self, conn, object_path="/com/example/TestService/object"):
dbus.service.Object.__init__(self, conn, object_path)
@dbus.service.signal("com.example.TestService")
def HelloSignal(self, message):
# The signal is emitted when this method exits
# You can have code here if you wish
pass
@dbus.service.method("com.example.TestService")
def emitHelloSignal(self):
#you emit signals by calling the signal"s skeleton method
self.HelloSignal("Hello")
return "Signal emitted"
@dbus.service.method("com.example.TestService",
in_signature="", out_signature="")
def Exit(self):
ecore.idler_add(ecore.main_loop_quit)
dbus_ml = dbus_mainloop.DBusEcoreMainLoop()
session_bus = dbus.SessionBus(mainloop=dbus_ml)
name = dbus.service.BusName("com.example.TestService", session_bus)
obj = TestObject(session_bus)
ecore.main_loop_begin()

View File

@ -0,0 +1,48 @@
#!/usr/bin/env python
import dbus
from efl import dbus_mainloop
from efl import ecore
def emit_signal(obj):
obj.emitHelloSignal(dbus_interface="com.example.TestService")
obj.Exit(dbus_interface="com.example.TestService")
ecore.idler_add(ecore.main_loop_quit)
return False
def hello_signal_handler(hello_string):
print "Received signal (by connecting using remote " \
"object) and it says: %s" % hello_string
def catchall_hello_signals_handler(hello_string):
print "Received a hello signal and it says: %s" % hello_string
def catchall_testservice_interface_handler(hello_string, dbus_message):
print "com.example.TestService interface says %s " \
"when it sent signal %s" % (hello_string, dbus_message.get_member())
dbus_ml = dbus_mainloop.DBusEcoreMainLoop()
bus = dbus.SessionBus(mainloop=dbus_ml)
obj = bus.get_object("com.example.TestService",
"/com/example/TestService/object")
obj.connect_to_signal("HelloSignal",
hello_signal_handler,
dbus_interface="com.example.TestService",
arg0="Hello")
bus.add_signal_receiver(catchall_hello_signals_handler,
dbus_interface = "com.example.TestService",
signal_name = "HelloSignal")
bus.add_signal_receiver(catchall_testservice_interface_handler,
dbus_interface = "com.example.TestService",
message_keyword="dbus_message")
ecore.timer_add(1.0, emit_signal, obj)
ecore.main_loop_begin()

View File

@ -0,0 +1,16 @@
#!/usr/bin/env python
import dbus
from efl import dbus_mainloop
from efl import ecore
def print_name_owner_changed(obj, old, new):
print "Obj = '%s', Old = '%s', New = '%s'" % (obj, old, new)
dbus_ml = dbus_mainloop.DBusEcoreMainLoop()
bus = dbus.SystemBus(mainloop=dbus_ml)
bus.add_signal_receiver(print_name_owner_changed, "NameOwnerChanged")
ecore.main_loop_begin()