Safe Haskell	None
Language	Haskell2010

DBus

Contents

Connection management
Message handling
Signals
Representable Types
DBus specific types
Methods
Properties
Introspection
Message Bus
Re-exports

Synopsis

Connection management

data DBusConnection Source

data ConnectionType Source

Which Bus to connect to

Constructors

System	The well-known system bus. First the environmental variable DBUS_SYSTEM_BUS_ADDRESS is checked and if it doesn't exist the address unix:path=/var/run/dbus/system_bus_socket is used
Session	The well-known session bus. Refers to the address stored in the environmental variable DBUS_SESSION_BUS_ADDRESS
Address String	The bus at the give addresss

connectBus Source

Arguments

:: ConnectionType	Bus to connect to
-> MethodCallHandler	Handler for incoming method calls
-> SignalHandler	Handler for incoming signals
-> IO DBusConnection

Create a new connection to a message bus

makeServer :: ConnectionType -> Objects -> IO DBusConnection Source

type MethodCallHandler = DBusConnection -> MessageHeader -> [SomeDBusValue] -> IO () Source

type SignalHandler = DBusConnection -> MessageHeader -> [SomeDBusValue] -> IO () Source

checkAlive :: DBusConnection -> IO Bool Source

Check whether connection is alive

waitFor :: DBusConnection -> IO () Source

Wait until connection is closed

Message handling

objectRoot :: Objects -> Handler Source

Create a message handler that dispatches matches to the methods in a root object

ignore :: Monad m => t -> t1 -> t2 -> m () Source

Ignore all incoming messages/signals

Signals

data MatchRule Source

Constructors

MatchRule
Fields mrType :: Maybe MessageType mrSender :: Maybe Text mrInterface :: Maybe Text mrMember :: Maybe Text mrPath :: Maybe (Bool, ObjectPath) mrDestination :: Maybe Text mrArgs :: [(Int, Text)] mrArgPaths :: [(Int, Text)] mrArg0namespace :: Maybe Text mrEavesdrop :: Maybe Bool

Instances

Monoid MatchRule

data Signal a Source

Constructors

Signal
Fields signalPath :: ObjectPath signalInterface :: InterfaceName signalMember :: MemberName signalBody :: DBusArguments a

Instances

SingI [DBusType] a => Show (Signal a)

data SignalDescription a Source

Constructors

SignalDescription
Fields signalDPath :: ObjectPath signalDInterface :: InterfaceName signalDMember :: MemberName signalDArguments :: ArgumentDescription (ArgParity a)

Instances

Eq (SignalDescription a)
SingI [DBusType] a => Show (SignalDescription a)
Typeable ([DBusType] -> *) SignalDescription

data SomeSignalDescription where Source

Constructors

SSD :: forall a. SingI a => SignalDescription a -> SomeSignalDescription

Instances

Eq SomeSignalDescription
Show SomeSignalDescription
Typeable * SomeSignalDescription

matchAll :: MatchRule Source

matchSignal :: Signal a -> MatchRule -> Bool Source

Match a Signal against a rule. The argN, argNPath and arg0namespace parameter are ignored at the moment

addMatch :: (MonadIO m, MonadThrow m) => MatchRule -> DBusConnection -> m () Source

Add a match rule

removeMatch :: (MonadIO m, MonadThrow m) => MatchRule -> DBusConnection -> m () Source

Remove a match rule

addSignalHandler :: MatchSignal -> MatchRule -> (SomeSignal -> IO ()) -> DBusConnection -> IO () Source

Add a match rule for the given signal specification and call function on all incoming matching signals

signalChan :: MatchSignal -> DBusConnection -> IO (TChan SomeSignal) Source

Add a match rule for the given signal specification and put all incoming signals into the TChan

handleSignal :: Representable a => SignalDescription (FlattenRepType (RepType a)) -> Maybe Text -> MatchRule -> (a -> IO ()) -> DBusConnection -> IO () Source

Add a match rule (computed from the SignalDescription) and install a handler that tries to convert the Signal's body and passes it to the callback

Representable Types

class SingI (RepType a) => Representable a where Source

Class of types that can be represented in the D-Bus type system.

The toRep and fromRep functions form a Prism and should follow the "obvious" laws:

```
fromRep (toRep x) == Just x
```
```
fmap toRep (fromRep x) =<= Just x
```

(where x =<= y iff x is Nothing or x == y)

All DBusValues represent themselves and instances for the following "canonical" pairs are provided

Haskell type => D-Bus type

WordX and IntX => UIntX and IntX respectively (for X in {16, 32, 64})
Bool => Boolean
Word8 => Byte
Double => Double
Text => String
ObjectPath => ObjectPath
DBusType => Signature
[a] => Array of a (for Representable a)
ByteString => Array of Byte
Tuples up to length 20 => Structs of equal length where each of the members is itself Representable
Map => Dict where the keys can be represented by a DBusSimpleType

An instance for String is impossible because it conflicts with the instance for lists (use Text instead)

Also note that no Representable instances are provided for Int, Integer and Float.

You can automatically derive an instance for your own Types with makeRepresentable

Associated Types

type RepType a :: DBusType Source

The DBusType that represents this type

Methods

toRep :: a -> DBusValue (RepType a) Source

Conversion from Haskell to D-Bus types

fromRep :: DBusValue (RepType a) -> Maybe a Source

Conversion from D-Bus to Haskell types.

Instances

Representable Bool
Representable Double
Representable Int16
Representable Int32
Representable Int64
Representable Word8
Representable Word16
Representable Word32
Representable Word64
Representable ()
Representable ByteString
Representable Text
Representable Signature
Representable ObjectPath
Representable Endian
Representable HeaderField
Representable HeaderFields
Representable Flags
Representable MessageType
Representable MessageHeader
(Representable a, SingI DBusType (RepType a)) => Representable [a]
SingI DBusType t => Representable (DBusValue t)
(Representable a, Representable b) => Representable (a, b)
(Ord k, Representable k, (~) DBusType (RepType k) (DBusSimpleType r), SingI DBusSimpleType r, Representable v) => Representable (Map k v)
(Representable a, Representable b, Representable c) => Representable (a, b, c)
(Representable a, Representable b, Representable c, Representable d) => Representable (a, b, c, d)
(Representable a, Representable b, Representable c, Representable d, Representable e) => Representable (a, b, c, d, e)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f) => Representable (a, b, c, d, e, f)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g) => Representable (a, b, c, d, e, f, g)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h) => Representable (a, b, c, d, e, f, g, h)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i) => Representable (a, b, c, d, e, f, g, h, i)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j) => Representable (a, b, c, d, e, f, g, h, i, j)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k) => Representable (a, b, c, d, e, f, g, h, i, j, k)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l) => Representable (a, b, c, d, e, f, g, h, i, j, k, l)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o, Representable p) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o, Representable p, Representable q) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o, Representable p, Representable q, Representable r) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o, Representable p, Representable q, Representable r, Representable s) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
(Representable a, Representable b, Representable c, Representable d, Representable e, Representable f, Representable g, Representable h, Representable i, Representable j, Representable k, Representable l, Representable m, Representable n, Representable o, Representable p, Representable q, Representable r, Representable s, Representable t) => Representable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

type family FlattenRepType a :: [DBusType] Source

Equations

FlattenRepType TypeUnit = `[]`
FlattenRepType (TypeStruct ts) = ts
FlattenRepType (DBusSimpleType wild_1627472167) = Apply (Apply (:$) (Let1627472175TSym1 wild_1627472167)) `[]`
FlattenRepType (TypeArray wild_1627472165) = Apply (Apply (:$) (Let1627472180TSym1 wild_1627472165)) `[]`
FlattenRepType (TypeDict wild_1627472161 wild_1627472163) = Apply (Apply (:$) (Let1627472186TSym2 wild_1627472161 wild_1627472163)) `[]`
FlattenRepType (TypeDictEntry wild_1627472157 wild_1627472159) = Apply (Apply (:$) (Let1627472196TSym2 wild_1627472157 wild_1627472159)) `[]`
FlattenRepType TypeVariant = Apply (Apply (:$) Let1627472204TSym0) `[]`

makeRepresentable :: Name -> Q [Dec] Source

makeRepresentableTuple :: Int -> Q Dec Source

DBus specific types

DBus Values

data DBusValue :: DBusType -> * where Source

Constructors

DBVByte :: Word8 -> DBusValue (DBusSimpleType TypeByte)
DBVBool :: Bool -> DBusValue (DBusSimpleType TypeBoolean)
DBVInt16 :: Int16 -> DBusValue (DBusSimpleType TypeInt16)
DBVUInt16 :: Word16 -> DBusValue (DBusSimpleType TypeUInt16)
DBVInt32 :: Int32 -> DBusValue (DBusSimpleType TypeInt32)
DBVUInt32 :: Word32 -> DBusValue (DBusSimpleType TypeUInt32)
DBVInt64 :: Int64 -> DBusValue (DBusSimpleType TypeInt64)
DBVUInt64 :: Word64 -> DBusValue (DBusSimpleType TypeUInt64)
DBVDouble :: Double -> DBusValue (DBusSimpleType TypeDouble)
DBVUnixFD :: Word32 -> DBusValue (DBusSimpleType TypeUnixFD)
DBVString :: Text -> DBusValue (DBusSimpleType TypeString)
DBVObjectPath :: ObjectPath -> DBusValue (DBusSimpleType TypeObjectPath)
DBVSignature :: [DBusType] -> DBusValue (DBusSimpleType TypeSignature)
DBVVariant :: SingI t => DBusValue t -> DBusValue TypeVariant
DBVArray :: [DBusValue a] -> DBusValue (TypeArray a)
DBVByteArray :: ByteString -> DBusValue (TypeArray (DBusSimpleType TypeByte))
DBVStruct :: DBusStruct ts -> DBusValue (TypeStruct ts)
DBVDict :: [(DBusValue (DBusSimpleType k), DBusValue v)] -> DBusValue (TypeDict k v)
DBVUnit :: DBusValue TypeUnit

Instances

Eq (DBusValue t)
SingI DBusType t => Show (DBusValue t)
SingI DBusType t => Representable (DBusValue t)
(IsMethod f, SingI DBusType t) => IsMethod (DBusValue t -> f)
type RepType (DBusValue t) = t
type ArgTypes (DBusValue t -> f) = (:) DBusType t (ArgTypes f)
type ResultType (DBusValue t -> f) = ResultType f

castDBV :: (SingI s, SingI t) => DBusValue s -> Maybe (DBusValue t) Source

data DBusStruct :: [DBusType] -> * where Source

Constructors

StructSingleton :: DBusValue a -> DBusStruct `[a]`
StructCons :: DBusValue a -> DBusStruct as -> DBusStruct (a : as)

Instances

Eq (DBusStruct t)
SingI [DBusType] a => Show (DBusStruct a)

data SomeDBusValue where Source

Constructors

DBV :: SingI t => DBusValue t -> SomeDBusValue

Instances

Show SomeDBusValue

dbusValue :: SingI t => SomeDBusValue -> Maybe (DBusValue t) Source

fromVariant :: SingI t => DBusValue TypeVariant -> Maybe (DBusValue t) Source

Extract a DBusValue from a Variant iff the type matches or return nothing

Signature

data DBusSimpleType Source

Types that are not composite. These can be the keys of a Dict

Constructors

TypeByte
TypeBoolean
TypeInt16
TypeUInt16
TypeInt32
TypeUInt32
TypeInt64
TypeUInt64
TypeDouble
TypeUnixFD
TypeString
TypeObjectPath
TypeSignature

Instances

Eq DBusSimpleType
Data DBusSimpleType
Read DBusSimpleType
Show DBusSimpleType
Typeable * DBusSimpleType
SingI DBusSimpleType TypeSignature
SingI DBusSimpleType TypeObjectPath
SingI DBusSimpleType TypeString
SingI DBusSimpleType TypeUnixFD
SingI DBusSimpleType TypeDouble
SingI DBusSimpleType TypeUInt64
SingI DBusSimpleType TypeInt64
SingI DBusSimpleType TypeUInt32
SingI DBusSimpleType TypeInt32
SingI DBusSimpleType TypeUInt16
SingI DBusSimpleType TypeInt16
SingI DBusSimpleType TypeBoolean
SingI DBusSimpleType TypeByte
SEq DBusSimpleType (KProxy DBusSimpleType)
PEq DBusSimpleType (KProxy DBusSimpleType)
SDecide DBusSimpleType (KProxy DBusSimpleType)
SingKind DBusSimpleType (KProxy DBusSimpleType)
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) TypeDictEntrySym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) TypeDictSym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let1627472196TSym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let1627472186TSym0
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) DBusSimpleTypeSym0
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) Let1627472175TSym0
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictEntrySym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictSym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let1627472196TSym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let1627472186TSym1
data Sing DBusSimpleType where STypeByte :: (~) DBusSimpleType z TypeByte => Sing DBusSimpleType z STypeBoolean :: (~) DBusSimpleType z TypeBoolean => Sing DBusSimpleType z STypeInt16 :: (~) DBusSimpleType z TypeInt16 => Sing DBusSimpleType z STypeUInt16 :: (~) DBusSimpleType z TypeUInt16 => Sing DBusSimpleType z STypeInt32 :: (~) DBusSimpleType z TypeInt32 => Sing DBusSimpleType z STypeUInt32 :: (~) DBusSimpleType z TypeUInt32 => Sing DBusSimpleType z STypeInt64 :: (~) DBusSimpleType z TypeInt64 => Sing DBusSimpleType z STypeUInt64 :: (~) DBusSimpleType z TypeUInt64 => Sing DBusSimpleType z STypeDouble :: (~) DBusSimpleType z TypeDouble => Sing DBusSimpleType z STypeUnixFD :: (~) DBusSimpleType z TypeUnixFD => Sing DBusSimpleType z STypeString :: (~) DBusSimpleType z TypeString => Sing DBusSimpleType z STypeObjectPath :: (~) DBusSimpleType z TypeObjectPath => Sing DBusSimpleType z STypeSignature :: (~) DBusSimpleType z TypeSignature => Sing DBusSimpleType z
type (:==) DBusSimpleType a0 b0 = Equals_1627467044 a0 b0
type Apply DBusType DBusSimpleType DBusSimpleTypeSym0 l0 = DBusSimpleTypeSym1 l0
type Apply DBusType DBusSimpleType Let1627472175TSym0 l0 = Let1627472175TSym1 l0
type DemoteRep DBusSimpleType (KProxy DBusSimpleType) = DBusSimpleType
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType TypeDictEntrySym0 l0 = TypeDictEntrySym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType TypeDictSym0 l0 = TypeDictSym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType Let1627472196TSym0 l0 = Let1627472196TSym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType Let1627472186TSym0 l0 = Let1627472186TSym1 l0

data DBusType Source

Constructors

DBusSimpleType DBusSimpleType
TypeArray DBusType
TypeStruct [DBusType]
TypeDict DBusSimpleType DBusType
TypeVariant
TypeDictEntry DBusSimpleType DBusType
TypeUnit

Instances

Eq DBusType
Data DBusType
Read DBusType
Show DBusType
Typeable * DBusType
SingI DBusType TypeUnit
SingI DBusType TypeVariant
SEq DBusType (KProxy DBusType)
PEq DBusType (KProxy DBusType)
SDecide DBusType (KProxy DBusType)
SingI [DBusType] n0 => SingI DBusType (TypeStruct n)
SingI DBusType n0 => SingI DBusType (TypeArray n)
SingI DBusSimpleType n0 => SingI DBusType (DBusSimpleType n)
SingKind DBusType (KProxy DBusType)
(SingI DBusSimpleType n0, SingI DBusType n1) => SingI DBusType (TypeDictEntry n n)
(SingI DBusSimpleType n0, SingI DBusType n1) => SingI DBusType (TypeDict n n)
Typeable ([DBusType] -> *) SignalDescription
SuppressUnusedWarnings (TyFun [DBusType] DBusType -> *) TypeStructSym0
SuppressUnusedWarnings (TyFun DBusType [DBusType] -> *) FlattenRepTypeSym0
SuppressUnusedWarnings (TyFun DBusType DBusType -> *) TypeArraySym0
SuppressUnusedWarnings (TyFun DBusType DBusType -> *) Let1627472180TSym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) TypeDictEntrySym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) TypeDictSym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let1627472196TSym0
SuppressUnusedWarnings (TyFun DBusSimpleType (TyFun DBusType DBusType -> ) -> ) Let1627472186TSym0
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) DBusSimpleTypeSym0
SuppressUnusedWarnings (TyFun DBusSimpleType DBusType -> *) Let1627472175TSym0
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictEntrySym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) TypeDictSym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let1627472196TSym1
SuppressUnusedWarnings (DBusSimpleType -> TyFun DBusType DBusType -> *) Let1627472186TSym1
data Sing DBusType where SDBusSimpleType :: (~) DBusType z (DBusSimpleType n) => Sing DBusSimpleType n -> Sing DBusType z STypeArray :: (~) DBusType z (TypeArray n) => Sing DBusType n -> Sing DBusType z STypeStruct :: (~) DBusType z (TypeStruct n) => Sing [DBusType] n -> Sing DBusType z STypeDict :: (~) DBusType z (TypeDict n n) => Sing DBusSimpleType n -> Sing DBusType n -> Sing DBusType z STypeVariant :: (~) DBusType z TypeVariant => Sing DBusType z STypeDictEntry :: (~) DBusType z (TypeDictEntry n n) => Sing DBusSimpleType n -> Sing DBusType n -> Sing DBusType z STypeUnit :: (~) DBusType z TypeUnit => Sing DBusType z
type (:==) DBusType a0 b0 = Equals_1627467051 a0 b0
type Apply DBusType DBusType TypeArraySym0 l0 = TypeArraySym1 l0
type Apply DBusType DBusType Let1627472180TSym0 l0 = Let1627472180TSym1 l0
type Apply DBusType DBusSimpleType DBusSimpleTypeSym0 l0 = DBusSimpleTypeSym1 l0
type Apply DBusType DBusSimpleType Let1627472175TSym0 l0 = Let1627472175TSym1 l0
type Apply DBusType DBusType (TypeDictEntrySym1 l1) l0 = TypeDictEntrySym2 l1 l0
type Apply DBusType DBusType (TypeDictSym1 l1) l0 = TypeDictSym2 l1 l0
type Apply DBusType DBusType (Let1627472196TSym1 l1) l0 = Let1627472196TSym2 l1 l0
type Apply DBusType DBusType (Let1627472186TSym1 l1) l0 = Let1627472186TSym2 l1 l0
type DemoteRep DBusType (KProxy DBusType) = DBusType
type Apply DBusType [DBusType] TypeStructSym0 l0 = TypeStructSym1 l0
type Apply [DBusType] DBusType FlattenRepTypeSym0 l0 = FlattenRepTypeSym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType TypeDictEntrySym0 l0 = TypeDictEntrySym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType TypeDictSym0 l0 = TypeDictSym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType Let1627472196TSym0 l0 = Let1627472196TSym1 l0
type Apply (TyFun DBusType DBusType -> *) DBusSimpleType Let1627472186TSym0 l0 = Let1627472186TSym1 l0

newtype Signature Source

Constructors

Signature
Fields fromSignature :: [DBusType]

Instances

Eq Signature
Show Signature
Representable Signature
type RepType Signature = DBusSimpleType TypeSignature

typeOf :: SingI t => DBusValue t -> DBusType Source

Objects

newtype Object Source

Constructors

Object
Fields interfaces :: Map Text Interface

Instances

Monoid Object

data Interface Source

Constructors

Interface
Fields interfaceMethods :: [Method] interfaceAnnotations :: [Annotation] interfaceSignals :: [SomeSignalDescription] interfaceProperties :: [SomeProperty]

Instances

Monoid Interface

objectPath :: Text -> ObjectPath Source

Parse an object path. Contrary to the standard, empty path parts are ignored

objectPathToText :: ObjectPath -> Text Source

stripObjectPrefix :: ObjectPath -> ObjectPath -> Maybe ObjectPath Source

isPathPrefix :: ObjectPath -> ObjectPath -> Bool Source

isRoot :: ObjectPath -> Bool Source

isEmpty :: ObjectPath -> Bool Source

Methods

data Method where Source

Constructors

Method :: (SingI avs, SingI ts) => MethodWrapper avs ts -> Text -> ArgumentDescription (ArgParity avs) -> ArgumentDescription (ArgParity ts) -> Method

Instances

Show Method

data MethodWrapper av rv where Source

Constructors

MReturn :: SingI ts => MethodHandlerT IO (DBusArguments ts) -> MethodWrapper [] ts
MAsk :: SingI t => (DBusValue t -> MethodWrapper avs rv) -> MethodWrapper (t : avs) rv

data ArgumentDescription parity where Source

Constructors

(:>) :: Text -> ArgumentDescription n -> ArgumentDescription (Arg n) infixr 0
Done :: ArgumentDescription Null

Instances

Show (ArgumentDescription n)
Typeable (Parity -> *) ArgumentDescription

repMethod :: RepMethod f => f -> MethodWrapper (RepMethodArgs f) (RepMethodValue f) Source

callMethod Source

Arguments

:: (Representable args, Representable ret)
=> Text	Entity to send the message to
-> ObjectPath	Object
-> Text	Interface
-> Text	Member (method) to call
-> args	Arguments
-> [Flag]	Method call flags
-> DBusConnection	Connection to send the call over
-> IO (Either MethodError ret)

Synchronously call a method.

This is the "cooked" version of callMethod''. It automatically converts arguments and returns values.

If the returned value's type doesn't match the expected type a MethodSignatureMissmatch is returned

You can pass in and extract multiple arguments and return values with types that are represented by DBus Structs (e.g. tuples). More specifically, multiple arguments/return values are handled in the following way:

If the method returns multiple values and the RepType of the expected return value is a struct it tries to match up the arguments with the struct fields
If the method returns a single struct and the RepType is a struct it will try to match up those two
If the RepType of the expected return value is not a struct it will only match if the method returned exactly one value and those two match up (as per normal)

This means that if the RepType of the expected return value is a struct it might be matched in two ways: Either by the method returning multiple values or the method returning a single struct. At the moment there is no way to exclude either

callMethod' Source

Arguments

:: Text	Entity to send the message to
-> ObjectPath	Object
-> Text	Interface
-> Text	Member (method) name
-> [SomeDBusValue]	Arguments
-> [Flag]	Method call flags
-> DBusConnection	Connection to send the call over
-> IO (STM (Either [SomeDBusValue] [SomeDBusValue]))

Asychronously call a method.

This is the "raw" version of callMethod. It doesn't do argument conversion.

call :: (Representable ret, Representable args) => MethodDescription (FlattenRepType (RepType args)) (FlattenRepType (RepType ret)) -> Text -> args -> [Flag] -> DBusConnection -> IO (Either MethodError ret) Source

callAsync :: (Representable args, Representable ret) => MethodDescription (FlattenRepType (RepType args)) (FlattenRepType (RepType ret)) -> Text -> args -> [Flag] -> DBusConnection -> IO (STM (Either MethodError ret)) Source

fromResponse :: Representable a => Either [SomeDBusValue] [SomeDBusValue] -> Either MethodError a Source

Try to convert the response to a method call top Haskell types

data MsgError Source

Constructors

MsgError
Fields errorName :: Text errorText :: Maybe Text errorBody :: [SomeDBusValue]

Instances

Show MsgError
Exception MsgError
Typeable * MsgError

data MethodError Source

Constructors

MethodErrorMessage [SomeDBusValue]
MethodSignatureMissmatch [SomeDBusValue]

Instances

Show MethodError
Exception MethodError
Typeable * MethodError

newtype MethodHandlerT m a Source

A Transformer for (IO) actions that might want to send a signal.

Constructors

MHT
Fields unMHT :: ExceptT MsgError (WriterT [SomeSignal] m) a

Instances

MonadTrans MethodHandlerT
(Functor m, Monad m) => Alternative (MethodHandlerT m)
Monad m => Monad (MethodHandlerT m)
Functor m => Functor (MethodHandlerT m)
Monad m => MonadPlus (MethodHandlerT m)
(Monad m, Functor m) => Applicative (MethodHandlerT m)
MonadIO m => MonadIO (MethodHandlerT m)
Representable t => RepMethod (MethodHandlerT IO t)
SingI [DBusType] t => IsMethod (MethodHandlerT IO (DBusArguments t))
type RepMethodArgs (MethodHandlerT IO t) = [] DBusType
type RepMethodValue (MethodHandlerT IO t) = FlattenRepType (RepType t)
type ArgTypes (MethodHandlerT IO (DBusArguments ts)) = [] DBusType
type ResultType (MethodHandlerT IO (DBusArguments ts)) = ts

data MethodDescription args rets where Source

Constructors

MD :: ObjectPath -> Text -> Text -> ArgumentDescription (ArgParity args) -> ArgumentDescription (ArgParity rets) -> MethodDescription args rets
Fields methodObjectPath :: ObjectPath methodInterface :: Text methodMember :: Text methodArgs :: ArgumentDescription (ArgParity args) methodResult :: ArgumentDescription (ArgParity rets)

Instances

Show (MethodDescription args rets)

data SomeMethodDescription where Source

Constructors

SMD :: (SingI args, SingI rets) => MethodDescription args rets -> SomeMethodDescription

Properties

data Property t where Source

Constructors

Property :: forall t. SingI t => ObjectPath -> Text -> Text -> Maybe (MethodHandlerT IO (DBusValue t)) -> Maybe (DBusValue t -> MethodHandlerT IO Bool) -> PropertyEmitsChangedSignal -> Property t
Fields propertyPath :: ObjectPath propertyInterface :: Text propertyName :: Text propertyGet :: Maybe (MethodHandlerT IO (DBusValue t)) propertySet :: Maybe (DBusValue t -> MethodHandlerT IO Bool) propertyEmitsChangedSignal :: PropertyEmitsChangedSignal

data SomeProperty where Source

Constructors

SomeProperty :: forall t. SingI t => Property t -> SomeProperty
Fields fromSomeProperty :: Property t

data PropertyEmitsChangedSignal Source

Constructors

PECSTrue
PECSInvalidates
PECSFalse

data RemoteProperty a Source

Constructors

RP
Fields rpEntity :: Text rpObject :: ObjectPath rpInterface :: Text rpName :: Text

Instances

Eq (RemoteProperty k a)
Show (RemoteProperty k a)

propertyChanged :: (MonadIO m, Representable a) => Property (RepType a) -> a -> MethodHandlerT m () Source

emitPropertyChanged :: Representable a => Property (RepType a) -> a -> DBusConnection -> IO () Source

getProperty :: Representable a => RemoteProperty (RepType a) -> DBusConnection -> IO (Either MethodError a) Source

setProperty :: Representable a => RemoteProperty (RepType a) -> a -> DBusConnection -> IO (Either MethodError ()) Source

handlePropertyChanged :: Representable a => RemoteProperty (RepType a) -> (Maybe a -> IO ()) -> DBusConnection -> IO () Source

mkProperty :: Representable a => ObjectPath -> Text -> Text -> Maybe (MethodHandlerT IO a) -> Maybe (a -> MethodHandlerT IO Bool) -> PropertyEmitsChangedSignal -> Property (RepType a) Source

Create a property from a getter and a setter. It will emit a PropertyChanged signal when the setter is called. To change this behaviour modify the propertyEmitsChangedSignal field

mkTVarProperty :: Representable a => ObjectPath -> Text -> Text -> PropertyAccess -> PropertyEmitsChangedSignal -> TVar a -> Property (RepType a) Source

Make a property out of a TVar. The property is considered changed on every outside set, no matter if the updated value is actually different from the old one

Introspection

addIntrospectable :: Objects -> Objects Source

Message Bus

requestName :: (MonadIO m, MonadThrow m) => Text -> RequestNameFlag -> DBusConnection -> m RequestNameReply Source

data RequestNameFlag Source

Constructors

RequestNameFlag
Fields allowReplacement :: Bool replaceExisting :: Bool doNotQueue :: Bool

Instances

Default RequestNameFlag

data RequestNameReply Source

Constructors

PrimaryOwner
InQueue
Exists
AlreadyOwner

releaseName :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m ReleaseNameReply Source

data ReleaseNameReply Source

Constructors

Released
NonExistent
NotOwner

listQueuedOwners :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m [Text] Source

listNames :: (MonadIO m, MonadThrow m) => DBusConnection -> m [Text] Source

listActivatableNames :: (MonadIO m, MonadThrow m) => DBusConnection -> m [Text] Source

nameHasOwner :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m Bool Source

startServiceByName :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m StartServiceResult Source

getNameOwner :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m Text Source

getConnectionUnixUser :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m Word32 Source

getConnectionProcessID :: (MonadIO m, MonadThrow m) => Text -> DBusConnection -> m Word32 Source

getID :: (MonadIO m, MonadThrow m) => DBusConnection -> m Text Source

Re-exports

def :: Default a => a

The default value for this type.

Eq ObjectPath
Data ObjectPath
Ord ObjectPath
Show ObjectPath
IsString ObjectPath
Representable ObjectPath
Typeable * ObjectPath
type RepType ObjectPath = DBusSimpleType TypeObjectPath