/// <summary>
/// Connects to the notification_proxy on the specified device.
/// </summary>
/// <param name="device">
/// The device to connect to.
/// </param>
/// <param name="service">
/// The service descriptor returned by lockdownd_start_service.
/// </param>
/// <param name="client">
/// Pointer that will be set to a newly allocated np_client_t
/// upon successful return.
/// </param>
/// <returns>
/// NP_E_SUCCESS on success, NP_E_INVALID_ARG when device is NULL,
/// or NP_E_CONN_FAILED when the connection to the device could not be
/// established.
/// </returns>
public virtual NotificationProxyError np_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out NotificationProxyClientHandle client)
{
NotificationProxyError returnValue;
returnValue = NotificationProxyNativeMethods.np_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new notification proxy service on the specified device and connects to it.
/// </summary>
/// <param name="device">
/// The device to connect to.
/// </param>
/// <param name="client">
/// Pointer that will point to a newly allocated
/// np_client_t upon successful return. Must be freed using
/// np_client_free() after use.
/// </param>
/// <param name="label">
/// The label to use for communication. Usually the program name.
/// Pass NULL to disable sending the label in requests to lockdownd.
/// </param>
/// <returns>
/// NP_E_SUCCESS on success, or an NP_E_* error
/// code otherwise.
/// </returns>
public virtual NotificationProxyError np_client_start_service(iDeviceHandle device, out NotificationProxyClientHandle client, string label)
{
NotificationProxyError returnValue;
returnValue = NotificationProxyNativeMethods.np_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
public static NotificationProxyError np_observe_notifications(NotificationProxyClientHandle client, out string notificationSpec)
{
System.Runtime.InteropServices.ICustomMarshaler notificationSpecMarshaler = NativeStringMarshaler.GetInstance(null);
System.IntPtr notificationSpecNative = System.IntPtr.Zero;
NotificationProxyError returnValue = NotificationProxyNativeMethods.np_observe_notifications(client, out notificationSpecNative);
notificationSpec = ((string)notificationSpecMarshaler.MarshalNativeToManaged(notificationSpecNative));
notificationSpecMarshaler.CleanUpNativeData(notificationSpecNative);
return(returnValue);
}
/// <summary>
/// This function allows an application to define a callback function that will
/// be called when a notification has been received.
/// It will start a thread that polls for notifications and calls the callback
/// function if a notification has been received.
/// In case of an error condition when polling for notifications - e.g. device
/// disconnect - the thread will call the callback function with an empty
/// notification "" and terminate itself.
/// </summary>
/// <param name="client">
/// the NP client
/// </param>
/// <param name="notify_cb">
/// pointer to a callback function or NULL to de-register a
/// previously set callback function.
/// </param>
/// <param name="user_data">
/// Pointer that will be passed to the callback function as
/// user data. If notify_cb is NULL, this parameter is ignored.
/// </param>
/// <returns>
/// NP_E_SUCCESS when the callback was successfully registered,
/// NP_E_INVALID_ARG when client is NULL, or NP_E_UNKNOWN_ERROR when
/// the callback thread could no be created.
/// </returns>
/// <remarks>
/// Only one callback function can be registered at the same time;
/// any previously set callback function will be removed automatically.
/// </remarks>
public virtual NotificationProxyError np_set_notify_callback(NotificationProxyClientHandle client, NotificationProxyNotifyCallBack notifyCallBack, System.IntPtr userdata)
{
return(NotificationProxyNativeMethods.np_set_notify_callback(client, notifyCallBack, userdata));
}
/// <summary>
/// Tells the device to send a notification on specified events.
/// </summary>
/// <param name="client">
/// The client to send to
/// </param>
/// <param name="notification_spec">
/// Specification of the notifications that should be
/// observed. This is expected to be an array of const char* that MUST have a
/// terminating NULL entry.
/// </param>
/// <returns>
/// NP_E_SUCCESS on success, NP_E_INVALID_ARG when client is null,
/// or an error returned by np_observe_notification.
/// </returns>
public virtual NotificationProxyError np_observe_notifications(NotificationProxyClientHandle client, out string notificationSpec)
{
return(NotificationProxyNativeMethods.np_observe_notifications(client, out notificationSpec));
}
/// <summary>
/// Tells the device to send a notification on the specified event.
/// </summary>
/// <param name="client">
/// The client to send to
/// </param>
/// <param name="notification">
/// The notifications that should be observed.
/// </param>
/// <returns>
/// NP_E_SUCCESS on success, NP_E_INVALID_ARG when client or
/// notification are NULL, or an error returned by np_plist_send.
/// </returns>
public virtual NotificationProxyError np_observe_notification(NotificationProxyClientHandle client, string notification)
{
return(NotificationProxyNativeMethods.np_observe_notification(client, notification));
}
/// <summary>
/// Disconnects a notification_proxy client from the device and frees up the
/// notification_proxy client data.
/// </summary>
/// <param name="client">
/// The notification_proxy client to disconnect and free.
/// </param>
/// <returns>
/// NP_E_SUCCESS on success, or NP_E_INVALID_ARG when client is NULL.
/// </returns>
public virtual NotificationProxyError np_client_free(System.IntPtr client)
{
return(NotificationProxyNativeMethods.np_client_free(client));
}
