/// <summary>
/// Starts a new heartbeat 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
/// heartbeat_client_t upon successful return. Must be freed using
/// heartbeat_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>
/// HEARTBEAT_E_SUCCESS on success, or an HEARTBEAT_E_* error
/// code otherwise.
/// </returns>
public virtual HeartBeatError heartbeat_client_start_service(iDeviceHandle device, out HeartBeatClientHandle client, string label)
{
HeartBeatError returnValue;
returnValue = HeartBeatNativeMethods.heartbeat_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the house_arrest service 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 point to a newly allocated
/// housearrest_client_t upon successful return.
/// </param>
/// <returns>
/// HOUSE_ARREST_E_SUCCESS on success, HOUSE_ARREST_E_INVALID_ARG when
/// client is NULL, or an HOUSE_ARREST_E_* error code otherwise.
/// </returns>
public virtual HouseArrestError house_arrest_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out HouseArrestClientHandle client)
{
HouseArrestError returnValue;
returnValue = HouseArrestNativeMethods.house_arrest_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the springboardservices service 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 point to a newly allocated
/// sbservices_client_t upon successful return.
/// </param>
/// <returns>
/// SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when
/// client is NULL, or an SBSERVICES_E_* error code otherwise.
/// </returns>
public virtual SpringBoardServicesError sbservices_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out SpringBoardServicesClientHandle client)
{
SpringBoardServicesError returnValue;
returnValue = SpringBoardServicesNativeMethods.sbservices_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the installation_proxy service 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
/// instproxy_client_t upon successful return.
/// </param>
/// <returns>
/// INSTPROXY_E_SUCCESS on success, or an INSTPROXY_E_* error value
/// when an error occured.
/// </returns>
public virtual InstallationProxyError instproxy_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out InstallationProxyClientHandle client)
{
InstallationProxyError returnValue;
returnValue = InstallationProxyNativeMethods.instproxy_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the mobilebackup service 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
/// mobilebackup_client_t upon successful return.
/// </param>
/// <returns>
/// MOBILEBACKUP_E_SUCCESS on success, MOBILEBACKUP_E_INVALID ARG if one
/// or more parameters are invalid, or DEVICE_LINK_SERVICE_E_BAD_VERSION if
/// the mobilebackup version on the device is newer.
/// </returns>
public virtual MobileBackupError mobilebackup_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MobileBackupClientHandle client)
{
MobileBackupError returnValue;
returnValue = MobileBackupNativeMethods.mobilebackup_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new misagent 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
/// misagent_client_t upon successful return. Must be freed using
/// misagent_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>
/// MISAGENT_E_SUCCESS on success, or an MISAGENT_E_* error
/// code otherwise.
/// </returns>
public virtual MisagentError misagent_client_start_service(iDeviceHandle device, out MisagentClientHandle client, string label)
{
MisagentError returnValue;
returnValue = MisagentNativeMethods.misagent_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new syslog_relay 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
/// syslog_relay_client_t upon successful return. Must be freed using
/// syslog_relay_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>
/// SYSLOG_RELAY_E_SUCCESS on success, or an SYSLOG_RELAY_E_* error
/// code otherwise.
/// </returns>
public virtual SyslogRelayError syslog_relay_client_start_service(iDeviceHandle device, out SyslogRelayClientHandle client, string label)
{
SyslogRelayError returnValue;
returnValue = SyslogRelayNativeMethods.syslog_relay_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the file_relay service 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">
/// Reference that will point to a newly allocated
/// file_relay_client_t upon successful return.
/// </param>
/// <returns>
/// FILE_RELAY_E_SUCCESS on success,
/// FILE_RELAY_E_INVALID_ARG when one of the parameters is invalid,
/// or FILE_RELAY_E_MUX_ERROR when the connection failed.
/// </returns>
public virtual FileRelayError file_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out FileRelayClientHandle client)
{
FileRelayError returnValue;
returnValue = FileRelayNativeMethods.file_relay_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new file_relay 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
/// file_relay_client_t upon successful return. Must be freed using
/// file_relay_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>
/// FILE_RELAY_E_SUCCESS on success, or an FILE_RELAY_E_* error
/// code otherwise.
/// </returns>
public virtual FileRelayError file_relay_client_start_service(iDeviceHandle device, out FileRelayClientHandle client, string label)
{
FileRelayError returnValue;
returnValue = FileRelayNativeMethods.file_relay_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <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);
}
/// <summary>
/// Connects to the mobile_image_mounter service 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
/// mobile_image_mounter_client_t upon successful return.
/// </param>
/// <returns>
/// MOBILE_IMAGE_MOUNTER_E_SUCCESS on success,
/// MOBILE_IMAGE_MOUNTER_E_INVALID_ARG if device is NULL,
/// or MOBILE_IMAGE_MOUNTER_E_CONN_FAILED if the connection to the
/// device could not be established.
/// </returns>
public virtual MobileImageMounterError mobile_image_mounter_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MobileImageMounterClientHandle client)
{
MobileImageMounterError returnValue;
returnValue = MobileImageMounterNativeMethods.mobile_image_mounter_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new mobile_image_mounter 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
/// mobile_image_mounter_t upon successful return. Must be freed using
/// mobile_image_mounter_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>
/// MOBILE_IMAGE_MOUNTER_E_SUCCESS on success, or an MOBILE_IMAGE_MOUNTER_E_* error
/// code otherwise.
/// </returns>
public virtual MobileImageMounterError mobile_image_mounter_start_service(iDeviceHandle device, out MobileImageMounterClientHandle client, string label)
{
MobileImageMounterError returnValue;
returnValue = MobileImageMounterNativeMethods.mobile_image_mounter_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new sbservices 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
/// sbservices_client_t upon successful return. Must be freed using
/// sbservices_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>
/// SBSERVICES_E_SUCCESS on success, or an SBSERVICES_E_* error
/// code otherwise.
/// </returns>
public virtual SpringBoardServicesError sbservices_client_start_service(iDeviceHandle device, out SpringBoardServicesClientHandle client, string label)
{
SpringBoardServicesError returnValue;
returnValue = SpringBoardServicesNativeMethods.sbservices_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Creates a new property list service for the specified port.
/// </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
/// property_list_service_client_t upon successful return.
/// </param>
/// <returns>
/// PROPERTY_LIST_SERVICE_E_SUCCESS on success,
/// PROPERTY_LIST_SERVICE_E_INVALID_ARG when one of the arguments is invalid,
/// or PROPERTY_LIST_SERVICE_E_MUX_ERROR when connecting to the device failed.
/// </returns>
public virtual PropertyListServiceError property_list_service_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out PropertyListServiceClientHandle client)
{
PropertyListServiceError returnValue;
returnValue = PropertyListServiceNativeMethods.property_list_service_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the debugserver service 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 point to a newly allocated
/// debugserver_client_t upon successful return. Must be freed using
/// debugserver_client_free() after use.
/// </param>
/// <returns>
/// DEBUGSERVER_E_SUCCESS on success, DEBUGSERVER_E_INVALID_ARG when
/// client is NULL, or an DEBUGSERVER_E_* error code otherwise.
/// </returns>
public virtual DebugServerError debugserver_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out DebugServerClientHandle client)
{
DebugServerError returnValue;
returnValue = DebugServerNativeMethods.debugserver_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the misagent service 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 point to a newly allocated
/// misagent_client_t upon successful return.
/// </param>
/// <returns>
/// MISAGENT_E_SUCCESS on success, MISAGENT_E_INVALID_ARG when
/// client is NULL, or an MISAGENT_E_* error code otherwise.
/// </returns>
public virtual MisagentError misagent_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MisagentClientHandle client)
{
MisagentError returnValue;
returnValue = MisagentNativeMethods.misagent_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new debugserver 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
/// debugserver_client_t upon successful return. Must be freed using
/// debugserver_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>
/// DEBUGSERVER_E_SUCCESS on success, or an DEBUGSERVER_E_* error
/// code otherwise.
/// </returns>
public virtual DebugServerError debugserver_client_start_service(iDeviceHandle device, out DebugServerClientHandle client, string label)
{
DebugServerError returnValue;
returnValue = DebugServerNativeMethods.debugserver_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the syslog_relay service 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 point to a newly allocated
/// syslog_relay_client_t upon successful return. Must be freed using
/// syslog_relay_client_free() after use.
/// </param>
/// <returns>
/// SYSLOG_RELAY_E_SUCCESS on success, SYSLOG_RELAY_E_INVALID_ARG when
/// client is NULL, or an SYSLOG_RELAY_E_* error code otherwise.
/// </returns>
public virtual SyslogRelayError syslog_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out SyslogRelayClientHandle client)
{
SyslogRelayError returnValue;
returnValue = SyslogRelayNativeMethods.syslog_relay_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the diagnostics_relay service 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">
/// Reference that will point to a newly allocated
/// diagnostics_relay_client_t upon successful return.
/// </param>
/// <returns>
/// DIAGNOSTICS_RELAY_E_SUCCESS on success,
/// DIAGNOSTICS_RELAY_E_INVALID_ARG when one of the parameters is invalid,
/// or DIAGNOSTICS_RELAY_E_MUX_ERROR when the connection failed.
/// </returns>
public virtual DiagnosticsRelayError diagnostics_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out DiagnosticsRelayClientHandle client)
{
DiagnosticsRelayError returnValue;
returnValue = DiagnosticsRelayNativeMethods.diagnostics_relay_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Creates a new service for the specified service descriptor.
/// </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
/// service_client_t upon successful return.
/// </param>
/// <returns>
/// SERVICE_E_SUCCESS on success,
/// SERVICE_E_INVALID_ARG when one of the arguments is invalid,
/// or SERVICE_E_MUX_ERROR when connecting to the device failed.
/// </returns>
public virtual ServiceError service_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out ServiceClientHandle client)
{
ServiceError returnValue;
returnValue = ServiceNativeMethods.service_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new diagnostics_relay 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
/// diagnostics_relay_client_t upon successful return. Must be freed using
/// diagnostics_relay_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>
/// DIAGNOSTICS_RELAY_E_SUCCESS on success, or an DIAGNOSTICS_RELAY_E_* error
/// code otherwise.
/// </returns>
public virtual DiagnosticsRelayError diagnostics_relay_client_start_service(iDeviceHandle device, out DiagnosticsRelayClientHandle client, string label)
{
DiagnosticsRelayError returnValue;
returnValue = DiagnosticsRelayNativeMethods.diagnostics_relay_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new installation_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
/// instproxy_client_t upon successful return. Must be freed using
/// instproxy_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>
/// INSTPROXY_E_SUCCESS on success, or an INSTPROXY_E_* error
/// code otherwise.
/// </returns>
public virtual InstallationProxyError instproxy_client_start_service(iDeviceHandle device, out InstallationProxyClientHandle client, string label)
{
InstallationProxyError returnValue;
returnValue = InstallationProxyNativeMethods.instproxy_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Creates a new restored client for the device.
/// </summary>
/// <param name="device">
/// The device to create a restored client for
/// </param>
/// <param name="client">
/// The pointer to the location of the new restored_client
/// </param>
/// <param name="label">
/// The label to use for communication. Usually the program name.
/// </param>
/// <returns>
/// RESTORE_E_SUCCESS on success, RESTORE_E_INVALID_ARG when client is NULL
/// </returns>
public virtual RestoreError restored_client_new(iDeviceHandle device, out RestoreClientHandle client, string label)
{
RestoreError returnValue;
returnValue = RestoreNativeMethods.restored_client_new(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new mobilebackup 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
/// mobilebackup_client_t upon successful return. Must be freed using
/// mobilebackup_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>
/// MOBILEBACKUP_E_SUCCESS on success, or an MOBILEBACKUP_E_* error
/// code otherwise.
/// </returns>
public virtual MobileBackupError mobilebackup_client_start_service(iDeviceHandle device, out MobileBackupClientHandle client, string label)
{
MobileBackupError returnValue;
returnValue = MobileBackupNativeMethods.mobilebackup_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Connects to the heartbeat service 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 point to a newly allocated
/// heartbeat_client_t upon successful return. Must be freed using
/// heartbeat_client_free() after use.
/// </param>
/// <returns>
/// HEARTBEAT_E_SUCCESS on success, HEARTBEAT_E_INVALID_ARG when
/// client is NULL, or an HEARTBEAT_E_* error code otherwise.
/// </returns>
public virtual HeartBeatError heartbeat_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out HeartBeatClientHandle client)
{
HeartBeatError returnValue;
returnValue = HeartBeatNativeMethods.heartbeat_client_new(device, service, out client);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new house_arrest 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
/// house_arrest_client_t upon successful return. Must be freed using
/// house_arrest_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>
/// HOUSE_ARREST_E_SUCCESS on success, or an HOUSE_ARREST_E_* error
/// code otherwise.
/// </returns>
public virtual HouseArrestError house_arrest_client_start_service(iDeviceHandle device, out HouseArrestClientHandle client, string label)
{
HouseArrestError returnValue;
returnValue = HouseArrestNativeMethods.house_arrest_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
/// <summary>
/// Starts a new AFC 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 afc_client_t upon
/// successful return. Must be freed using afc_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>
/// AFC_E_SUCCESS on success, or an AFC_E_* error code otherwise.
/// </returns>
public virtual AfcError afc_client_start_service(iDeviceHandle device, out AfcClientHandle client, string label)
{
AfcError returnValue;
returnValue = AfcNativeMethods.afc_client_start_service(device, out client, label);
client.Api = this.Parent;
return(returnValue);
}
