DeviceProvider.hs


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

A 'GI.Gst.Objects.DeviceProvider.DeviceProvider' subclass is provided by a plugin that handles devices
if there is a way to programmatically 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.

/Since: 1.4/
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gst.Objects.DeviceProvider
    ( 

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


 -- * Methods
-- ** canMonitor #method:canMonitor#

#if ENABLE_OVERLOADING
    DeviceProviderCanMonitorMethodInfo      ,
#endif
    deviceProviderCanMonitor                ,


-- ** deviceAdd #method:deviceAdd#

#if ENABLE_OVERLOADING
    DeviceProviderDeviceAddMethodInfo       ,
#endif
    deviceProviderDeviceAdd                 ,


-- ** deviceChanged #method:deviceChanged#

#if ENABLE_OVERLOADING
    DeviceProviderDeviceChangedMethodInfo   ,
#endif
    deviceProviderDeviceChanged             ,


-- ** deviceRemove #method:deviceRemove#

#if ENABLE_OVERLOADING
    DeviceProviderDeviceRemoveMethodInfo    ,
#endif
    deviceProviderDeviceRemove              ,


-- ** getBus #method:getBus#

#if ENABLE_OVERLOADING
    DeviceProviderGetBusMethodInfo          ,
#endif
    deviceProviderGetBus                    ,


-- ** getDevices #method:getDevices#

#if ENABLE_OVERLOADING
    DeviceProviderGetDevicesMethodInfo      ,
#endif
    deviceProviderGetDevices                ,


-- ** getFactory #method:getFactory#

#if ENABLE_OVERLOADING
    DeviceProviderGetFactoryMethodInfo      ,
#endif
    deviceProviderGetFactory                ,


-- ** getHiddenProviders #method:getHiddenProviders#

#if ENABLE_OVERLOADING
    DeviceProviderGetHiddenProvidersMethodInfo,
#endif
    deviceProviderGetHiddenProviders        ,


-- ** getMetadata #method:getMetadata#

#if ENABLE_OVERLOADING
    DeviceProviderGetMetadataMethodInfo     ,
#endif
    deviceProviderGetMetadata               ,


-- ** hideProvider #method:hideProvider#

#if ENABLE_OVERLOADING
    DeviceProviderHideProviderMethodInfo    ,
#endif
    deviceProviderHideProvider              ,


-- ** register #method:register#

    deviceProviderRegister                  ,


-- ** start #method:start#

#if ENABLE_OVERLOADING
    DeviceProviderStartMethodInfo           ,
#endif
    deviceProviderStart                     ,


-- ** stop #method:stop#

#if ENABLE_OVERLOADING
    DeviceProviderStopMethodInfo            ,
#endif
    deviceProviderStop                      ,


-- ** unhideProvider #method:unhideProvider#

#if ENABLE_OVERLOADING
    DeviceProviderUnhideProviderMethodInfo  ,
#endif
    deviceProviderUnhideProvider            ,




 -- * Signals
-- ** providerHidden #signal:providerHidden#

    C_DeviceProviderProviderHiddenCallback  ,
    DeviceProviderProviderHiddenCallback    ,
#if ENABLE_OVERLOADING
    DeviceProviderProviderHiddenSignalInfo  ,
#endif
    afterDeviceProviderProviderHidden       ,
    genClosure_DeviceProviderProviderHidden ,
    mk_DeviceProviderProviderHiddenCallback ,
    noDeviceProviderProviderHiddenCallback  ,
    onDeviceProviderProviderHidden          ,
    wrap_DeviceProviderProviderHiddenCallback,


-- ** providerUnhidden #signal:providerUnhidden#

    C_DeviceProviderProviderUnhiddenCallback,
    DeviceProviderProviderUnhiddenCallback  ,
#if ENABLE_OVERLOADING
    DeviceProviderProviderUnhiddenSignalInfo,
#endif
    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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
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 GHC.OverloadedLabels as OL

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

-- | Memory-managed wrapper type.
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
    

-- | Type class for types which can be safely cast to `DeviceProvider`, for instance with `toDeviceProvider`.
class (GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance (GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o

instance O.HasParentTypes DeviceProvider
type instance O.ParentTypes DeviceProvider = '[Gst.Object.Object, GObject.Object.Object]

-- | Cast to `DeviceProvider`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDeviceProvider :: (MonadIO m, IsDeviceProvider o) => o -> m DeviceProvider
toDeviceProvider = liftIO . unsafeCastTo DeviceProvider

-- | A convenience alias for `Nothing` :: `Maybe` `DeviceProvider`.
noDeviceProvider :: Maybe DeviceProvider
noDeviceProvider = Nothing

#if ENABLE_OVERLOADING
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 "deviceChanged" o = DeviceProviderDeviceChangedMethodInfo
    ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo
    ResolveDeviceProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDeviceProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDeviceProviderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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 "getMetadata" o = DeviceProviderGetMetadataMethodInfo
    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 "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) => OL.IsLabel t (DeviceProvider -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- signal DeviceProvider::provider-hidden
{- |
/No description available in the introspection data./
-}
type DeviceProviderProviderHiddenCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceProviderProviderHiddenCallback`@.
noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DeviceProviderProviderHiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DeviceProviderProviderHiddenCallback`.
foreign import ccall "wrapper"
    mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_DeviceProviderProviderHidden :: MonadIO m => DeviceProviderProviderHiddenCallback -> m (GClosure C_DeviceProviderProviderHiddenCallback)
genClosure_DeviceProviderProviderHidden cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderHiddenCallback cb
    mk_DeviceProviderProviderHiddenCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `DeviceProviderProviderHiddenCallback` into a `C_DeviceProviderProviderHiddenCallback`.
wrap_DeviceProviderProviderHiddenCallback ::
    DeviceProviderProviderHiddenCallback ->
    C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


{- |
Connect a signal handler for the “@provider-hidden@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' deviceProvider #providerHidden callback
@
-}
onDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
onDeviceProviderProviderHidden obj cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderHiddenCallback cb
    cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
    connectSignalFunPtr obj "provider-hidden" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@provider-hidden@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' deviceProvider #providerHidden callback
@
-}
afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderHidden obj cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderHiddenCallback cb
    cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
    connectSignalFunPtr obj "provider-hidden" cb'' SignalConnectAfter


-- signal DeviceProvider::provider-unhidden
{- |
/No description available in the introspection data./
-}
type DeviceProviderProviderUnhiddenCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceProviderProviderUnhiddenCallback`@.
noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback
noDeviceProviderProviderUnhiddenCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DeviceProviderProviderUnhiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DeviceProviderProviderUnhiddenCallback`.
foreign import ccall "wrapper"
    mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_DeviceProviderProviderUnhidden :: MonadIO m => DeviceProviderProviderUnhiddenCallback -> m (GClosure C_DeviceProviderProviderUnhiddenCallback)
genClosure_DeviceProviderProviderUnhidden cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
    mk_DeviceProviderProviderUnhiddenCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `DeviceProviderProviderUnhiddenCallback` into a `C_DeviceProviderProviderUnhiddenCallback`.
wrap_DeviceProviderProviderUnhiddenCallback ::
    DeviceProviderProviderUnhiddenCallback ->
    C_DeviceProviderProviderUnhiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


{- |
Connect a signal handler for the “@provider-unhidden@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' deviceProvider #providerUnhidden callback
@
-}
onDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
onDeviceProviderProviderUnhidden obj cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
    cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
    connectSignalFunPtr obj "provider-unhidden" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@provider-unhidden@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' deviceProvider #providerUnhidden callback
@
-}
afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderUnhidden obj cb = liftIO $ do
    let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
    cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
    connectSignalFunPtr obj "provider-unhidden" cb'' SignalConnectAfter


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

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data DeviceProviderProviderHiddenSignalInfo
instance SignalInfo DeviceProviderProviderHiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DeviceProviderProviderHiddenCallback cb
        cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
        connectSignalFunPtr obj "provider-hidden" cb'' connectMode

data DeviceProviderProviderUnhiddenSignalInfo
instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
        cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
        connectSignalFunPtr obj "provider-unhidden" cb'' connectMode

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

#endif

-- 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'

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

#endif

-- 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 = TransferNothing}]
-- 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.

/@device@/\'s reference count will be incremented, and any floating reference
will be removed (see @/gst_object_ref_sink()/@).

/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' <- unsafeManagedPtrCastPtr device
    gst_device_provider_device_add provider' device'
    touchManagedPtr provider
    touchManagedPtr device
    return ()

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

#endif

-- method DeviceProvider::device_changed
-- 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},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gst", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new version of @changed_device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "changed_device", argType = TInterface (Name {namespace = "Gst", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the old version of the device that has been udpated", 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_changed" gst_device_provider_device_changed :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    Ptr Gst.Device.Device ->                -- changed_device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

{- |
This function is used when /@changedDevice@/ was modified into its new form
/@device@/. This will post a @DEVICE_CHANGED@ message on the bus to let
the application know that the device was modified. 'GI.Gst.Objects.Device.Device' is immutable
for MT. safety purposes so this is an \"atomic\" way of letting the application
know when a device was modified.

/Since: 1.16/
-}
deviceProviderDeviceChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) =>
    a
    -> b
    {- ^ /@device@/: the new version of /@changedDevice@/ -}
    -> c
    {- ^ /@changedDevice@/: the old version of the device that has been udpated -}
    -> m ()
deviceProviderDeviceChanged provider device changedDevice = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    device' <- unsafeManagedPtrCastPtr device
    changedDevice' <- unsafeManagedPtrCastPtr changedDevice
    gst_device_provider_device_changed provider' device' changedDevice'
    touchManagedPtr provider
    touchManagedPtr device
    touchManagedPtr changedDevice
    return ()

#if ENABLE_OVERLOADING
data DeviceProviderDeviceChangedMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) => O.MethodInfo DeviceProviderDeviceChangedMethodInfo a signature where
    overloadedMethod _ = deviceProviderDeviceChanged

#endif

-- 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 ()

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

#endif

-- 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'

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

#endif

-- 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''

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

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

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

{- |
Get metadata with /@key@/ in /@provider@/.

/Since: 1.14/
-}
deviceProviderGetMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    {- ^ /@provider@/: provider to get metadata for -}
    -> T.Text
    {- ^ /@key@/: the key to get -}
    -> m T.Text
    {- ^ __Returns:__ the metadata for /@key@/. -}
deviceProviderGetMetadata provider key = liftIO $ do
    provider' <- unsafeManagedPtrCastPtr provider
    key' <- textToCString key
    result <- gst_device_provider_get_metadata provider' key'
    checkUnexpectedReturnNULL "deviceProviderGetMetadata" result
    result' <- cstringToText result
    touchManagedPtr provider
    freeMem key'
    return result'

#if ENABLE_OVERLOADING
data DeviceProviderGetMetadataMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetMetadataMethodInfo a signature where
    overloadedMethod _ = deviceProviderGetMetadata

#endif

-- 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 ()

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

#endif

-- 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'

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

#endif

-- 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 ()

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

#endif

-- 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 ()

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

#endif

-- 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'

#if ENABLE_OVERLOADING
#endif