383 lines
12 KiB
Haskell
383 lines
12 KiB
Haskell
--------------------------------------------------------------------------------
|
|
-- Bluetooth plugin
|
|
--
|
|
-- Use the bluez interface on DBus to check status
|
|
--
|
|
-- org.bluez dynamically updates its DBus interfaces using the standard Object
|
|
-- Manager. The adapter is located at path "/org/bluez/hci<X>" where X is
|
|
-- usually 0, and each device is "/org/bluez/hci<X>/<MAC_ADDRESS>".
|
|
--
|
|
-- This plugin will reflect if the adapter is powered and if any device is
|
|
-- connected to it. The rough outline for this procedure:
|
|
-- 1) get the adapter from the object manager
|
|
-- 2) get all devices associated with the adapter using the object interface
|
|
-- 3) determine if the adapter is powered
|
|
-- 4) determine if any devices are connected
|
|
-- 5) format the icon; powered vs not powered controls the color and connected
|
|
-- vs not connected controls the icon (connected bluetooth symbol has two
|
|
-- dots flanking it)
|
|
--
|
|
-- Step 3 can be accomplished using the "org.bluez.Adapter1" interface and
|
|
-- querying the "Powered" property. Step 4 can be done using the
|
|
-- "org.bluez.Device1" interface and the "Connected" property for each device
|
|
-- path. Since these are properties, we can asynchronously read changes to them
|
|
-- via the "PropertiesChanged" signal.
|
|
--
|
|
-- If any devices are added/removed, steps 2-4 will need to be redone and any
|
|
-- listeners will need to be updated. (TODO not sure which signals to use in
|
|
-- determining if a device is added)
|
|
--
|
|
-- TODO also not sure if I need to care about multiple adapters and/or the
|
|
-- adapter changing.
|
|
|
|
module Xmobar.Plugins.Bluetooth
|
|
( Bluetooth (..)
|
|
, btAlias
|
|
, btDep
|
|
)
|
|
where
|
|
|
|
import DBus
|
|
import DBus.Client
|
|
import Data.Internal.DBus
|
|
import Data.Internal.XIO
|
|
import RIO
|
|
import RIO.FilePath
|
|
import RIO.List
|
|
import qualified RIO.Map as M
|
|
import qualified RIO.Text as T
|
|
import XMonad.Internal.DBus.Common
|
|
import Xmobar
|
|
import Xmobar.Plugins.Common
|
|
|
|
btAlias :: T.Text
|
|
btAlias = "bluetooth"
|
|
|
|
btDep :: DBusDependency_ SysClient
|
|
btDep =
|
|
Endpoint [Package Official "bluez"] btBus btOMPath omInterface $
|
|
Method_ getManagedObjects
|
|
|
|
data Bluetooth = Bluetooth Icons Colors deriving (Read, Show)
|
|
|
|
instance Exec Bluetooth where
|
|
alias (Bluetooth _ _) = T.unpack btAlias
|
|
start (Bluetooth icons colors) cb =
|
|
withDBusClientConnection cb (Just "bluetooth.log") $ startAdapter icons colors cb
|
|
|
|
startAdapter
|
|
:: Icons
|
|
-> Colors
|
|
-> Callback
|
|
-> SysClient
|
|
-> RIO SimpleApp ()
|
|
startAdapter is cs cb cl = do
|
|
state <- newMVar emptyState
|
|
let dpy cb' = displayIcon cb' (iconFormatter is cs)
|
|
mapRIO (PluginEnv cl state dpy cb) $ do
|
|
ot <- getBtObjectTree
|
|
case findAdapter ot of
|
|
Nothing -> logError "could not find bluetooth adapter"
|
|
Just adapter -> do
|
|
-- set up adapter
|
|
initAdapter adapter
|
|
void $ addAdaptorListener adapter
|
|
-- set up devices on the adapter (and listeners for adding/removing devices)
|
|
let devices = findDevices adapter ot
|
|
addDeviceAddedListener adapter
|
|
addDeviceRemovedListener adapter
|
|
forM_ devices $ \d -> addAndInitDevice (deviceLogFile d) d
|
|
-- after setting things up, show the icon based on the initialized state
|
|
pluginDisplay
|
|
|
|
deviceLogFile :: ObjectPath -> FilePath
|
|
deviceLogFile =
|
|
T.unpack
|
|
. T.append "bluetooth"
|
|
. T.map (\c -> if c == '/' then '_' else c)
|
|
. T.pack
|
|
. formatObjectPath
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Icon Display
|
|
--
|
|
-- Color corresponds to the adaptor powered state, and the icon corresponds to
|
|
-- if it is paired or not. If the adaptor state is undefined, display "N/A"
|
|
|
|
type IconFormatter = (Maybe Bool -> Bool -> T.Text)
|
|
|
|
type Icons = (T.Text, T.Text)
|
|
|
|
displayIcon :: Callback -> IconFormatter -> BTIO ()
|
|
displayIcon callback formatter =
|
|
liftIO . callback . T.unpack . uncurry formatter =<< readState
|
|
|
|
-- TODO maybe I want this to fail when any of the device statuses are Nothing
|
|
iconFormatter :: Icons -> Colors -> IconFormatter
|
|
iconFormatter (iconConn, iconDisc) cs powered connected =
|
|
maybe na (\p -> colorText cs p icon) powered
|
|
where
|
|
icon = if connected then iconConn else iconDisc
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Connection State
|
|
--
|
|
-- The signal handlers all run on separate threads, yet the icon depends on
|
|
-- the state reflected by all these signals. The best (only?) way to do this is
|
|
-- is to track the shared state of the bluetooth adaptor and its devices using
|
|
-- an MVar.
|
|
|
|
type BTIO = PluginIO BtState SysClient
|
|
|
|
data BTDevice = BTDevice
|
|
{ btDevConnected :: Maybe Bool
|
|
, btDevSigHandler :: SignalHandler
|
|
}
|
|
|
|
type ConnectedDevices = M.Map ObjectPath BTDevice
|
|
|
|
data BtState = BtState
|
|
{ btDevices :: ConnectedDevices
|
|
, btPowered :: Maybe Bool
|
|
}
|
|
|
|
emptyState :: BtState
|
|
emptyState =
|
|
BtState
|
|
{ btDevices = M.empty
|
|
, btPowered = Nothing
|
|
}
|
|
|
|
readState :: BTIO (Maybe Bool, Bool)
|
|
readState = do
|
|
p <- readPowered
|
|
c <- readDevices
|
|
return (p, anyDevicesConnected c)
|
|
|
|
modifyState :: (BtState -> BTIO (BtState, a)) -> BTIO a
|
|
modifyState f = do
|
|
m <- asks plugState
|
|
modifyMVar m f
|
|
|
|
beforeDisplay :: BTIO () -> BTIO ()
|
|
beforeDisplay f = f >> pluginDisplay
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Object manager
|
|
|
|
findAdapter :: ObjectTree -> Maybe ObjectPath
|
|
findAdapter = find (("/org/bluez/hci" `isPrefixOf`) . formatObjectPath) . M.keys
|
|
|
|
findDevices :: ObjectPath -> ObjectTree -> [ObjectPath]
|
|
findDevices adapter = filter (adaptorHasDevice adapter) . M.keys
|
|
|
|
adaptorHasDevice :: ObjectPath -> ObjectPath -> Bool
|
|
adaptorHasDevice adaptor device = case splitPathNoRoot device of
|
|
[org, bluez, hciX, _] -> splitPathNoRoot adaptor == [org, bluez, hciX]
|
|
_ -> False
|
|
|
|
splitPathNoRoot :: ObjectPath -> [FilePath]
|
|
splitPathNoRoot = dropWhile (== "/") . splitDirectories . formatObjectPath
|
|
|
|
getBtObjectTree
|
|
:: ( HasClient env
|
|
, SafeClient c
|
|
, MonadReader (env c) m
|
|
, HasLogFunc (env c)
|
|
, MonadUnliftIO m
|
|
)
|
|
=> m ObjectTree
|
|
getBtObjectTree = callGetManagedObjects btBus btOMPath
|
|
|
|
btOMPath :: ObjectPath
|
|
btOMPath = objectPath_ "/"
|
|
|
|
addBtOMListener
|
|
:: ( HasClient env
|
|
, SafeClient c
|
|
, MonadReader (env c) m
|
|
, HasLogFunc (env c)
|
|
, MonadUnliftIO m
|
|
)
|
|
=> SignalCallback m
|
|
-> m ()
|
|
addBtOMListener sc = void $ addInterfaceAddedListener btBus btOMPath sc
|
|
|
|
addDeviceAddedListener :: ObjectPath -> BTIO ()
|
|
addDeviceAddedListener adapter = addBtOMListener addDevice
|
|
where
|
|
addDevice = pathCallback adapter $ \d ->
|
|
addAndInitDevice (deviceLogFile d) d
|
|
|
|
addDeviceRemovedListener :: ObjectPath -> BTIO ()
|
|
addDeviceRemovedListener adapter =
|
|
addBtOMListener remDevice
|
|
where
|
|
remDevice = pathCallback adapter $ \d -> do
|
|
old <- removeDevice d
|
|
cl <- asks plugClient
|
|
forM_ old $ liftIO . removeMatch (toClient cl) . btDevSigHandler
|
|
|
|
pathCallback :: ObjectPath -> (ObjectPath -> BTIO ()) -> SignalCallback BTIO
|
|
pathCallback adapter f [device, _] = forM_ (fromVariant device) $ \d -> do
|
|
when (adaptorHasDevice adapter d) $ beforeDisplay $ f d
|
|
pathCallback _ _ _ = return ()
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Adapter
|
|
|
|
initAdapter :: ObjectPath -> BTIO ()
|
|
initAdapter adapter = do
|
|
reply <- callGetPowered adapter
|
|
logInfo $ "initializing adapter at path " <> adapter_
|
|
-- TODO this could fail if the variant is something weird; the only
|
|
-- indication I will get is "NA"
|
|
putPowered $ fromSingletonVariant reply
|
|
where
|
|
adapter_ = displayWrapQuote $ displayObjectPath adapter
|
|
|
|
matchBTProperty
|
|
:: ( SafeClient c
|
|
, HasClient env
|
|
, MonadReader (env c) m
|
|
, HasLogFunc (env c)
|
|
, MonadUnliftIO m
|
|
)
|
|
=> ObjectPath
|
|
-> m (Maybe MatchRule)
|
|
matchBTProperty p = matchPropertyFull btBus (Just p)
|
|
|
|
withBTPropertyRule
|
|
:: IsVariant a
|
|
=> FilePath
|
|
-> ObjectPath
|
|
-> (Maybe a -> BTIO ())
|
|
-> InterfaceName
|
|
-> T.Text
|
|
-> BTIO (Maybe SignalHandler)
|
|
withBTPropertyRule logpath path update iface prop = do
|
|
dpy <- asks plugDisplay
|
|
s <- asks plugState
|
|
cb <- asks plugCallback
|
|
res <- matchBTProperty path
|
|
case res of
|
|
Just rule -> Just <$> addMatchCallback rule (callback cb s dpy)
|
|
Nothing -> do
|
|
logError $
|
|
"could not add listener for prop "
|
|
<> prop_
|
|
<> " on path "
|
|
<> path_
|
|
return Nothing
|
|
where
|
|
callback cb s dpy sig = withDBusClientConnection cb (Just logpath) $ \c' ->
|
|
mapRIO (PluginEnv c' s dpy cb) $
|
|
signalToUpdate $
|
|
matchConnected sig
|
|
path_ = displayObjectPath path
|
|
prop_ = Utf8Builder $ encodeUtf8Builder prop
|
|
signalToUpdate = withSignalMatch update
|
|
matchConnected = matchPropertyChanged iface prop
|
|
|
|
addAdaptorListener :: ObjectPath -> BTIO (Maybe SignalHandler)
|
|
addAdaptorListener adaptor =
|
|
withBTPropertyRule "bluetooth-adaptor" adaptor procMatch adapterInterface adaptorPowered
|
|
where
|
|
procMatch = beforeDisplay . putPowered
|
|
|
|
callGetPowered
|
|
:: ( HasClient env
|
|
, MonadReader (env c) m
|
|
, HasLogFunc (env c)
|
|
, SafeClient c
|
|
, MonadUnliftIO m
|
|
)
|
|
=> ObjectPath
|
|
-> m [Variant]
|
|
callGetPowered adapter =
|
|
callPropertyGet btBus adapter adapterInterface $
|
|
memberName_ $
|
|
T.unpack adaptorPowered
|
|
|
|
putPowered :: Maybe Bool -> BTIO ()
|
|
putPowered ds = modifyState $ \s -> return (s {btPowered = ds}, ())
|
|
|
|
readPowered :: BTIO (Maybe Bool)
|
|
readPowered = fmap btPowered $ readMVar =<< asks plugState
|
|
|
|
adapterInterface :: InterfaceName
|
|
adapterInterface = interfaceName_ "org.bluez.Adapter1"
|
|
|
|
adaptorPowered :: T.Text
|
|
adaptorPowered = "Powered"
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Devices
|
|
|
|
addAndInitDevice :: FilePath -> ObjectPath -> BTIO ()
|
|
addAndInitDevice logpath device = do
|
|
res <- addDeviceListener logpath device
|
|
case res of
|
|
Just handler -> do
|
|
logInfo $ "initializing device at path " <> device_
|
|
initDevice handler device
|
|
Nothing -> logError $ "could not initialize device at path " <> device_
|
|
where
|
|
device_ = displayWrapQuote $ displayObjectPath device
|
|
|
|
initDevice :: SignalHandler -> ObjectPath -> BTIO ()
|
|
initDevice sh device = do
|
|
reply <- callGetConnected device
|
|
void $
|
|
insertDevice device $
|
|
BTDevice
|
|
{ btDevConnected = fromVariant =<< listToMaybe reply
|
|
, btDevSigHandler = sh
|
|
}
|
|
|
|
addDeviceListener :: FilePath -> ObjectPath -> BTIO (Maybe SignalHandler)
|
|
addDeviceListener logpath device =
|
|
withBTPropertyRule logpath device procMatch devInterface devConnected
|
|
where
|
|
procMatch = beforeDisplay . void . updateDevice device
|
|
|
|
callGetConnected
|
|
:: ( SafeClient c
|
|
, HasClient env
|
|
, MonadReader (env c) m
|
|
, HasLogFunc (env c)
|
|
, MonadUnliftIO m
|
|
)
|
|
=> ObjectPath
|
|
-> m [Variant]
|
|
callGetConnected p =
|
|
callPropertyGet btBus p devInterface $
|
|
memberName_ (T.unpack devConnected)
|
|
|
|
insertDevice :: ObjectPath -> BTDevice -> BTIO Bool
|
|
insertDevice device dev = modifyState $ \s -> do
|
|
let new = M.insert device dev $ btDevices s
|
|
return (s {btDevices = new}, anyDevicesConnected new)
|
|
|
|
updateDevice :: ObjectPath -> Maybe Bool -> BTIO Bool
|
|
updateDevice device status = modifyState $ \s -> do
|
|
let new = M.update (\d -> Just d {btDevConnected = status}) device $ btDevices s
|
|
return (s {btDevices = new}, anyDevicesConnected new)
|
|
|
|
anyDevicesConnected :: ConnectedDevices -> Bool
|
|
anyDevicesConnected = or . mapMaybe btDevConnected . M.elems
|
|
|
|
removeDevice :: ObjectPath -> BTIO (Maybe BTDevice)
|
|
removeDevice device = modifyState $ \s -> do
|
|
let devs = btDevices s
|
|
return (s {btDevices = M.delete device devs}, M.lookup device devs)
|
|
|
|
readDevices :: BTIO ConnectedDevices
|
|
readDevices = fmap btDevices $ readMVar =<< asks plugState
|
|
|
|
devInterface :: InterfaceName
|
|
devInterface = interfaceName_ "org.bluez.Device1"
|
|
|
|
devConnected :: T.Text
|
|
devConnected = "Connected"
|