HORIZON HASKELLDocslts/ghc-9.10.x248f8f02026-10-05Search names, modules, packages, or :: a typeCtrl K

GHC 9.10.3 · lts/ghc-9.10.x · 248f8f0 · 2026-10-05

Moduledbus-1.4.1Haskell2010

DBus.Client

D-Bus clients are an abstraction over the lower-level messaging system. When combined with an external daemon called the "bus", clients can perform remote procedure calls to other clients on the bus.

Clients may also listen for or emit signals, which are asynchronous broadcast notifications.

Example: connect to the session bus, and get a list of active names.

{-# LANGUAGE OverloadedStrings #-}

import Data.List (sort)
import DBus
import DBus.Client

main = do
    client <- connectSession
    //
    -- Request a list of connected clients from the bus
    reply <- call_ client (methodCall "/org/freedesktop/DBus" "org.freedesktop.DBus" "ListNames")
        { methodCallDestination = Just "org.freedesktop.DBus"
        }
    //
    -- org.freedesktop.DBus.ListNames() returns a single value, which is
    -- a list of names (here represented as [String])
    let Just names = fromVariant (methodReturnBody reply !! 0)
    //
    -- Print each name on a line, sorted so reserved names are below
    -- temporary names.
    mapM_ putStrLn (sort names)
  • 15 types
  • 1 class
  • 63 values
  • Packagedbus-1.4.1
  • Exports79
  • LanguageHaskell2010
  • LicenceApache-2.0
  • SourceClient.hs

Clients

2 declarations
datadata Client
#

An active client session to a message bus. Clients may send or receive method calls, and listen for or emit signals.

Constructors

Instances2AutoMethod

Path/Interface storage

7 declarations

Connecting to a bus

5 declarations
valueconnectSystem :: IO Client
#

Connect to the bus specified in the environment variable DBUS_SYSTEM_BUS_ADDRESS, or to unix:path=/var/run/dbus/system_bus_socket if DBUS_SYSTEM_BUS_ADDRESS is not set.

Throws a ClientError if DBUS_SYSTEM_BUS_ADDRESS contains an invalid address, or if connecting to the bus failed.

valueconnectSession :: IO Client
#

Connect to the bus specified in the environment variable DBUS_SESSION_BUS_ADDRESS, which must be set.

Throws a ClientError if DBUS_SESSION_BUS_ADDRESS is unset, contains an invalid address, or if connecting to the bus failed.

valueconnectStarter :: IO Client
#

Connect to the bus specified in the environment variable DBUS_STARTER_ADDRESS, which must be set.

Throws a ClientError if DBUS_STARTER_ADDRESS is unset, contains an invalid address, or if connecting to the bus failed.

valuedisconnect :: Client -> IO ()
#

Stop a Client's callback thread and close its underlying socket.

Sending method calls

10 declarations
valuecall_ :: Client -> MethodCall -> IO MethodReturn
#

Send a method call to the bus, and wait for the response.

Unsets the noReplyExpected message flag before sending.

Throws a ClientError if the method call couldn't sent, if the reply couldn't be parsed, or if the reply was a MethodError.

valuecallNoReply :: Client -> MethodCall -> IO ()
#

Send a method call to the bus, and do not wait for a response.

Sets the noReplyExpected message flag before sending.

Throws a ClientError if the method call couldn't be sent.

Receiving method calls

12 declarations
valueexport :: Client -> ObjectPath -> Interface -> IO ()
#

Export the given Interface at the given ObjectPath

Use autoMethod to construct a Method from a function that accepts and returns simple types.

Use method to construct a Method from a function that handles parameter conversion manually.

ping :: MethodCall -> IO Reply
ping _ = ReplyReturn []

sayHello :: String -> IO String
sayHello name = return ("Hello " ++ name ++ "!")

 export client "/hello_world"
   defaultInterface { interfaceName = "com.example.HelloWorld"
                    , interfaceMethods =
                      [ method "com.example.HelloWorld" "Ping" ping
                      , autoMethod "com.example.HelloWorld" "Hello" sayHello
                      ]
                    }
valuemakeMethod
  1. :: MemberName
  2. -> Signature

    Input parameter signature

  3. -> Signature

    Output parameter signature

  4. -> (MethodCall -> DBusR Reply)
  5. -> Method
#

Define a method handler, which will accept method calls with the given interface and member name.

Note that the input and output parameter signatures are used for introspection, but are not checked when executing a method.

See autoMethod for an easier way to export functions with simple parameter and return types.

classclass AutoMethod a where
#

Used to automatically generate method signatures for introspection documents. To support automatic signatures, a method's parameters and return value must all be instances of IsValue.

This class maps Haskell idioms to D-Bus; it is therefore unable to generate some signatures. In particular, it does not support methods which accept/return a single structure, or single-element structures. It also cannot generate signatures for methods with parameters or return values which are only instances of IsVariant. For these cases, please use DBus.Client.method.

To match common Haskell use, if the return value is a tuple, it will be converted to a list of return values.

Instances5AutoMethod
valueautoMethod :: AutoMethod fn => MemberName -> fn -> Method
#

Prepare a Haskell function for export, automatically detecting the function's type signature.

See AutoMethod for details on the limitations of this function.

See method for exporting functions with user-defined types.

valuethrowError
  1. :: ErrorName
  2. -> String

    Error message

  3. -> [Variant]

    Additional items of the error body

  4. -> IO a
#

Normally, any exceptions raised while executing a method will be given the generic "org.freedesktop.DBus.Error.Failed" name. throwError allows the programmer to specify an error name, and provide additional information to the remote application. You may use this instead of throwIO to abort a method call.

Signals

5 declarations
valueaddMatch :: Client -> MatchRule -> (Signal -> IO ()) -> IO SignalHandler
#

Request that the bus forward signals matching the given rule to this client, and process them in a callback.

A received signal might be processed by more than one callback at a time. Callbacks each run in their own thread.

The returned SignalHandler can be passed to removeMatch to stop handling this signal.

Throws a ClientError if the match rule couldn't be added to the bus.

Match rules

datadata MatchRule
#

A match rule describes which signals a particular callback is interested in. Use matchAny to construct match rules.

Example: a match rule which matches signals sent by the root object.

matchFromRoot :: MatchRule
matchFromRoot = matchAny { matchPath = Just "/" }
Instances1Show
valuematchSender :: MatchRule -> Maybe BusName
#

If set, only receives signals sent from the given bus name.

The standard D-Bus implementation from http://dbus.freedesktop.org/ almost always sets signal senders to the unique name of the sending client. If matchSender is a requested name like "com.example.Foo", it will not match any signals.

The exception is for signals sent by the bus itself, which always have a sender of "org.freedesktop.DBus".

Introspection

5 declarations

Name reservation

8 declarations
valuerequestName :: Client -> BusName -> [RequestNameFlag] -> IO RequestNameReply
#

Asks the message bus to assign the given name to this client. The bus maintains a queue of possible owners, where the head of the queue is the current ("primary") owner.

There are several uses for name reservation:

  • Clients which export methods reserve a name so users and applications can send them messages. For example, the GNOME Keyring reserves the name "org.gnome.keyring" on the user's session bus, and NetworkManager reserves "org.freedesktop.NetworkManager" on the system bus.

  • When there are multiple implementations of a particular service, the service standard will ususally include a generic bus name for the service. This allows other clients to avoid depending on any particular implementation's name. For example, both the GNOME Keyring and KDE KWallet services request the "org.freedesktop.secrets" name on the user's session bus.

  • A process with "single instance" behavior can use name assignment to check whether the instance is already running, and invoke some method on it (e.g. opening a new window).

Throws a ClientError if the call failed.

datadata RequestNameReply
#

Constructors

  • NamePrimaryOwner

    This client is now the primary owner of the requested name.

  • NameInQueue

    The name was already reserved by another client, and replacement was either not attempted or not successful.

  • NameExists

    The name was already reserved by another client, DoNotQueue was set, and replacement was either not attempted or not successful.

  • NameAlreadyOwner

    This client is already the primary owner of the requested name.

  • UnknownRequestNameReply Word32

    Not exported; exists to generate a compiler warning if users case on the reply and forget to include a default case.

Instances2Eq, Show
datadata ReleaseNameReply
#

Constructors

Instances2Eq, Show

Client errors

4 declarations

Advanced connection options

12 declarations
valueclientThreadRunner :: ClientOptions t -> IO () -> IO ()
#

A function to run the client thread. The provided IO computation should be called repeatedly; each time it is called, it will process one incoming message.

The provided computation will throw a ClientError if it fails to process an incoming message, or if the connection is lost.

The default implementation is forever.

newtypenewtype ErrorName
#

Error names are used to identify which type of error was returned from a method call. Error names consist of alphanumeric characters separated by periods.

See http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-error for details.

Instances6Eq, Ord, Show, IsString, NFData, IsVariant