styx
/
enlightenment
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

e: Port fileman to edbus 

Patch by: José Roberto de Souza  <zehortigoza@profusion.mobi>



SVN revision: 81977
This commit is contained in:
José Roberto de Souza 2013-01-02 13:14:54 +00:00 committed by Lucas De Marchi
parent 0313f186c5
commit 5b714e3146
3 changed files with 84 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
configure.ac
View File

@ -479,7 +479,7 @@ ecore-file >= $efl_version \
ecore-ipc >= $efl_version \
eet >= $efl_version \
efreet >= $efl_version \
edbus >= $efl_version \
edbus2 >= $efl_version \
eina >= $efl_version"
efm_requires="$efm_requires $eeze_mount $dbus_mount $hal_mount $udisks_mount"
@ -489,6 +489,7 @@ PKG_CHECK_MODULES(E_FM_CMDLINE, [
eina >= ${efl_version}
ecore >= ${efl_version}
ecore-file >= ${efl_version}
edbus2 >= ${efl_version}
edbus >= ${efl_version}
dbus-1
])

45
src/bin/e_fm_cmdline.c
View File

@ -5,21 +5,23 @@
#include <Ecore.h>
#include <Ecore_File.h>
#include <Ecore_Getopt.h>
#include <E_DBus.h>
#include <EDBus.h>
#include <unistd.h>
#include <errno.h>
static E_DBus_Connection *conn = NULL;
static EDBus_Connection *conn = NULL;
static int retval = EXIT_SUCCESS;
static int pending = 0;
static void
fm_open_reply(void *data __UNUSED__, DBusMessage *msg __UNUSED__, DBusError *err)
fm_open_reply(void *data __UNUSED__, const EDBus_Message *msg,
EDBus_Pending *dbus_pending __UNUSED__)
{
if (dbus_error_is_set(err))
const char *name, *txt;
if (edbus_message_error_get(msg, &name, &txt))
{
retval = EXIT_FAILURE;
fprintf(stderr, "ERROR: %s: %s", err->name, err->message);
fprintf(stderr, "ERROR: %s: %s", name, txt);
}
pending--;
@ -36,8 +38,7 @@ fm_error_quit_last(void *data __UNUSED__)
static void
fm_open(const char *path)
{
DBusMessage *msg;
Eina_Bool sent;
EDBus_Message *msg;
const char *method;
char *p;
@ -78,10 +79,10 @@ fm_open(const char *path)
else
method = "OpenFile";
msg = dbus_message_new_method_call
("org.enlightenment.FileManager",
"/org/enlightenment/FileManager",
"org.enlightenment.FileManager", method);
msg = edbus_message_method_call_new("org.enlightenment.FileManager",
"/org/enlightenment/FileManager",
"org.enlightenment.FileManager",
method);
if (!msg)
{
fputs("ERROR: Could not create DBus Message\n", stderr);
@ -89,21 +90,17 @@ fm_open(const char *path)
free(p);
return;
}
dbus_message_append_args(msg, DBUS_TYPE_STRING, &p, DBUS_TYPE_INVALID);
edbus_message_arguments_append(msg, "s", p);
free(p);
sent = !!e_dbus_message_send(conn, msg, fm_open_reply, -1, NULL);
dbus_message_unref(msg);
if (!sent)
if (!edbus_connection_send(conn, msg, fm_open_reply, NULL, -1))
{
fputs("ERROR: Could not send DBus Message\n", stderr);
ecore_idler_add(fm_error_quit_last, NULL);
return;
}
pending++;
else
pending++;
edbus_message_unref(msg);
}
static const Ecore_Getopt options = {
@ -147,9 +144,9 @@ main(int argc, char *argv[])
ecore_init();
ecore_file_init();
e_dbus_init();
edbus_init();
conn = e_dbus_bus_get(DBUS_BUS_SESSION);
conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
if (!conn)
{
fputs("ERROR: Could not DBus SESSION bus.\n", stderr);
@ -167,9 +164,9 @@ main(int argc, char *argv[])
}
ecore_main_loop_begin();
edbus_connection_unref(conn);
end:
e_dbus_shutdown();
edbus_shutdown();
ecore_file_shutdown();
ecore_shutdown();
return retval;

190
src/modules/fileman/e_mod_dbus.c
View File

@ -8,77 +8,78 @@ static const char E_FILEMAN_PATH[] = "/org/enlightenment/FileManager";
typedef struct _E_Fileman_DBus_Daemon E_Fileman_DBus_Daemon;
struct _E_Fileman_DBus_Daemon
{
E_DBus_Connection *conn;
E_DBus_Interface *iface;
E_DBus_Object *obj;
struct
{
DBusPendingCall *request_name;
} pending;
EDBus_Connection *conn;
EDBus_Service_Interface *iface;
};
static DBusMessage *
_e_fileman_dbus_daemon_error(DBusMessage *message,
const char *msg)
static EDBus_Message * _e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg);
static EDBus_Message *_e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface, const EDBus_Message *msg);
static EDBus_Message *
_e_fileman_dbus_daemon_error(const EDBus_Message *msg,
const char *error_msg)
{
return dbus_message_new_error(message, E_FILEMAN_ERROR, msg);
return edbus_message_error_new(msg, E_FILEMAN_ERROR, error_msg);
}
static const EDBus_Method methods[] = {
{
"OpenDirectory", EDBUS_ARGS({"s", "directory"}), NULL,
_e_fileman_dbus_daemon_open_directory_cb, 0
},
{
"OpenFile", EDBUS_ARGS({"s", "file"}), NULL,
_e_fileman_dbus_daemon_open_file_cb, 0
},
{ NULL, NULL, NULL, NULL, 0 }
};
static const EDBus_Service_Interface_Desc desc = {
E_FILEMAN_INTERFACE, methods, NULL, NULL, NULL, NULL
};
static void
_e_fileman_dbus_daemon_object_init(E_Fileman_DBus_Daemon *d)
{
if (d->obj) return;
d->obj = e_dbus_object_add(d->conn, E_FILEMAN_PATH, d);
if (!d->obj)
d->iface = edbus_service_interface_register(d->conn, E_FILEMAN_PATH, &desc);
if (!d->iface)
{
fprintf(stderr, "ERROR: cannot add object to %s\n", E_FILEMAN_PATH);
return;
}
e_dbus_object_interface_attach(d->obj, d->iface);
}
static void
_e_fileman_dbus_daemon_free(E_Fileman_DBus_Daemon *d)
{
if (d->pending.request_name)
dbus_pending_call_cancel(d->pending.request_name);
if (d->obj)
{
e_dbus_object_interface_detach(d->obj, d->iface);
e_dbus_object_free(d->obj);
}
if (d->iface)
e_dbus_interface_unref(d->iface);
edbus_service_object_unregister(d->iface);
if (d->conn)
e_dbus_connection_close(d->conn);
edbus_connection_unref(d->conn);
free(d);
}
static DBusMessage *
_e_fileman_dbus_daemon_open_directory_cb(E_DBus_Object *obj __UNUSED__,
DBusMessage *message)
static EDBus_Message *
_e_fileman_dbus_daemon_open_directory_cb(const EDBus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg)
{
DBusMessageIter itr;
const char *directory = NULL, *p;
char *dev, *to_free = NULL;
E_Zone *zone;
dbus_message_iter_init(message, &itr);
dbus_message_iter_get_basic(&itr, &directory);
if (!edbus_message_arguments_get(msg, "s", &directory))
{
fprintf(stderr, "Error: getting arguments of OpenDirectory call.\n");
return edbus_message_method_return_new(msg);
}
if ((!directory) || (directory[0] == '\0'))
return _e_fileman_dbus_daemon_error(message, "no directory provided.");
return _e_fileman_dbus_daemon_error(msg, "no directory provided.");
zone = e_util_zone_current_get(e_manager_current_get());
if (!zone)
return _e_fileman_dbus_daemon_error(message, "could not find a zone.");
return _e_fileman_dbus_daemon_error(msg, "could not find a zone.");
if (strstr(directory, "://"))
{
@ -93,7 +94,7 @@ _e_fileman_dbus_daemon_open_directory_cb(E_DBus_Object *obj __UNUSED__,
}
if (!directory)
return _e_fileman_dbus_daemon_error(message, "unsupported protocol");
return _e_fileman_dbus_daemon_error(msg, "unsupported protocol");
}
p = strchr(directory, '/');
@ -105,7 +106,7 @@ _e_fileman_dbus_daemon_open_directory_cb(E_DBus_Object *obj __UNUSED__,
if (!dev)
{
free(to_free);
return _e_fileman_dbus_daemon_error(message,
return _e_fileman_dbus_daemon_error(msg,
"could not allocate memory.");
}
@ -126,7 +127,7 @@ _e_fileman_dbus_daemon_open_directory_cb(E_DBus_Object *obj __UNUSED__,
e_fwin_new(zone->container, dev, directory);
free(dev);
free(to_free);
return dbus_message_new_method_return(message);
return edbus_message_method_return_new(msg);
}
static Eina_Bool
@ -153,25 +154,27 @@ _mime_shell_script_check(const char *mime)
return EINA_FALSE;
}
static DBusMessage *
_e_fileman_dbus_daemon_open_file_cb(E_DBus_Object *obj __UNUSED__,
DBusMessage *message)
static EDBus_Message*
_e_fileman_dbus_daemon_open_file_cb(const EDBus_Service_Interface *iface __UNUSED__,
const EDBus_Message *msg)
{
DBusMessageIter itr;
Eina_List *handlers;
const char *param_file = NULL, *mime, *errmsg = "unknow error";
char *real_file, *to_free = NULL;
E_Zone *zone;
dbus_message_iter_init(message, &itr);
dbus_message_iter_get_basic(&itr, &param_file);
if (!edbus_message_arguments_get(msg, "s", &param_file))
{
fprintf(stderr, "ERROR: getting arguments of OpenFile call.\n");
return edbus_message_method_return_new(msg);
}
if ((!param_file) || (param_file[0] == '\0'))
return _e_fileman_dbus_daemon_error(message, "no file provided.");
return _e_fileman_dbus_daemon_error(msg, "no file provided.");
zone = e_util_zone_current_get(e_manager_current_get());
if (!zone)
return _e_fileman_dbus_daemon_error(message, "could not find a zone.");
return _e_fileman_dbus_daemon_error(msg, "could not find a zone.");
if (!strstr(param_file, "://"))
{
@ -271,104 +274,33 @@ _e_fileman_dbus_daemon_open_file_cb(E_DBus_Object *obj __UNUSED__,
end:
free(real_file);
free(to_free);
return dbus_message_new_method_return(message);
return edbus_message_method_return_new(msg);
error:
free(real_file);
free(to_free);
return _e_fileman_dbus_daemon_error(message, errmsg);
}
static void
_e_fileman_dbus_daemon_request_name_cb(void *data,
DBusMessage *msg,
DBusError *err)
{
E_Fileman_DBus_Daemon *d = data;
dbus_uint32_t ret;
DBusError new_err;
d->pending.request_name = NULL;
if (dbus_error_is_set(err))
{
fprintf(stderr, "ERROR: FILEMAN: RequestName failed: %s\n",
err->message);
dbus_error_free(err);
return;
}
dbus_error_init(&new_err);
dbus_message_get_args(msg, &new_err, DBUS_TYPE_UINT32, &ret,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&new_err))
{
fprintf(stderr,
"ERROR: FILEMAN: could not get arguments of RequestName: %s\n",
new_err.message);
dbus_error_free(&new_err);
return;
}
switch (ret)
{
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
_e_fileman_dbus_daemon_object_init(d);
break;
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
//XXX mark daemon as queued?
break;
case DBUS_REQUEST_NAME_REPLY_EXISTS:
//XXX exit?
break;
}
return _e_fileman_dbus_daemon_error(msg, errmsg);
}
static E_Fileman_DBus_Daemon *
_e_fileman_dbus_daemon_new(void)
{
const struct
{
const char *method;
const char *signature;
const char *ret_signature;
E_DBus_Method_Cb func;
} *itr, desc[] = {
{"OpenDirectory", "s", "", _e_fileman_dbus_daemon_open_directory_cb},
{"OpenFile", "s", "", _e_fileman_dbus_daemon_open_file_cb},
{NULL, NULL, NULL, NULL}
};
E_Fileman_DBus_Daemon *d;
d = calloc(1, sizeof(*d));
d = calloc(1, sizeof(E_Fileman_DBus_Daemon));
if (!d)
{
perror("ERROR: FILEMAN: cannot allocate fileman dbus daemon memory.");
return NULL;
}
d->conn = e_dbus_bus_get(DBUS_BUS_SESSION);
d->conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
if (!d->conn)
goto error;
d->iface = e_dbus_interface_new(E_FILEMAN_INTERFACE);
if (!d->iface)
goto error;
d->pending.request_name = e_dbus_request_name
(d->conn, E_FILEMAN_BUS_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING,
_e_fileman_dbus_daemon_request_name_cb, d);
if (!d->pending.request_name)
goto error;
for (itr = desc; itr->method; itr++)
e_dbus_interface_method_add
(d->iface, itr->method, itr->signature, itr->ret_signature, itr->func);
_e_fileman_dbus_daemon_object_init(d);
edbus_name_request(d->conn, E_FILEMAN_BUS_NAME,
EDBUS_NAME_REQUEST_FLAG_REPLACE_EXISTING, NULL, NULL);
return d;
error:
@ -385,7 +317,7 @@ e_fileman_dbus_init(void)
if (_daemon)
return;
e_dbus_init();
edbus_init();
_daemon = _e_fileman_dbus_daemon_new();
}
@ -397,6 +329,6 @@ e_fileman_dbus_shutdown(void)
_e_fileman_dbus_daemon_free(_daemon);
_daemon = NULL;
e_dbus_shutdown();
edbus_shutdown();
}