diff --git a/PInvoke/CfgMgr32/SWDevice.cs b/PInvoke/CfgMgr32/SWDevice.cs
index 31d687a4..750f2901 100644
--- a/PInvoke/CfgMgr32/SWDevice.cs
+++ b/PInvoke/CfgMgr32/SWDevice.cs
@@ -1,6 +1,8 @@
using System;
using System.Runtime.InteropServices;
+using Vanara.Extensions;
using Vanara.InteropServices;
+using static Vanara.PInvoke.SetupAPI;
namespace Vanara.PInvoke
{
@@ -88,12 +90,18 @@ namespace Vanara.PInvoke
SWDeviceCapabilitiesDriverRequired = 0x00000008
}
+ /// Indicates the current lifetime value for the software device.
[PInvokeData("swdevicedef.h")]
public enum SW_DEVICE_LIFETIME
{
+ ///
+ /// Indicates that the lifetime of the software device is determined by the lifetime of the handle that is associated with the
+ /// software device. As long as the handle is open, the software device is enumerated by PnP.
+ ///
SWDeviceLifetimeHandle,
+
+ /// Indicates that the lifetime of the software device is tied to the lifetime of its parent.
SWDeviceLifetimeParentPresent,
- SWDeviceLifetimeMax
}
/// Closes the software device handle. When the handle is closed, PnP will initiate the process of removing the device.
@@ -125,6 +133,326 @@ namespace Vanara.PInvoke
[PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceClose")]
public static extern void SwDeviceClose(HSWDEVICE hSwDevice);
+ /// Initiates the enumeration of a software device.
+ ///
+ /// A string that names the enumerator of the software device. Choose a name that represents the component that enumerates the devices.
+ ///
+ ///
+ /// A string that specifies the device instance ID of the device that is the parent of the software device.
+ ///
+ /// This can be HTREE\ROOT\0, but we recommend to keep children of the root device to a minimum. We also recommend that the
+ /// preferred parent of a software device be a real device that the software device is extending the functionality for. In
+ /// situations where a software device doesn't have such a natural parent, create a device as a child of the root that can collect
+ /// all the software devices that a component will enumerate; then, enumerate the actual software devices as children of this device
+ /// grouping node. This keeps the children of the root device to a manageable number.
+ ///
+ ///
+ /// A pointer to a SW_DEVICE_CREATE_INFO structure that describes info that PnP uses to create the device.
+ /// The number of DEVPROPERTY structures in the pProperties array.
+ ///
+ /// An optional array of DEVPROPERTY structures. These properties are set on the device after it is created but before a
+ /// notification that the device has been created are sent. For more info, see Remarks. This pointer can be NULL.
+ ///
+ ///
+ /// The SW_DEVICE_CREATE_CALLBACK callback function that the operating system calls after PnP enumerates the device.
+ ///
+ ///
+ /// An optional client context that the operating system passes to the callback function. This pointer can be NULL.
+ ///
+ ///
+ /// A pointer to a variable that receives the HSWDEVICE handle that represents the device. Call SwDeviceClose to close this
+ /// handle after the client app wants PnP to remove the device.
+ ///
+ ///
+ /// S_OK is returned if device enumeration was successfully initiated. This does not mean that the device has been successfully
+ /// enumerated. Check the CreateResult parameter of the SW_DEVICE_CREATE_CALLBACK callback function to determine if the device was
+ /// successfully enumerated.
+ ///
+ ///
+ /// SwDeviceCreate returns a handle that represents the device. After this handle is closed, PnP will remove the device.
+ /// The calling process must have Administrator access in order to initiate the enumeration of a software device.
+ ///
+ /// PnP forms the device instance ID of a software device as "SWD<pszEnumeratorName><pszInstanceId>," but this
+ /// string might change or PnP might decorate the name. Always get the device instance ID from the callback function.
+ ///
+ ///
+ /// There is a subtle difference between properties that are set as part of a SwDeviceCreate call and properties that are
+ /// later set by calling SwDevicePropertySet. Properties that are set as part of SwDeviceCreate are stored in memory; if the
+ /// device is uninstalled or a null driver wipes out the property stores, these properties are written out again by the Software
+ /// Device API feature when PnP re-enumerates the devices. This is all transparent to the client. Properties that are set using
+ /// SwDevicePropertySet after the enumeration don't persist in memory. But, if you set a property by using
+ /// SwDeviceCreate, you can update the value with SwDevicePropertySet, and this update is applied to the in-memory
+ /// value as well as the persisted store.
+ ///
+ ///
+ /// We recommend that all properties be specified as part of the call to SwDeviceCreate when possible and that these
+ /// properties be specified for every call to SwDeviceCreate.
+ ///
+ ///
+ /// Note The operating system might possibly call SW_DEVICE_CREATE_CALLBACK before the call to SwDeviceCreate returns.
+ /// For this reason, the software device handle for the device is supplied as a parameter to the callback function.
+ ///
+ ///
+ /// You can create a software device as the child of a parent that is not present at the time. PnP will enumerate the software
+ /// device after the parent becomes present.
+ ///
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdevicecreate HRESULT SwDeviceCreate( PCWSTR
+ // pszEnumeratorName, PCWSTR pszParentDeviceInstance, const SW_DEVICE_CREATE_INFO *pCreateInfo, ULONG cPropertyCount, const
+ // DEVPROPERTY *pProperties, SW_DEVICE_CREATE_CALLBACK pCallback, PVOID pContext, PHSWDEVICE phSwDevice );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceCreate")]
+ public static extern HRESULT SwDeviceCreate([MarshalAs(UnmanagedType.LPWStr)] string pszEnumeratorName, [MarshalAs(UnmanagedType.LPWStr)] string pszParentDeviceInstance,
+ in SW_DEVICE_CREATE_INFO pCreateInfo, uint cPropertyCount, [In, Optional, MarshalAs(UnmanagedType.LPArray)] DEVPROPERTY[] pProperties, SW_DEVICE_CREATE_CALLBACK pCallback,
+ [In, Optional] IntPtr pContext, out SafeHSWDEVICE phSwDevice);
+
+ /// Gets the lifetime of a software device.
+ /// The HSWDEVICE handle to the software device to retrieve.
+ ///
+ ///
+ /// A pointer to a variable that receives a SW_DEVICE_LIFETIME-typed value that indicates the current lifetime value for the
+ /// software device. Here are possible values:
+ ///
+ ///
+ ///
+ /// Value
+ /// Meaning
+ ///
+ /// -
+ /// SWDeviceLifetimeHandle
+ ///
+ /// Indicates that the lifetime of the software device is determined by the lifetime of the handle that is associated with the
+ /// software device. As long as the handle is open, the software device is enumerated by PnP.
+ ///
+ ///
+ /// -
+ /// SWDeviceLifetimeParentPresent
+ /// Indicates that the lifetime of the software device is tied to the lifetime of its parent.
+ ///
+ ///
+ ///
+ /// S_OK is returned if SwDeviceSetLifetime successfully retrieved the lifetime.
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdevicegetlifetime HRESULT SwDeviceGetLifetime(
+ // HSWDEVICE hSwDevice, PSW_DEVICE_LIFETIME pLifetime );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceGetLifetime")]
+ public static extern HRESULT SwDeviceGetLifetime(HSWDEVICE hSwDevice, out SW_DEVICE_LIFETIME pLifetime);
+
+ /// Sets properties on a software device interface.
+ /// The HSWDEVICE handle to the software device of the interface to set properties for.
+ /// A string that identifies the interface to set properties on.
+ /// The number of DEVPROPERTY structures in the pProperties array.
+ /// An array of DEVPROPERTY structures containing the properties to set on the interface.
+ ///
+ /// S_OK is returned if SwDeviceInterfacePropertySet successfully set the properties on the interface; otherwise, an
+ /// appropriate error value.
+ ///
+ ///
+ ///
+ /// Typically, only the operating system and Administrators of the computer can set properties on an interface, but the creator of a
+ /// device can call SwDeviceInterfacePropertySet to set properties on an interface for that device even if the creator isn't
+ /// the operating system or an Administrator.
+ ///
+ ///
+ /// You can call SwDeviceInterfacePropertySet only after the operating system has called your client app's
+ /// SW_DEVICE_CREATE_CALLBACK callback function to notify the client app that device enumeration completed.
+ ///
+ ///
+ /// There is a subtle difference between properties that are set as part of a SwDeviceInterfaceRegister call and properties that are
+ /// later set by calling SwDeviceInterfacePropertySet. Properties that are set as part of SwDeviceInterfaceRegister
+ /// are stored in memory; if the device is uninstalled or a null driver wipes out the property stores, these properties are written
+ /// out again by the Software Device API feature when PnP re-enumerates the devices. This is all transparent to the client.
+ /// Properties that are set using SwDeviceInterfacePropertySet after the enumeration don't persist in memory. But, if you set
+ /// a property by using SwDeviceInterfaceRegister, you can update the value with SwDeviceInterfacePropertySet, and
+ /// this update is applied to the in-memory value as well as the persisted store.
+ ///
+ /// You can use SwDeviceInterfacePropertySet only to set properties in the operating system store for the interface.
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdeviceinterfacepropertyset HRESULT
+ // SwDeviceInterfacePropertySet( HSWDEVICE hSwDevice, PCWSTR pszDeviceInterfaceId, ULONG cPropertyCount, const DEVPROPERTY
+ // *pProperties );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceInterfacePropertySet")]
+ public static extern HRESULT SwDeviceInterfacePropertySet(HSWDEVICE hSwDevice, [MarshalAs(UnmanagedType.LPWStr)] string pszDeviceInterfaceId,
+ uint cPropertyCount, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] DEVPROPERTY[] pProperties);
+
+ /// Registers a device interface for a software device and optionally sets properties on that interface.
+ /// The HSWDEVICE handle to the software device to register a device interface for.
+ /// A pointer to the interface class GUID that names the contract that this interface implements.
+ ///
+ /// An optional reference string that differentiates multiple interfaces of the same class for this device. This pointer can be NULL.
+ ///
+ /// The number of DEVPROPERTY structures in the pProperties array.
+ ///
+ /// An optional array of DEVPROPERTY structures for the properties to set on the interface. This pointer can be NULL.
+ ///
+ /// Set these properties on the interface after it is created but before a notification that the interface has been created are
+ /// sent. For more info, see Remarks. This pointer can be NULL.
+ ///
+ ///
+ ///
+ /// A Boolean value that indicates whether to either enable or disable the interface. TRUE to enable; FALSE to disable.
+ ///
+ ///
+ /// A pointer to a variable that receives a pointer to the device interface ID for the interface. The caller must free this value
+ /// with SwMemFree. This value can be NULL if the client app doesn't need to retrieve the name.
+ ///
+ ///
+ /// S_OK is returned if SwDeviceInterfaceRegister successfully registered the interface; otherwise, an appropriate error value.
+ ///
+ ///
+ ///
+ /// You can call SwDeviceInterfaceRegister only after the operating system has called your client app's
+ /// SW_DEVICE_CREATE_CALLBACK callback function to notify the client app that device enumeration completed.
+ ///
+ ///
+ /// You can't call SwDeviceInterfaceRegister for software devices that specify the SWDeviceCapabilitiesDriverRequired capability.
+ ///
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdeviceinterfaceregister HRESULT
+ // SwDeviceInterfaceRegister( HSWDEVICE hSwDevice, const GUID *pInterfaceClassGuid, PCWSTR pszReferenceString, ULONG cPropertyCount,
+ // const DEVPROPERTY *pProperties, BOOL fEnabled, PWSTR *ppszDeviceInterfaceId );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceInterfaceRegister")]
+ public static extern HRESULT SwDeviceInterfaceRegister(HSWDEVICE hSwDevice, in Guid pInterfaceClassGuid, [Optional, MarshalAs(UnmanagedType.LPWStr)] string pszReferenceString,
+ uint cPropertyCount, [In, Optional, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] DEVPROPERTY[] pProperties, [MarshalAs(UnmanagedType.Bool)] bool fEnabled,
+ [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SwMemMarshaler))] out string ppszDeviceInterfaceId);
+
+ /// Enables or disables a device interface for a software device.
+ /// The HSWDEVICE handle to the software device to register a device interface for.
+ /// A string that identifies the interface to enable or disable.
+ ///
+ /// A Boolean value that indicates whether to either enable or disable the interface. TRUE to enable; FALSE to disable.
+ ///
+ ///
+ /// S_OK is returned if SwDeviceInterfaceSetState successfully enabled or disabled the interface; otherwise, an appropriate
+ /// error value.
+ ///
+ ///
+ ///
+ /// You can call SwDeviceInterfaceSetState only after the operating system has called your client app's
+ /// SW_DEVICE_CREATE_CALLBACK callback function to notify the client app that device enumeration completed.
+ ///
+ ///
+ /// You can only use SwDeviceInterfaceSetState to manage interfaces that were previously registered with
+ /// SwDeviceInterfaceRegister against the software device that hSwDevice represents.
+ ///
+ ///
+ /// Client apps use SwDeviceInterfaceSetState to manage the state that they want the interface to have. The software device
+ /// changes the actual interface state as needed. For example, a client app disables and re-enables the interface if the device is
+ /// re-enumerated for any reason. The state always tries to reflect the client app’s required state.
+ ///
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdeviceinterfacesetstate HRESULT
+ // SwDeviceInterfaceSetState( HSWDEVICE hSwDevice, PCWSTR pszDeviceInterfaceId, BOOL fEnabled );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceInterfaceSetState")]
+ public static extern HRESULT SwDeviceInterfaceSetState(HSWDEVICE hSwDevice, [MarshalAs(UnmanagedType.LPWStr)] string pszDeviceInterfaceId, [MarshalAs(UnmanagedType.Bool)] bool fEnabled);
+
+ /// Sets properties on a software device.
+ /// The HSWDEVICE handle to the software device to set properties for.
+ /// The number of DEVPROPERTY structures in the pProperties array.
+ /// An array of DEVPROPERTY structures containing the properties to set.
+ ///
+ /// S_OK is returned if SwDevicePropertySet successfully set the properties; otherwise, an appropriate error value.
+ ///
+ ///
+ ///
+ /// Typically, only the operating system and Administrators of the computer can set properties on a device, but the creator of a
+ /// device can call SwDevicePropertySet to set properties on that device even if it isn't the operating system or an Administrator.
+ ///
+ ///
+ /// You can call SwDevicePropertySet only after the operating system has called your client app's SW_DEVICE_CREATE_CALLBACK
+ /// callback function to notify the client app that device enumeration completed.
+ ///
+ ///
+ /// There is a subtle difference between properties that are set as part of a SwDeviceCreate call and properties that are later set
+ /// by calling SwDevicePropertySet. Properties that are set as part of SwDeviceCreate are stored in memory; if the
+ /// device is uninstalled or a null driver wipes out the property stores, these properties are written out again by the Software
+ /// Device API feature when PnP re-enumerates the devices. This is all transparent to the client. Properties that are set using
+ /// SwDevicePropertySet after the enumeration don't persist in memory. But, if you set a property by using
+ /// SwDeviceCreate, you can update the value with SwDevicePropertySet, and this update is applied to the in-memory
+ /// value as well as the persisted store.
+ ///
+ /// You can use SwDevicePropertySet only to set properties in the operating system store for the device.
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdevicepropertyset HRESULT SwDevicePropertySet(
+ // HSWDEVICE hSwDevice, ULONG cPropertyCount, const DEVPROPERTY *pProperties );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDevicePropertySet")]
+ public static extern HRESULT SwDevicePropertySet(HSWDEVICE hSwDevice, uint cPropertyCount, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] DEVPROPERTY[] pProperties);
+
+ /// Manages the lifetime of a software device.
+ /// The HSWDEVICE handle to the software device to manage.
+ ///
+ ///
+ /// A SW_DEVICE_LIFETIME-typed value that indicates the new lifetime value for the software device. Here are possible values:
+ ///
+ ///
+ ///
+ /// Value
+ /// Meaning
+ ///
+ /// -
+ /// SWDeviceLifetimeHandle
+ ///
+ /// Indicates that the lifetime of the software device is determined by the lifetime of the handle that is associated with the
+ /// software device. As long as the handle is open, the software device is enumerated by PnP.
+ ///
+ ///
+ /// -
+ /// SWDeviceLifetimeParentPresent
+ /// Indicates that the lifetime of the software device is tied to the lifetime of its parent.
+ ///
+ ///
+ ///
+ /// S_OK is returned if SwDeviceSetLifetime successfully updated the lifetime.
+ ///
+ ///
+ /// After a software device is initially created by calling SwDeviceCreate, its default lifetime is set to
+ /// SwDeviceLifetimeHandle. When a software device has a lifetime of SwDeviceLifetimeHandle, PnP stops enumerating the
+ /// device after the device's handle is closed.
+ ///
+ ///
+ /// You can use SwDeviceSetLifetime to set the lifetime of the software device to SwDeviceLifetimeParentPresent. The
+ /// lifetime of the software device is then tied to the lifetime of the closest non-software device parent. The creator of the
+ /// software device can then close the handle to the software device and the device will still be enumerated. This can be useful for
+ /// services that manage software devices but want to idle stop.
+ ///
+ ///
+ /// A client app can only call SwDeviceSetLifetime after it has received a call to its SW_DEVICE_CREATE_CALLBACK callback
+ /// function that is associated with its call to SwDeviceCreate.
+ ///
+ ///
+ /// When a client app calls SwDeviceCreate for a software device that was previously marked for
+ /// SwDeviceLifetimeParentPresent, SwDeviceCreate succeeds if there are no open software device handles for the device
+ /// (only one handle can be open for a device). A client app can then regain control over a persistent software device for the
+ /// purposes of updating properties and interfaces or changing the lifetime.
+ ///
+ ///
+ /// If the client app specifies info in SW_DEVICE_CREATE_INFO that is different form a previous enumeration, the device might stop
+ /// being enumerated and immediately re-enumerated to apply the changes. The operating system reports only some properties when PnP
+ /// enumerates the device.
+ ///
+ ///
+ /// To uninstall a software device with a lifetime of SwDeviceLifetimeParentPresent, we recommend that you change the
+ /// lifetime back to SwDeviceLifetimeHandle before the device is uninstalled.
+ ///
+ ///
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdevicesetlifetime HRESULT SwDeviceSetLifetime(
+ // HSWDEVICE hSwDevice, SW_DEVICE_LIFETIME Lifetime );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceSetLifetime")]
+ public static extern HRESULT SwDeviceSetLifetime(HSWDEVICE hSwDevice, SW_DEVICE_LIFETIME Lifetime);
+
+ /// Frees memory that other Software Device API functions allocated.
+ /// A pointer to the block of memory to free.
+ /// None
+ // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swmemfree void SwMemFree( PVOID pMem );
+ [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
+ [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwMemFree")]
+ public static extern void SwMemFree(IntPtr pMem);
+
/// Provides a handle to a software device.
[StructLayout(LayoutKind.Sequential)]
public struct HSWDEVICE : IHandle
@@ -329,87 +657,19 @@ namespace Vanara.PInvoke
protected override bool InternalReleaseHandle() { SwDeviceClose(handle); return true; }
}
- /*
- /// Initiates the enumeration of a software device.
- ///
- /// A string that names the enumerator of the software device. Choose a name that represents the component that enumerates the devices.
- ///
- ///
- /// A string that specifies the device instance ID of the device that is the parent of the software device.
- ///
- /// This can be HTREE\ROOT\0, but we recommend to keep children of the root device to a minimum. We also recommend that the
- /// preferred parent of a software device be a real device that the software device is extending the functionality for. In
- /// situations where a software device doesn't have such a natural parent, create a device as a child of the root that can collect
- /// all the software devices that a component will enumerate; then, enumerate the actual software devices as children of this device
- /// grouping node. This keeps the children of the root device to a manageable number.
- ///
- ///
- /// A pointer to a SW_DEVICE_CREATE_INFO structure that describes info that PnP uses to create the device.
- /// The number of DEVPROPERTY structures in the pProperties array.
- ///
- /// An optional array of DEVPROPERTY structures. These properties are set on the device after it is created but before a
- /// notification that the device has been created are sent. For more info, see Remarks. This pointer can be NULL.
- ///
- ///
- /// The SW_DEVICE_CREATE_CALLBACK callback function that the operating system calls after PnP enumerates the device.
- ///
- ///
- /// An optional client context that the operating system passes to the callback function. This pointer can be NULL.
- ///
- ///
- /// A pointer to a variable that receives the HSWDEVICE handle that represents the device. Call SwDeviceClose to close this
- /// handle after the client app wants PnP to remove the device.
- ///
- ///
- /// S_OK is returned if device enumeration was successfully initiated. This does not mean that the device has been successfully
- /// enumerated. Check the CreateResult parameter of the SW_DEVICE_CREATE_CALLBACK callback function to determine if the device was
- /// successfully enumerated.
- ///
- ///
- /// SwDeviceCreate returns a handle that represents the device. After this handle is closed, PnP will remove the device.
- /// The calling process must have Administrator access in order to initiate the enumeration of a software device.
- ///
- /// PnP forms the device instance ID of a software device as "SWD<pszEnumeratorName><pszInstanceId>," but this
- /// string might change or PnP might decorate the name. Always get the device instance ID from the callback function.
- ///
- ///
- /// There is a subtle difference between properties that are set as part of a SwDeviceCreate call and properties that are
- /// later set by calling SwDevicePropertySet. Properties that are set as part of SwDeviceCreate are stored in memory; if the
- /// device is uninstalled or a null driver wipes out the property stores, these properties are written out again by the Software
- /// Device API feature when PnP re-enumerates the devices. This is all transparent to the client. Properties that are set using
- /// SwDevicePropertySet after the enumeration don't persist in memory. But, if you set a property by using
- /// SwDeviceCreate, you can update the value with SwDevicePropertySet, and this update is applied to the in-memory
- /// value as well as the persisted store.
- ///
- ///
- /// We recommend that all properties be specified as part of the call to SwDeviceCreate when possible and that these
- /// properties be specified for every call to SwDeviceCreate.
- ///
- ///
- /// Note The operating system might possibly call SW_DEVICE_CREATE_CALLBACK before the call to SwDeviceCreate returns.
- /// For this reason, the software device handle for the device is supplied as a parameter to the callback function.
- ///
- ///
- /// You can create a software device as the child of a parent that is not present at the time. PnP will enumerate the software
- /// device after the parent becomes present.
- ///
- ///
- // https://docs.microsoft.com/en-us/windows/win32/api/swdevice/nf-swdevice-swdevicecreate HRESULT SwDeviceCreate( PCWSTR
- // pszEnumeratorName, PCWSTR pszParentDeviceInstance, const SW_DEVICE_CREATE_INFO *pCreateInfo, ULONG cPropertyCount, const
- // DEVPROPERTY *pProperties, SW_DEVICE_CREATE_CALLBACK pCallback, PVOID pContext, PHSWDEVICE phSwDevice );
- [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
- [PInvokeData("swdevice.h", MSDNShortId = "NF:swdevice.SwDeviceCreate")]
- public static extern HRESULT SwDeviceCreate([MarshalAs(UnmanagedType.LPWStr)] string pszEnumeratorName, [MarshalAs(UnmanagedType.LPWStr)] string pszParentDeviceInstance,
- in SW_DEVICE_CREATE_INFO pCreateInfo, uint cPropertyCount, [In, Optional, MarshalAs(UnmanagedType.LPArray)] DEVPROPERTY[] pProperties, SW_DEVICE_CREATE_CALLBACK pCallback,
- [In, Optional] IntPtr pContext, out SafeHSWDEVICE phSwDevice);
+ internal class SwMemMarshaler : ICustomMarshaler
+ {
+ public static ICustomMarshaler GetInstance() => new SwMemMarshaler();
- SwDeviceGetLifetime Gets the lifetime of a software device.
- SwDeviceInterfacePropertySet Sets properties on a software device interface.
- SwDeviceInterfaceRegister Registers a device interface for a software device and optionally sets properties on that interface.
- SwDeviceInterfaceSetState Enables or disables a device interface for a software device.
- SwDevicePropertySet Sets properties on a software device.
- SwDeviceSetLifetime Manages the lifetime of a software device.
- SwMemFree Frees memory that other Software Device API functions allocated.
- */
+ void ICustomMarshaler.CleanUpManagedData(object ManagedObj) => throw new NotImplementedException();
+
+ void ICustomMarshaler.CleanUpNativeData(IntPtr pNativeData) => SwMemFree(pNativeData);
+
+ int ICustomMarshaler.GetNativeDataSize() => -1;
+
+ IntPtr ICustomMarshaler.MarshalManagedToNative(object ManagedObj) => throw new NotImplementedException();
+
+ object ICustomMarshaler.MarshalNativeToManaged(IntPtr pNativeData) => StringHelper.GetString(pNativeData, CharSet.Unicode);
+ }
}
}
\ No newline at end of file