/// <summary>
/// Constructor for string input argument for an action
/// </summary>
/// <remarks>Intended to be write only (its value is written on construction and not be later read)</remarks>
/// <param name="aParameter">Defines the name plus any bounds to the value for the argument.
/// Must have been previously added to the action using Action.AddInputParameter</param>
/// <param name="aValue">Value for the argument</param>
public ArgumentString(ParameterString aParameter, String aValue)
{
IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue);
iHandle = ActionArgumentCreateStringInput(aParameter.Handle(), value);
Marshal.FreeHGlobal(value);
}
/// <summary>
/// Constructor. Creates a device capable of operating on any of the protocols the device
/// stack supports as standard but with no services or attributes as yet
/// </summary>
/// <param name="aUdn">Universally unique identifier. The caller is responsible for calculating/assigning this</param>
public unsafe DvDeviceStandard(string aUdn)
{
IntPtr udn = InteropUtils.StringToHGlobalUtf8(aUdn);
iHandle = DvDeviceStandardCreateNoResources(udn);
Marshal.FreeHGlobal(udn);
}
public void TryAdd(string aLocation)
{
IntPtr location = InteropUtils.StringToHGlobalUtf8(aLocation);
CpDeviceListUpnpTryAdd(iHandle, location);
Marshal.FreeHGlobal(location);
}
/// <summary>
/// Report an error reading or writing an invocation
/// </summary>
/// <remarks>Must be called if ReadEnd() isn't reached.
/// May be called if WriteStart() or later have been called.</remarks>
/// <param name="aCode">Error code</param>
/// <param name="aDescription">Error description</param>
public void ReportError(uint aCode, String aDescription)
{
IntPtr desc = InteropUtils.StringToHGlobalUtf8(aDescription);
// no point in propogating any error - client code can't cope with error reporting failing
DvInvocationReportError(iHandle, aCode, desc);
Marshal.FreeHGlobal(desc);
}
/// <summary>
/// Constructor. Creates a device without support for any protocol but capable of adding services or attributes.
/// This should only be used with CpDeviceDv.
/// </summary>
/// <param name="aUdn">Universally unique identifier. The caller is responsible for calculating/assigning this</param>
public unsafe DvDevice(string aUdn)
{
IntPtr udn = InteropUtils.StringToHGlobalUtf8(aUdn);
iHandle = DvDeviceCreate(udn);
Marshal.FreeHGlobal(udn);
iCallbackDisabled = new DisabledCallback(Disabled);
}
/// <summary>
/// Set the value of an unsigned integer output argument for an invocation.
/// </summary>
/// <param name="aName">Name of the parameter associated with this output argument</param>
/// <param name="aValue">Value of the output argument</param>
public void WriteUint(String aName, uint aValue)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
int err = DvInvocationWriteUint(iHandle, name, aValue);
Marshal.FreeHGlobal(name);
CheckError(err);
}
/// <summary>
/// Query the value of an atrribute
/// </summary>
/// <param name="aKey">string of the form protocol_name.protocol_specific_key.
/// Commonly used keys are published ... (!!!! where?)</param>
/// <param name="aValue">string containing the attribute or null if the attribute has not been set.</param>
public unsafe void GetAttribute(string aKey, out string aValue)
{
IntPtr key = InteropUtils.StringToHGlobalUtf8(aKey);
char * value;
DvDeviceGetAttribute(iHandle, key, &value);
Marshal.FreeHGlobal(key);
aValue = InteropUtils.PtrToStringUtf8((IntPtr)value);
}
/// <summary>
/// Set the value of an attribute
/// </summary>
/// <param name="aKey">string of the form protocol_name.protocol_specific_key</param>
/// <param name="aValue">attribute will be set to a copy of this string</param>
public unsafe void SetAttribute(string aKey, string aValue)
{
IntPtr key = InteropUtils.StringToHGlobalUtf8(aKey);
IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue);
DvDeviceSetAttribute(iHandle, key, value);
Marshal.FreeHGlobal(key);
Marshal.FreeHGlobal(value);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="aUuid">Unique identifier for the target device.</param>
/// <param name="aAdded">Delegate which will be run when a new device is detected.
/// Clients who are interested this new device should call AddRef() on it and add it to some local collection.
/// This callback will never be run for a device that is already in the list.</param>
/// <param name="aRemoved">Delegatewhich will be run when a device is removed from the network.
/// Clients who had previously stored a reference to the device in their aAdded callback should call RemoveRef()
/// and remove the device from their local collection.
/// Clients who had not previously claimed a reference to a device must not call ReleaseRef().</param>
public CpDeviceListUpnpUuid(String aUuid, ChangeHandler aAdded, ChangeHandler aRemoved)
: base(aAdded, aRemoved)
{
IntPtr uuid = InteropUtils.StringToHGlobalUtf8(aUuid);
IntPtr ptr = GCHandle.ToIntPtr(iGch);
iHandle = CpDeviceListCreateUpnpUuid(uuid, iFnAdded, ptr, iFnRemoved, ptr);
Marshal.FreeHGlobal(uuid);
}
/// <summary>
/// Set the value of a boolean output argument for an invocation.
/// </summary>
/// <param name="aName">Name of the parameter associated with this output argument</param>
/// <param name="aValue">Value of the output argument</param>
public void WriteBool(String aName, bool aValue)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
uint val = (aValue? 1u : 0u);
int err = DvInvocationWriteBool(iHandle, name, val);
Marshal.FreeHGlobal(name);
CheckError(err);
}
/// <summary>
/// Read the value of a boolean input argument for an invocation
/// </summary>
/// <param name="aName">Name of the parameter associated with this input argument</param>
/// <returns>Value of the input argument</returns>
public bool ReadBool(String aName)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
uint val;
int err = DvInvocationReadBool(iHandle, name, out val);
Marshal.FreeHGlobal(name);
CheckError(err);
return(val != 0);
}
/// <summary>
/// Read the value of an unsigned integer input argument for an invocation
/// </summary>
/// <param name="aName">Name of the parameter associated with this input argument</param>
/// <returns>Value of the input argument</returns>
public unsafe uint ReadUint(String aName)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
uint val;
int err = DvInvocationReadUint(iHandle, name, &val);
Marshal.FreeHGlobal(name);
CheckError(err);
return(val);
}
public unsafe void WriteResourceBegin(int aTotalBytes, string aMimeType)
{
IntPtr mimeType = InteropUtils.StringToHGlobalUtf8(aMimeType);
int err = iWriteBegin(iWriterData, aTotalBytes, mimeType);
Marshal.FreeHGlobal(mimeType);
if (err != 0)
{
throw new ResourceWriterError();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="aDevice">Device the service is being added to and will be offered by</param>
/// <param name="aDomain">Domain of the vendor who defined the service</param>
/// <param name="aType">Name of the service</param>
/// <param name="aVersion">Version number of the service</param>
protected DvProvider(DvDevice aDevice, String aDomain, String aType, uint aVersion)
{
IntPtr domain = InteropUtils.StringToHGlobalUtf8(aDomain);
IntPtr type = InteropUtils.StringToHGlobalUtf8(aType);
iHandle = DvProviderCreate(aDevice.Handle(), domain, type, aVersion);
Marshal.FreeHGlobal(type);
Marshal.FreeHGlobal(domain);
iActions = new List <OpenHome.Net.Core.Action>();
iProperties = new List <OpenHome.Net.Core.Property>();
}
/// <summary>
/// Constructor. Creates a device capable of serving UI files and of operating on any of the
/// protocols the device stack supports as standard but with no services or attributes as yet
/// </summary>
/// <param name="aUdn">Universally unique identifier. The caller is responsible for calculating/assigning this</param>
/// <param name="aResourceManager">Allows the owner of a device to serve UI files</param>
public unsafe DvDeviceStandard(string aUdn, IResourceManager aResourceManager)
{
iResourceManager = aResourceManager;
iGch = GCHandle.Alloc(this);
IntPtr ptr = GCHandle.ToIntPtr(iGch);
IntPtr udn = InteropUtils.StringToHGlobalUtf8(aUdn);
iCallbackResourceManager = new CallbackResourceManager(WriteResource);
iHandle = DvDeviceStandardCreate(udn, iCallbackResourceManager, ptr);
Marshal.FreeHGlobal(udn);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="aDomainName">Vendor domain for the target service (e.g. upnp.org).</param>
/// <param name="aServiceType">Name of the target service.</param>
/// <param name="aVersion">Version number for the target service.</param>
/// <param name="aAdded">Delegate which will be run when a new device is detected.
/// Clients who are interested this new device should call AddRef() on it and add it to some local collection.
/// This callback will never be run for a device that is already in the list.</param>
/// <param name="aRemoved">Delegatewhich will be run when a device is removed from the network.
/// Clients who had previously stored a reference to the device in their aAdded callback should call RemoveRef()
/// and remove the device from their local collection.
/// Clients who had not previously claimed a reference to a device must not call ReleaseRef().</param>
public CpDeviceListUpnpServiceType(String aDomainName, String aServiceType, uint aVersion,
ChangeHandler aAdded, ChangeHandler aRemoved)
: base(aAdded, aRemoved)
{
IntPtr domain = InteropUtils.StringToHGlobalUtf8(aDomainName);
IntPtr type = InteropUtils.StringToHGlobalUtf8(aServiceType);
IntPtr ptr = GCHandle.ToIntPtr(iGch);
iHandle = CpDeviceListCreateUpnpServiceType(domain, type, aVersion, iFnAdded, ptr, iFnRemoved, ptr);
Marshal.FreeHGlobal(domain);
Marshal.FreeHGlobal(type);
}
/// <summary>
/// Utility function which updates the value of a PropertyString. (Not intended for external use)
/// </summary>
/// <remarks>If the property value has changed and the properties are not locked (PropertiesLock()
/// called more recently than PropertiesUnlock()), publication of an update is scheduled.
///
/// Throws ParameterValidationError if the property has a range of allowed values and
/// the new value is not in this range</remarks>
/// <param name="aProperty">Property to be updated</param>
/// <param name="aValue">New value for the property</param>
/// <returns>true if the property's value has changed (aValue was different to the previous value)</returns>
protected bool SetPropertyString(PropertyString aProperty, String aValue)
{
uint changed;
IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue);
int err = DvProviderSetPropertyString(iHandle, aProperty.Handle(), value, out changed);
Marshal.FreeHGlobal(value);
if (err != 0)
{
throw new PropertyUpdateError();
}
return(changed != 0);
}
protected CpProxy(String aDomain, String aName, uint aVersion, CpDevice aDevice)
{
IntPtr domain = InteropUtils.StringToHGlobalUtf8(aDomain);
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
iHandle = CpProxyCreate(domain, name, aVersion, aDevice.Handle());
Marshal.FreeHGlobal(domain);
Marshal.FreeHGlobal(name);
IntPtr serviceHandle = CpProxyService(iHandle);
iService = new CpService(serviceHandle);
iGchProxy = GCHandle.Alloc(this);
iSubscriptionStatusLock = new Mutex();
}
/// <summary>
/// Read the value of a string input argument for an invocation
/// </summary>
/// <param name="aName">Name of the parameter associated with this input argument</param>
/// <returns>Value of the input argument</returns>
public String ReadString(String aName)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
IntPtr ptr;
uint len;
int err = DvInvocationReadStringAsBuffer(iHandle, name, out ptr, out len);
Marshal.FreeHGlobal(name);
String str = InteropUtils.PtrToStringUtf8(ptr, len);
OhNetFree(ptr);
CheckError(err);
return(str);
}
/// <summary>
/// Query the value of one of the device's attributes
/// </summary>
/// <param name="aKey">The name of the attribute being queried. Available attributes
/// will be listed in a protocol-specific header</param>
/// <param name="aValue">The value of the attribute</param>
/// <returns>true if the attribute was available on the device; false otherwise.
/// aValue will not have been set if false is returned</returns>
public bool GetAttribute(string aKey, out string aValue)
{
IntPtr key = InteropUtils.StringToHGlobalUtf8(aKey);
IntPtr value;
int ret = CpDeviceCGetAttribute(iHandle, key, out value);
Marshal.FreeHGlobal(key);
if (ret != 0)
{
aValue = InteropUtils.PtrToStringUtf8(value);
OhNetFree(value);
return(true);
}
aValue = null;
return(false);
}
/// <summary>
/// Read the value of a binary input argument for an invocation
/// </summary>
/// <param name="aName">Name of the parameter associated with this input argument</param>
/// <returns>Value of the input argument</returns>
public byte[] ReadBinary(String aName)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
IntPtr data;
uint len;
int err = DvInvocationReadBinary(iHandle, name, out data, out len);
Marshal.FreeHGlobal(name);
byte[] bin = new byte[len];
if (len > 0)
{
Marshal.Copy(data, bin, 0, (int)len);
}
OhNetFree((IntPtr)data);
CheckError(err);
return(bin);
}
/// <summary>
/// Set the value of a binary output argument for an invocation.
/// </summary>
/// <param name="aName">Name of the parameter associated with this output argument</param>
/// <param name="aData">Value of the output argument</param>
public void WriteBinary(String aName, byte[] aData)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
int err = DvInvocationWriteBinaryStart(iHandle, name);
if (err == 0)
{
GCHandle h = GCHandle.Alloc(aData, GCHandleType.Pinned);
err = DvInvocationWriteBinary(iHandle, h.AddrOfPinnedObject(), (uint)aData.Length);
h.Free();
}
if (err == 0)
{
err = DvInvocationWriteBinaryEnd(iHandle, name);
}
Marshal.FreeHGlobal(name);
CheckError(err);
}
/// <summary>
/// Set the value of a string output argument for an invocation.
/// </summary>
/// <param name="aName">Name of the parameter associated with this output argument</param>
/// <param name="aValue">Value of the output argument</param>
public void WriteString(String aName, String aValue)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue);
int err = DvInvocationWriteStringStart(iHandle, name);
if (err == 0)
{
err = DvInvocationWriteString(iHandle, value);
}
Marshal.FreeHGlobal(value);
if (err == 0)
{
err = DvInvocationWriteStringEnd(iHandle, name);
}
Marshal.FreeHGlobal(name);
CheckError(err);
}
/// <summary>
/// Set the value of a binary output argument for an invocation.
/// </summary>
/// <param name="aName">Name of the parameter associated with this output argument</param>
/// <param name="aData">Value of the output argument</param>
public unsafe void WriteBinary(String aName, byte[] aData)
{
IntPtr name = InteropUtils.StringToHGlobalUtf8(aName);
int err = DvInvocationWriteBinaryStart(iHandle, name);
if (err == 0)
{
fixed(byte *data = aData)
{
err = DvInvocationWriteBinary(iHandle, data, (uint)aData.Length);
}
}
if (err == 0)
{
err = DvInvocationWriteBinaryEnd(iHandle, name);
}
Marshal.FreeHGlobal(name);
CheckError(err);
}