{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A 'GI.Gst.Objects.DeviceProvider.DeviceProvider' subclass is provided by a plugin that handles devices
if there is a way to programatically list connected devices. It can also
optionally provide updates to the list of connected devices.

Each 'GI.Gst.Objects.DeviceProvider.DeviceProvider' subclass is a singleton, a plugin should
normally provide a single subclass for all devices.

Applications would normally use a 'GI.Gst.Objects.DeviceMonitor.DeviceMonitor' to monitor devices
from all relevant providers.
-}

module GI.Gst.Objects.DeviceProvider
    ( 

-- * Exported types
    DeviceProvider(..)                      ,
    IsDeviceProvider                        ,
    toDeviceProvider                        ,
    noDeviceProvider                        ,


 -- * Methods
-- ** canMonitor #method:canMonitor#
    DeviceProviderCanMonitorMethodInfo      ,
    deviceProviderCanMonitor                ,


-- ** deviceAdd #method:deviceAdd#
    DeviceProviderDeviceAddMethodInfo       ,
    deviceProviderDeviceAdd                 ,


-- ** deviceRemove #method:deviceRemove#
    DeviceProviderDeviceRemoveMethodInfo    ,
    deviceProviderDeviceRemove              ,


-- ** getBus #method:getBus#
    DeviceProviderGetBusMethodInfo          ,
    deviceProviderGetBus                    ,


-- ** getDevices #method:getDevices#
    DeviceProviderGetDevicesMethodInfo      ,
    deviceProviderGetDevices                ,


-- ** getFactory #method:getFactory#
    DeviceProviderGetFactoryMethodInfo      ,
    deviceProviderGetFactory                ,


-- ** getHiddenProviders #method:getHiddenProviders#
    DeviceProviderGetHiddenProvidersMethodInfo,
    deviceProviderGetHiddenProviders        ,


-- ** hideProvider #method:hideProvider#
    DeviceProviderHideProviderMethodInfo    ,
    deviceProviderHideProvider              ,


-- ** register #method:register#
    deviceProviderRegister                  ,


-- ** start #method:start#
    DeviceProviderStartMethodInfo           ,
    deviceProviderStart                     ,


-- ** stop #method:stop#
    DeviceProviderStopMethodInfo            ,
    deviceProviderStop                      ,


-- ** unhideProvider #method:unhideProvider#
    DeviceProviderUnhideProviderMethodInfo  ,
    deviceProviderUnhideProvider            ,




 -- * Signals
-- ** providerHidden #signal:providerHidden#
    C_DeviceProviderProviderHiddenCallback  ,
    DeviceProviderProviderHiddenCallback    ,
    DeviceProviderProviderHiddenSignalInfo  ,
    afterDeviceProviderProviderHidden       ,
    genClosure_DeviceProviderProviderHidden ,
    mk_DeviceProviderProviderHiddenCallback ,
    noDeviceProviderProviderHiddenCallback  ,
    onDeviceProviderProviderHidden          ,
    wrap_DeviceProviderProviderHiddenCallback,


-- ** providerUnhidden #signal:providerUnhidden#
    C_DeviceProviderProviderUnhiddenCallback,
    DeviceProviderProviderUnhiddenCallback  ,
    DeviceProviderProviderUnhiddenSignalInfo,
    afterDeviceProviderProviderUnhidden     ,
    genClosure_DeviceProviderProviderUnhidden,
    mk_DeviceProviderProviderUnhiddenCallback,
    noDeviceProviderProviderUnhiddenCallback,
    onDeviceProviderProviderUnhidden        ,
    wrap_DeviceProviderProviderUnhiddenCallback,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Bus as Gst.Bus
import {-# SOURCE #-} qualified GI.Gst.Objects.Device as Gst.Device
import {-# SOURCE #-} qualified GI.Gst.Objects.DeviceProviderFactory as Gst.DeviceProviderFactory
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin

newtype DeviceProvider = DeviceProvider (ManagedPtr DeviceProvider)
foreign import ccall "gst_device_provider_get_type"
    c_gst_device_provider_get_type :: IO GType

instance GObject DeviceProvider where
    gobjectType _ = c_gst_device_provider_get_type
    

class GObject o => IsDeviceProvider o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DeviceProvider a) =>
    IsDeviceProvider a
#endif
instance IsDeviceProvider DeviceProvider
instance Gst.Object.IsObject DeviceProvider
instance GObject.Object.IsObject DeviceProvider

toDeviceProvider :: IsDeviceProvider o => o -> IO DeviceProvider
toDeviceProvider = unsafeCastTo DeviceProvider

noDeviceProvider :: Maybe DeviceProvider
noDeviceProvider = Nothing

type family ResolveDeviceProviderMethod (t :: Symbol) (o :: *) :: * where
    ResolveDeviceProviderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveDeviceProviderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDeviceProviderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDeviceProviderMethod "canMonitor" o = DeviceProviderCanMonitorMethodInfo
    ResolveDeviceProviderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveDeviceProviderMethod "deviceAdd" o = DeviceProviderDeviceAddMethodInfo
    ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo
    ResolveDeviceProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDeviceProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDeviceProviderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveDeviceProviderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveDeviceProviderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveDeviceProviderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveDeviceProviderMethod "hideProvider" o = DeviceProviderHideProviderMethodInfo
    ResolveDeviceProviderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDeviceProviderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDeviceProviderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDeviceProviderMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveDeviceProviderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDeviceProviderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveDeviceProviderMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDeviceProviderMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDeviceProviderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDeviceProviderMethod "start" o = DeviceProviderStartMethodInfo
    ResolveDeviceProviderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDeviceProviderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDeviceProviderMethod "stop" o = DeviceProviderStopMethodInfo
    ResolveDeviceProviderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveDeviceProviderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveDeviceProviderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDeviceProviderMethod "unhideProvider" o = DeviceProviderUnhideProviderMethodInfo
    ResolveDeviceProviderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveDeviceProviderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveDeviceProviderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDeviceProviderMethod "getBus" o = DeviceProviderGetBusMethodInfo
    ResolveDeviceProviderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveDeviceProviderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveDeviceProviderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDeviceProviderMethod "getDevices" o = DeviceProviderGetDevicesMethodInfo
    ResolveDeviceProviderMethod "getFactory" o = DeviceProviderGetFactoryMethodInfo
    ResolveDeviceProviderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveDeviceProviderMethod "getHiddenProviders" o = DeviceProviderGetHiddenProvidersMethodInfo
    ResolveDeviceProviderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveDeviceProviderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveDeviceProviderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveDeviceProviderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDeviceProviderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDeviceProviderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveDeviceProviderMethod "getValueArray" o = Gst.Object.ObjectGetValueArrayMethodInfo
    ResolveDeviceProviderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveDeviceProviderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveDeviceProviderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveDeviceProviderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDeviceProviderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveDeviceProviderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveDeviceProviderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDeviceProviderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.MethodInfo info DeviceProvider p) => O.IsLabelProxy t (DeviceProvider -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.MethodInfo info DeviceProvider p) => O.IsLabel t (DeviceProvider -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal DeviceProvider::provider-hidden
type DeviceProviderProviderHiddenCallback =
    T.Text ->
    IO ()

noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback = Nothing

type C_DeviceProviderProviderHiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)

genClosure_DeviceProviderProviderHidden :: DeviceProviderProviderHiddenCallback -> IO Closure
genClosure_DeviceProviderProviderHidden cb = do
    let cb' = wrap_DeviceProviderProviderHiddenCallback cb
    mk_DeviceProviderProviderHiddenCallback cb' >>= newCClosure


wrap_DeviceProviderProviderHiddenCallback ::
    DeviceProviderProviderHiddenCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
wrap_DeviceProviderProviderHiddenCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


onDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
onDeviceProviderProviderHidden obj cb = liftIO $ connectDeviceProviderProviderHidden obj cb SignalConnectBefore
afterDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderHidden obj cb = connectDeviceProviderProviderHidden obj cb SignalConnectAfter

connectDeviceProviderProviderHidden :: (GObject a, MonadIO m) =>
                                       a -> DeviceProviderProviderHiddenCallback -> SignalConnectMode -> m SignalHandlerId
connectDeviceProviderProviderHidden obj cb after = liftIO $ do
    let cb' = wrap_DeviceProviderProviderHiddenCallback cb
    cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
    connectSignalFunPtr obj "provider-hidden" cb'' after

-- signal DeviceProvider::provider-unhidden
type DeviceProviderProviderUnhiddenCallback =
    T.Text ->
    IO ()

noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback
noDeviceProviderProviderUnhiddenCallback = Nothing

type C_DeviceProviderProviderUnhiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)

genClosure_DeviceProviderProviderUnhidden :: DeviceProviderProviderUnhiddenCallback -> IO Closure
genClosure_DeviceProviderProviderUnhidden cb = do
    let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
    mk_DeviceProviderProviderUnhiddenCallback cb' >>= newCClosure


wrap_DeviceProviderProviderUnhiddenCallback ::
    DeviceProviderProviderUnhiddenCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
wrap_DeviceProviderProviderUnhiddenCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


onDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
onDeviceProviderProviderUnhidden obj cb = liftIO $ connectDeviceProviderProviderUnhidden obj cb SignalConnectBefore
afterDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderUnhidden obj cb = connectDeviceProviderProviderUnhidden obj cb SignalConnectAfter

connectDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) =>
                                         a -> DeviceProviderProviderUnhiddenCallback -> SignalConnectMode -> m SignalHandlerId
connectDeviceProviderProviderUnhidden obj cb after = liftIO $ do
    let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
    cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
    connectSignalFunPtr obj "provider-unhidden" cb'' after

instance O.HasAttributeList DeviceProvider
type instance O.AttributeList DeviceProvider = DeviceProviderAttributeList
type DeviceProviderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])

data DeviceProviderProviderHiddenSignalInfo
instance SignalInfo DeviceProviderProviderHiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback
    connectSignal _ = connectDeviceProviderProviderHidden

data DeviceProviderProviderUnhiddenSignalInfo
instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback
    connectSignal _ = connectDeviceProviderProviderUnhidden

type instance O.SignalList DeviceProvider = DeviceProviderSignalList
type DeviceProviderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("providerHidden", DeviceProviderProviderHiddenSignalInfo), '("providerUnhidden", DeviceProviderProviderUnhiddenSignalInfo)] :: [(Symbol, *)])

-- method DeviceProvider::can_monitor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_can_monitor" gst_device_provider_can_monitor :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO CInt

{- |
/No description available in the introspection data./
-}
deviceProviderCanMonitor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -> m Bool
deviceProviderCanMonitor provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_can_monitor provider'
    let result' = (/= 0) result
    touchManagedPtr provider
    return result'

data DeviceProviderCanMonitorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderCanMonitorMethodInfo a signature where
    overloadedMethod _ = deviceProviderCanMonitor

-- method DeviceProvider::device_add
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gst", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDevice that has been added", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_device_add" gst_device_provider_device_add :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

{- |
Posts a message on the provider\'s 'GI.Gst.Objects.Bus.Bus' to inform applications that
a new device has been added.

This is for use by subclasses.

@since 1.4
-}
deviceProviderDeviceAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> b
    {- ^ /@device@/: a 'GI.Gst.Objects.Device.Device' that has been added -}
    -> m ()
deviceProviderDeviceAdd provider device = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    device' <- B.ManagedPtr.disownObject device
    gst_device_provider_device_add provider' device'
    touchManagedPtr provider
    touchManagedPtr device
    return ()

data DeviceProviderDeviceAddMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.MethodInfo DeviceProviderDeviceAddMethodInfo a signature where
    overloadedMethod _ = deviceProviderDeviceAdd

-- method DeviceProvider::device_remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gst", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDevice that has been removed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_device_remove" gst_device_provider_device_remove :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

{- |
Posts a message on the provider\'s 'GI.Gst.Objects.Bus.Bus' to inform applications that
a device has been removed.

This is for use by subclasses.

@since 1.4
-}
deviceProviderDeviceRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> b
    {- ^ /@device@/: a 'GI.Gst.Objects.Device.Device' that has been removed -}
    -> m ()
deviceProviderDeviceRemove provider device = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    device' <- unsafeManagedPtrCastPtr device
    gst_device_provider_device_remove provider' device'
    touchManagedPtr provider
    touchManagedPtr device
    return ()

data DeviceProviderDeviceRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.MethodInfo DeviceProviderDeviceRemoveMethodInfo a signature where
    overloadedMethod _ = deviceProviderDeviceRemove

-- method DeviceProvider::get_bus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Bus"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_bus" gst_device_provider_get_bus :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr Gst.Bus.Bus)

{- |
Gets the 'GI.Gst.Objects.Bus.Bus' of this 'GI.Gst.Objects.DeviceProvider.DeviceProvider'

@since 1.4
-}
deviceProviderGetBus ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> m Gst.Bus.Bus
    {- ^ __Returns:__ a 'GI.Gst.Objects.Bus.Bus' -}
deviceProviderGetBus provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_get_bus provider'
    checkUnexpectedReturnNULL "deviceProviderGetBus" result
    result' <- (wrapObject Gst.Bus.Bus) result
    touchManagedPtr provider
    return result'

data DeviceProviderGetBusMethodInfo
instance (signature ~ (m Gst.Bus.Bus), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetBusMethodInfo a signature where
    overloadedMethod _ = deviceProviderGetBus

-- method DeviceProvider::get_devices
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gst", name = "Device"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_devices" gst_device_provider_get_devices :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr (GList (Ptr Gst.Device.Device)))

{- |
Gets a list of devices that this provider understands. This may actually
probe the hardware if the provider is not currently started.

@since 1.4
-}
deviceProviderGetDevices ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: A 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> m [Gst.Device.Device]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of
  'GI.Gst.Objects.Device.Device' -}
deviceProviderGetDevices provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_get_devices provider'
    result' <- unpackGList result
    result'' <- mapM (wrapObject Gst.Device.Device) result'
    g_list_free result
    touchManagedPtr provider
    return result''

data DeviceProviderGetDevicesMethodInfo
instance (signature ~ (m [Gst.Device.Device]), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetDevicesMethodInfo a signature where
    overloadedMethod _ = deviceProviderGetDevices

-- method DeviceProvider::get_factory
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider to request the device provider factory of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_factory" gst_device_provider_get_factory :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr Gst.DeviceProviderFactory.DeviceProviderFactory)

{- |
Retrieves the factory that was used to create this device provider.

@since 1.4
-}
deviceProviderGetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' to request the device provider factory of. -}
    -> m Gst.DeviceProviderFactory.DeviceProviderFactory
    {- ^ __Returns:__ the 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' used for
    creating this device provider. no refcounting is needed. -}
deviceProviderGetFactory provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_get_factory provider'
    checkUnexpectedReturnNULL "deviceProviderGetFactory" result
    result' <- (newObject Gst.DeviceProviderFactory.DeviceProviderFactory) result
    touchManagedPtr provider
    return result'

data DeviceProviderGetFactoryMethodInfo
instance (signature ~ (m Gst.DeviceProviderFactory.DeviceProviderFactory), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetFactoryMethodInfo a signature where
    overloadedMethod _ = deviceProviderGetFactory

-- method DeviceProvider::get_hidden_providers
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_hidden_providers" gst_device_provider_get_hidden_providers :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr CString)

{- |
Get the provider factory names of the 'GI.Gst.Objects.DeviceProvider.DeviceProvider' instances that
are hidden by /@provider@/.

@since 1.6
-}
deviceProviderGetHiddenProviders ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> m [T.Text]
    {- ^ __Returns:__ 
  a list of hidden providers factory names or 'Nothing' when
  nothing is hidden by /@provider@/. Free with g_strfreev. -}
deviceProviderGetHiddenProviders provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_get_hidden_providers provider'
    checkUnexpectedReturnNULL "deviceProviderGetHiddenProviders" result
    result' <- unpackZeroTerminatedUTF8CArray result
    mapZeroTerminatedCArray freeMem result
    freeMem result
    touchManagedPtr provider
    return result'

data DeviceProviderGetHiddenProvidersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetHiddenProvidersMethodInfo a signature where
    overloadedMethod _ = deviceProviderGetHiddenProviders

-- method DeviceProvider::hide_provider
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a provider factory name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_hide_provider" gst_device_provider_hide_provider :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Make /@provider@/ hide the devices from the factory with /@name@/.

This function is used when /@provider@/ will also provide the devices reported
by provider factory /@name@/. A monitor should stop monitoring the
device provider with /@name@/ to avoid duplicate devices.

@since 1.6
-}
deviceProviderHideProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> T.Text
    {- ^ /@name@/: a provider factory name -}
    -> m ()
deviceProviderHideProvider provider name = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    name' <- textToCString name
    gst_device_provider_hide_provider provider' name'
    touchManagedPtr provider
    freeMem name'
    return ()

data DeviceProviderHideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderHideProviderMethodInfo a signature where
    overloadedMethod _ = deviceProviderHideProvider

-- method DeviceProvider::start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_start" gst_device_provider_start :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO CInt

{- |
Starts providering the devices. This will cause @/GST_MESSAGE_DEVICE_ADDED/@
and @/GST_MESSAGE_DEVICE_REMOVED/@ messages to be posted on the provider\'s bus
when devices are added or removed from the system.

Since the 'GI.Gst.Objects.DeviceProvider.DeviceProvider' is a singleton,
'GI.Gst.Objects.DeviceProvider.deviceProviderStart' may already have been called by another
user of the object, 'GI.Gst.Objects.DeviceProvider.deviceProviderStop' needs to be called the same
number of times.

@since 1.4
-}
deviceProviderStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: A 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the device providering could be started -}
deviceProviderStart provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    result <- gst_device_provider_start provider'
    let result' = (/= 0) result
    touchManagedPtr provider
    return result'

data DeviceProviderStartMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderStartMethodInfo a signature where
    overloadedMethod _ = deviceProviderStart

-- method DeviceProvider::stop
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_stop" gst_device_provider_stop :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO ()

{- |
Decreases the use-count by one. If the use count reaches zero, this
'GI.Gst.Objects.DeviceProvider.DeviceProvider' will stop providering the devices. This needs to be
called the same number of times that 'GI.Gst.Objects.DeviceProvider.deviceProviderStart' was called.

@since 1.4
-}
deviceProviderStop ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: A 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> m ()
deviceProviderStop provider = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    gst_device_provider_stop provider'
    touchManagedPtr provider
    return ()

data DeviceProviderStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderStopMethodInfo a signature where
    overloadedMethod _ = deviceProviderStop

-- method DeviceProvider::unhide_provider
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "Gst", name = "DeviceProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDeviceProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a provider factory name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_unhide_provider" gst_device_provider_unhide_provider :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Make /@provider@/ unhide the devices from factory /@name@/.

This function is used when /@provider@/ will no longer provide the devices
reported by provider factory /@name@/. A monitor should start
monitoring the devices from provider factory /@name@/ in order to see
all devices again.

@since 1.6
-}
deviceProviderUnhideProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' -}
    -> T.Text
    {- ^ /@name@/: a provider factory name -}
    -> m ()
deviceProviderUnhideProvider provider name = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    name' <- textToCString name
    gst_device_provider_unhide_provider provider' name'
    touchManagedPtr provider
    freeMem name'
    return ()

data DeviceProviderUnhideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderUnhideProviderMethodInfo a signature where
    overloadedMethod _ = deviceProviderUnhideProvider

-- method DeviceProvider::register
-- method type : MemberFunction
-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "Gst", name = "Plugin"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GstPlugin to register the device provider with, or %NULL for\n    a static device provider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of device providers of this type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rank of device provider (higher rank means more importance when autoplugging)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GType of device provider to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_register" gst_device_provider_register :: 
    Ptr Gst.Plugin.Plugin ->                -- plugin : TInterface (Name {namespace = "Gst", name = "Plugin"})
    CString ->                              -- name : TBasicType TUTF8
    Word32 ->                               -- rank : TBasicType TUInt
    CGType ->                               -- type : TBasicType TGType
    IO CInt

{- |
Create a new device providerfactory capable of instantiating objects of the
/@type@/ and add the factory to /@plugin@/.

@since 1.4
-}
deviceProviderRegister ::
    (B.CallStack.HasCallStack, MonadIO m, Gst.Plugin.IsPlugin a) =>
    Maybe (a)
    {- ^ /@plugin@/: 'GI.Gst.Objects.Plugin.Plugin' to register the device provider with, or 'Nothing' for
    a static device provider. -}
    -> T.Text
    {- ^ /@name@/: name of device providers of this type -}
    -> Word32
    {- ^ /@rank@/: rank of device provider (higher rank means more importance when autoplugging) -}
    -> GType
    {- ^ /@type@/: GType of device provider to register -}
    -> m Bool
    {- ^ __Returns:__ 'True', if the registering succeeded, 'False' on error -}
deviceProviderRegister plugin name rank type_ = liftIO $ do
    maybePlugin <- case plugin of
        Nothing -> return nullPtr
        Just jPlugin -> do
            jPlugin' <- unsafeManagedPtrCastPtr jPlugin
            return jPlugin'
    name' <- textToCString name
    let type_' = gtypeToCGType type_
    result <- gst_device_provider_register maybePlugin name' rank type_'
    let result' = (/= 0) result
    whenJust plugin touchManagedPtr
    freeMem name'
    return result'