watch_events_internal.c

Go to the documentation of this file.

/*
 EasyDbus: DBUS Binding Library.
 Copyright (C) 2007  Daniele Rondina aka ge@@ru, geaaru@gmail.com 

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 Filename:  watch_events_internal.c
 
 Description:  
 
 Version:  1.0
 Created:  09/18/07 11:33:33 CEST
 Revision:  none
 
 Author:   Daniele Rondina aka Ge@@ru (geaaru@gmail.com) 
 License:  GPL 2.0
*/

#include <string.h>
#include <stdlib.h>
// easydbus includes
#include "debug.h"
#include "easydbus-core.h"
#include "reply_internal.h"
#include "monitor_internal.h"

inline int
easydbus_send_method_withReply_Blocking (struct EasyDbus_core *core,
                                         DBusMessage * msg, 
                                         struct EasyDbus_method *method, 
                                         int timeout) 
{
   int ret_val = 0;
   DBusError err;

   dbus_connection_flush (core->conn);
   dbus_error_init (&err);

   DBusMessage *reply =
      dbus_connection_send_with_reply_and_block (core->conn,
                                                 msg, timeout, &err);

   dbus_connection_flush (core->conn);

   if (dbus_error_is_set (&err)) {
      EasyDbusDebug ("Received error reply: %s\n", err.message);
      easydbus_reply_build_error (method, err.message);
      ret_val = -1;
      goto exit_;
   }

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

   if (easydbus_reply_build_struct (method, reply)) {
      ret_val = -1;
      goto exit_;
   }

   dbus_error_free (&err);

 exit_:
   /* see if is needed */
   if (reply != NULL)
      dbus_message_unref (reply);
   dbus_error_free (&err);
   return ret_val;
}


dbus_bool_t 
easydbus_add_watch_callback (DBusWatch * watch, 
                             void *data) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   struct EasyDbus_watcher *watcher = NULL;
   int flags = 0, fd = 0;

   flags = dbus_watch_get_flags (watch);
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
   fd = dbus_watch_get_fd (watch);
#else
   fd = dbus_watch_get_unix_fd (watch);
#endif

   watcher = easydbus_watcher_get_from_watch (core->watcher,
                                              watch);
   if (watcher) {
      // if watcher is already on list
      EasyDbusDebug ("Enable already create watcher (%p %s) "
                     "with fd %d",
                     watch, 
                     (flags & DBUS_WATCH_READABLE ? "readable" :
                      ((flags & DBUS_WATCH_WRITABLE) ? "writable" : 
                        "error" )), fd);
      
      core->user_data.watcher_add_cb (watcher, 
                                      core->user_data.watcher_closure);
   } else {
      dbus_watch_set_data (watch, data, NULL);
      watcher = easydbus_watcher_create_skeleton ();
      // see how manage this exception
      if (watcher == NULL)
         return FALSE;

      watcher->watch = watch;
      easydbus_watcher_add (core, watcher);

      EasyDbusDebug ("Add %s watcher (%p %s) with fd %d", 
                     (flags & DBUS_WATCH_READABLE ? "readable" :
                      ((flags & DBUS_WATCH_WRITABLE) ? "writable" : 
                        "error" )), watch, 
                     dbus_watch_get_enabled (watch) ? "enable" : "not enable",
                     fd);
   }
   return TRUE;
}

void 
easydbus_remove_watch_callback (DBusWatch * watch, 
                                void *data) 
{
   struct EasyDbus_core *core = (struct EasyDbus_core *) data;
   int flags = 0;
   
   flags = dbus_watch_get_flags (watch);

   if (easydbus_watcher_remove_dbus_watch (core, watch))
     EasyDbusDebug ("Error on remove watcher (%s) with fd "
                    "%d or already removed.",
                    (flags & DBUS_WATCH_READABLE ? "readable" :
                     ((flags & DBUS_WATCH_WRITABLE) ? "writable" : 
                       "error" )), 
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
                    dbus_watch_get_fd (watch));
#else
                    dbus_watch_get_unix_fd (watch));
#endif
   else
    EasyDbusDebug ("Remove Watcher (%s) with fd = %d",
                   (flags & DBUS_WATCH_READABLE ? "readable" :
                    ((flags & DBUS_WATCH_WRITABLE) ? "writable" : 
                      "error" )),
#if defined(__DBUS_VERSION__) && (__DBUS_VERSION__ <= 102)
                   dbus_watch_get_fd (watch));
#else
                  dbus_watch_get_unix_fd(watch));
#endif
}

void 
easydbus_toggle_watch_callback (DBusWatch * watch, 
                                void *data) 
{
   EasyDbusDebug ("Toggle callback");
   easydbus_remove_watch_callback (watch, data);
}

#ifdef EASYDBUS_TESTING

void 
easydbus_dispatch_status_callback (DBusConnection * conn, 
                                   DBusDispatchStatus status, 
                                   void *data) 
{
   switch (status) {
      case DBUS_DISPATCH_COMPLETE:
         EasyDbusDebug ("Complete dispatch status");
         break;
      case DBUS_DISPATCH_DATA_REMAINS:
         EasyDbusDebug ("Complete data remains");
         break;
      case DBUS_DISPATCH_NEED_MEMORY:
      default:
         break;
   }
}

dbus_bool_t
easydbus_add_timeout (DBusTimeout * timeout, void *data)
{
   //struct EasyDbus_core *core =
   // (struct EasyDbus_core *) data;

   if (!dbus_timeout_get_enabled (timeout)) {
      EasyDbusDebug ("timeout isn't enable");
      return TRUE;
   }
   EasyDbusDebug ("timeout added");
   return TRUE;
}

void
easydbus_remove_timeout (DBusTimeout * timeout, void *data)
{
   EasyDbusDebug ("remove timeout");
}

void
easydbus_toggle_timeout (DBusTimeout * timeout, void *data)
{
   EasyDbusDebug ("toggle timeout");
}

void
easydbus_wakeup_main_callback (void *data)
{

   struct EasyDbus_core *core = (struct EasyDbus_core *) data;

   if (core == NULL) {
      EasyDbusDebug ("Error data == NULL");
      return;
   }
   EasyDbusDebug ("i'm here");
}
#endif

// vim: ts=3 shiftwidth=3 expandtab

---