monitor
[Easydbus Library API]

Collaboration diagram for monitor:

---

Detailed Description

Module for manage TO COMPLETE

This module is under hard development phase and could be change completly.

Monitor Meta Information

Contact:

Daniele Rondina aka Ge@@ru <geaaru@gmail.com>

Status:

EasyDbus Core Library

License:

GPL

Contributor(s):

• Daniele Rondina aka Ge@@ru <geaaru@gmail.com>

Modules
	watcher
Functions
int	easydbus_object_handle_message (EasyDbus_conn *data, int event_fd)
	Handle message where it is handled an event.
int	easydbus_object_main_loop (EasyDbus_conn *data)
	Easydbus main loop function.
enum easydbus_ret_values	easydbus_watch_method_blocking (EasyDbus_conn *conn, EasyDbus_method *method_container, int timeout)
	Wait for a method with blocking mode.
enum easydbus_ret_values	easydbus_watch_signal_blocking (EasyDbus_conn *data, EasyDbus_signal *signal_container, int timeout)
	Wait for a signal with blocking mode.

---

Function Documentation

int easydbus_object_handle_message	(	EasyDbus_conn *	data,
		int	event_fd
	)

Handle message where it is handled an event.

Parameters:

	data	pointer to EasyDbus_conn object
	event_fd	event file descriptor where manage message.

Returns:

-1 error

0 ok

Note:

This function is on high development phase. Use with caution.

Definition at line 73 of file watch_events.c.

References EasyDbus_core::conn, easydbus_watcher_get_from_fd(), EASYDBUS_WATCHER_READABLE, EasyDbusDebug, EasyDbus_watcher::watch, and EasyDbus_core::watcher.

{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   struct EasyDbus_watcher *watch = NULL;
   int ret_val;

   if (data == NULL || event_fd < 0)
      return -1;

   watch = easydbus_watcher_get_from_fd (core->watcher, event_fd, 
                                         EASYDBUS_WATCHER_READABLE);
   if (watch == NULL)
      return -1;

   do {
      if (!dbus_watch_get_enabled (watch->watch)) {
         EasyDbusDebug ("Watch not enabled");
         return -1;
      }
      else
         dbus_watch_handle (watch->watch, DBUS_WATCH_READABLE);
      ret_val = dbus_connection_dispatch (core->conn);
      // this permit to call dbus_connection_dispatch
      // in the next step. See if it is needed a sleep.
      if (ret_val == DBUS_DISPATCH_NEED_MEMORY)
         return 0;
   } while (ret_val == DBUS_DISPATCH_DATA_REMAINS);

   return 0;
}

Here is the call graph for this function:

int easydbus_object_main_loop

(

EasyDbus_conn *

data

)

Easydbus main loop function.

Parameters:

data

pointer to EasyDbus_conn object

Returns:

-1 error

0 ok

Definition at line 112 of file watch_events.c.

References EasyDbus_core::conn, EasyDbus_object_box::core, EasyDbusDebug, EasyDbus_core::objects, and EasyDbus_core::user_data.

{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   void *user_data;

   if (core == NULL || core->objects == NULL)
      return -1;

   if (!dbus_connection_get_object_path_data (core->conn,
                                              core->objects->core.
                                              path, &user_data)) {
      EasyDbusDebug ("Error on recover user data");
      return -1;
   }

   if (user_data != (void *) core) {
      EasyDbusDebug ("User data pointer wrong!");
   }
   EasyDbusDebug ("User data pointer is correct!");

   while (1) 
      dbus_connection_read_write_dispatch (core->conn, -1);

   return 0;
}

enum easydbus_ret_values easydbus_watch_method_blocking	(	EasyDbus_conn *	conn,
		EasyDbus_method *	method_container,
		int	timeout
	)

Wait for a method with blocking mode.

Parameters:

	method_container	method to handled.
	conn	pointer to struct EasyDbus_conn object.
	timeout	Timeout for wait call. -1 no timeout.

Returns:

EASYDBUS_METHOD_NOT_HANDLED when method not handled.

EASYDBUS_ERROR on error

EASYDBUS_METHOD_MSG_NULL for a msg equal to null exception

EASYDBUS_METHOD_HANDLED when method is catched.

Deprecated:

Old function that must be reimplemented or removed

Definition at line 151 of file watch_events.c.

References EasyDbus_core::conn, easydbus_method_build_skeleton(), easydbus_method_free_skeleton(), EASYDBUS_METHOD_HANDLED, EASYDBUS_METHOD_MSG_NULL, EASYDBUS_METHOD_NOT_HANDLED, EasyDbusDebug, EasyDbus_method::interface, EasyDbus_method::name, and EasyDbus_conn::received_msg.

{
   DBusMessage *msg;
   struct EasyDbus_core *core = (struct EasyDbus_core *) conn;
   int ret_val = EASYDBUS_METHOD_NOT_HANDLED;

   // blocking read of the next available message
   dbus_connection_read_write_dispatch (core->conn, timeout);
   msg = dbus_connection_pop_message (core->conn);

   // loop again if we haven't read a message
   if (!msg) {
      EasyDbusDebug ("Null Message");
      return EASYDBUS_METHOD_MSG_NULL;
   }

   EasyDbusDebug ("%s Message: member = %s\n"
                  "interface = %s\n"
                  "path = %s\n",
                  dbus_message_type_to_string (dbus_message_get_type
                                               (msg)),
                  dbus_message_get_member (msg),
                  dbus_message_get_interface (msg),
                  dbus_message_get_path (msg));

   // check if the message is a signal from the correct 
   // interface and with the correct name
   if (dbus_message_is_method_call (msg,
                                    method_container->interface,
                                    method_container->name)) {
      conn->received_msg++;
      // data->received_methods++;
      struct EasyDbus_method *temp =
         easydbus_method_build_skeleton (msg);
      easydbus_method_free_skeleton (temp);
      ret_val = EASYDBUS_METHOD_HANDLED;
   }

   if (msg)
      dbus_message_unref (msg);

   return ret_val;
}

Here is the call graph for this function:

enum easydbus_ret_values easydbus_watch_signal_blocking	(	EasyDbus_conn *	data,
		EasyDbus_signal *	signal_container,
		int	timeout
	)

Wait for a signal with blocking mode.

Parameters:

	signal_container	signal to handled.
	data	pointer to struct EasyDbus_conn object.
	timeout	Timeout for wait call. -1 no timeout.

Returns:

EASYDBUS_SIGNAL_NOT_HANDLED when signal not handled.

EASYDBUS_ERROR on error

EASYDBUS_SIGNAL_MSG_NULL for a msg equal to null exception

EASYDBUS_SIGNAL_HANDLED when signal is catched.

Deprecated:

Old function that must be reimplemented or removed

Definition at line 210 of file watch_events.c.

References EasyDbus_core::conn, easydbus_build_skeleton_data(), EASYDBUS_ET_SIGNAL, EASYDBUS_SIGNAL_HANDLED, EASYDBUS_SIGNAL_MSG_NULL, EASYDBUS_SIGNAL_NOT_HANDLED, EasyDbusDebug, EasyDbus_signal::interface, EasyDbus_signal::name, and EasyDbus_conn::received_signal.

{
   DBusMessage *msg;
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   int ret_val = EASYDBUS_SIGNAL_NOT_HANDLED;

   do {
      // blocking read of the next available message
      dbus_connection_read_write_dispatch (core->conn, timeout);
      msg = dbus_connection_pop_message (core->conn);

      // loop again if we haven't read a message
      // (a timeout is handled);
      if (!msg) {
         EasyDbusDebug ("Null Message");
         return EASYDBUS_SIGNAL_MSG_NULL;
      }

      EasyDbusDebug ("%s Message: member = %s\n"
                     "interface = %s\n"
                     "path = %s\n",
                     dbus_message_type_to_string
                     (dbus_message_get_type (msg)),
                     dbus_message_get_member (msg),
                     dbus_message_get_interface (msg),
                     dbus_message_get_path (msg));

      // check if the message is a signal from the correct 
      // interface and with the correct name
      if (dbus_message_is_signal (msg,
                                  signal_container->interface,
                                  signal_container->name)) {
         //data->received_msg++;
         data->received_signal++;
         // add arg of signal to signal container passed in input 
         easydbus_build_skeleton_data (msg, EASYDBUS_ET_SIGNAL,
                                       signal_container);
         ret_val = EASYDBUS_SIGNAL_HANDLED;
      }

      if (msg)
         dbus_message_unref (msg);

   } while (ret_val == EASYDBUS_SIGNAL_NOT_HANDLED);

   return ret_val;
}

Here is the call graph for this function:

---