NAME
   AnyEvent::DBus - adapt Net::DBus to AnyEvent

SYNOPSIS
      use AnyEvent::DBus;

      # now use the Net::DBus API, preferably the non-blocking variants:

      use Net::DBus::Annotation qw(:call);

      $bus->get_object (...)
          ->Method (dbus_call_async, $arg1, ...)
          ->set_notify (sub {
             my @data = $_[0]->get_result
             ...
          });

      $bus->get_connection->send (...);

DESCRIPTION
   This module is an AnyEvent user, you need to make sure that you use and
   run a supported event loop.

   Loading this module will install the necessary magic to seamlessly
   integrate Net::DBus into AnyEvent. It does this by quite brutally
   hacking Net::DBus::Reactor so that all dbus connections created after
   loading this module will automatically be managed by this module.

   Note that a) a lot inside Net::DBus is still blocking b) if you call a
   method that blocks, you again block your process (basically anything but
   calls to the Net::DBus::Binding::Connection objects block, but see
   Net::DBus::Annoation, specifically dbus_call_async) c) the underlying
   libdbus is often blocking itself, even with infinite timeouts and d)
   this module only implements the minimum API required to make Net::DBus
   work - Net::DBus unfortunately has no nice hooking API.

   However, unlike Net::DBus::Reactor, this module should be fully
   non-blocking as long as you only use non-blocking APIs
   (Net::DBus::Reactor blocks on writes). It should also be faster, but
   Net::DBus is such a morass so unneeded method calls that speed won't
   matter much...

 EXAMPLE
   Here is a simple example. Both work with AnyEvent::DBus and do the same
   thing, but only the second is actually non-blocking.

   Example 1: list registered named, blocking version.

      use AnyEvent::DBus;

      my $conn = Net::DBus->find;
      my $bus  = $conn->get_bus_object;

      for my $name (@{ $bus->ListNames }) {
         print "  $name\n";
      }

   Example 1: list registered named, somewhat non-blocking version.

      use AnyEvent;
      use AnyEvent::DBus;
      use Net::DBus::Annotation qw(:call);

      my $conn = Net::DBus->find; # always blocks :/
      my $bus  = $conn->get_bus_object;

      my $quit = AE::cv;

      # the trick here is to prepend dbus_call_async to any method
      # arguments and then to call the set_notify method on the
      # returned Net::DBus::AsyncReply object

      $bus->ListNames (dbus_call_async)->set_notify (sub {
         for my $name (@{ $_[0]->get_result }) {
            print "  $name\n";
         }
         $quit->send;
      });

      $quit->recv;

SEE ALSO
   AnyEvent, Net::DBus.

AUTHOR
    Marc Lehmann <[email protected]>
    http://home.schmorp.de/