soup/org.gtkkn.bindings.soup/WebsocketConnection

WebsocketConnection

class WebsocketConnection(val soupWebsocketConnectionPointer: <Error class: unknown class><<Error class: unknown class>>)(source)

The WebSocket Protocol

Provides support for the WebSocket protocol.

To connect to a WebSocket server, create a class@Session and call method@Session.websocket_connect_async. To accept WebSocket connections, create a class@Server and add a handler to it with method@Server.add_websocket_handler.

(Lower-level support is available via func@websocket_client_prepare_handshake and func@websocket_client_verify_handshake, for handling the client side of the WebSocket handshake, and func@websocket_server_process_handshake for handling the server side.)

#SoupWebsocketConnection handles the details of WebSocket communication. You can use method@WebsocketConnection.send_text and method@WebsocketConnection.send_binary to send data, and the signal@WebsocketConnection::message signal to receive data. (#SoupWebsocketConnection currently only supports asynchronous I/O.)

Skipped during bindings generation

parameter data: Array parameter of type guint8 is not supported

Constructors

WebsocketConnection

constructor( stream: <Error class: unknown class>, uri: <Error class: unknown class>, type: WebsocketConnectionType, origin: String? = null, protocol: String? = null, extensions: <Error class: unknown class>)

Creates a #SoupWebsocketConnection on @stream with the given active @extensions.

constructor(soupWebsocketConnectionPointer: <Error class: unknown class><<Error class: unknown class>>)

Types

Companion

object Companion

Properties

connectionType

val connectionType: WebsocketConnectionType

The type of connection (client/server).

extensions

val extensions: <Error class: unknown class>

List of class@WebsocketExtension objects that are active in the connection.

ioStream

val ioStream: <Error class: unknown class>

The underlying IO stream the WebSocket is communicating over.

keepaliveInterval

var keepaliveInterval: <Error class: unknown class>

Interval in seconds on when to send a ping message which will serve as a keepalive message.

keepalivePongTimeout

var keepalivePongTimeout: <Error class: unknown class>

Timeout in seconds for when the absence of a pong from a keepalive ping is assumed to be caused by a faulty connection. The WebSocket will be transitioned to a closed state when this happens.

maxIncomingPayloadSize

var maxIncomingPayloadSize: <Error class: unknown class>

The maximum payload size for incoming packets.

origin

val origin: String?

The client's Origin.

protocol

val protocol: String?

The chosen protocol, or null if a protocol was not agreed upon.

soupWebsocketConnectionPointer

val soupWebsocketConnectionPointer: <Error class: unknown class><<Error class: unknown class>>

state

val state: WebsocketState

The current state of the WebSocket.

uri

val uri: <Error class: unknown class>

The URI of the WebSocket.

Functions

fun close(code: <Error class: unknown class>, data: String? = null)

Close the connection in an orderly fashion.

emitClosed

fun emitClosed()

Emits the "closed" signal. See onClosed.

emitClosing

fun emitClosing()

Emits the "closing" signal. See onClosing.

emitError

fun emitError(error: <Error class: unknown class>)

Emits the "error" signal. See onError.

emitMessage

fun emitMessage(type: <Error class: unknown class>, message: <Error class: unknown class>)

Emits the "message" signal. See onMessage.

emitPong

fun emitPong(message: <Error class: unknown class>)

Emits the "pong" signal. See onPong.

getCloseCode

fun getCloseCode(): <Error class: unknown class>

Get the close code received from the WebSocket peer.

getCloseData

fun getCloseData(): String

Get the close data received from the WebSocket peer.

onClosed

fun onClosed(connectFlags: <Error class: unknown class> = ConnectFlags(0u), handler: () -> Unit): <Error class: unknown class>

Emitted when the connection has completely closed.

onClosing

fun onClosing(connectFlags: <Error class: unknown class> = ConnectFlags(0u), handler: () -> Unit): <Error class: unknown class>

This signal will be emitted during an orderly close.

onError

fun onError( connectFlags: <Error class: unknown class> = ConnectFlags(0u), handler: (<Error class: unknown class>) -> Unit): <Error class: unknown class>

Emitted when an error occurred on the WebSocket.

onMessage

fun onMessage( connectFlags: <Error class: unknown class> = ConnectFlags(0u), handler: (<Error class: unknown class>, <Error class: unknown class>) -> Unit): <Error class: unknown class>

Emitted when we receive a message from the peer.

onPong

fun onPong( connectFlags: <Error class: unknown class> = ConnectFlags(0u), handler: (<Error class: unknown class>) -> Unit): <Error class: unknown class>

Emitted when we receive a Pong frame (solicited or unsolicited) from the peer.

sendMessage

fun sendMessage(type: WebsocketDataType, message: <Error class: unknown class>)

Send a message of the given @type to the peer. Note that this method, allows to send text messages containing null characters.

sendText

fun sendText(text: String)

Send a null-terminated text (UTF-8) message to the peer.