jsonrpc_client_error_quark ()

GQuark
jsonrpc_client_error_quark (void);

jsonrpc_client_new ()

JsonrpcClient *
jsonrpc_client_new (GIOStream *io_stream);

Creates a new JsonrpcClient instance.

If you want to communicate with a process using stdin/stdout, consider using GSubprocess to launch the process and create a GSimpleIOStream using the g_subprocess_get_stdin_pipe() and g_subprocess_get_stdout_pipe().

Since: 3.26

jsonrpc_client_get_use_gvariant ()

gboolean
jsonrpc_client_get_use_gvariant (JsonrpcClient *self);

Gets the “use-gvariant” property.

Indicates if GVariant is being used to communicate with the peer.

Since: 3.26

jsonrpc_client_set_use_gvariant ()

void
jsonrpc_client_set_use_gvariant (JsonrpcClient *self,
                                 gboolean use_gvariant);

Sets the “use-gvariant” property.

This function sets if GVariant should be used to communicate with the peer. Doing so can allow for more efficient communication by avoiding expensive parsing overhead and memory allocations. However, it requires that the peer also supports GVariant encoding.

Since: 3.26

jsonrpc_client_close ()

gboolean
jsonrpc_client_close (JsonrpcClient *self,
                      GCancellable *cancellable,
                      GError **error);

Closes the underlying streams and cancels any inflight operations of the JsonrpcClient. This is important to call when you are done with the client so that any outstanding operations that have caused self to hold additional references are cancelled.

Failure to call this method results in a leak of JsonrpcClient.

Since: 3.26

jsonrpc_client_close_async ()

void
jsonrpc_client_close_async (JsonrpcClient *self,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

Asynchronous version of jsonrpc_client_close()

Currently this operation is implemented synchronously, but in the future may be converted to using asynchronous operations.

Since: 3.26

jsonrpc_client_close_finish ()

gboolean
jsonrpc_client_close_finish (JsonrpcClient *self,
                             GAsyncResult *result,
                             GError **error);

Completes an asynchronous request of jsonrpc_client_close_async().

Since: 3.26

jsonrpc_client_call ()

gboolean
jsonrpc_client_call (JsonrpcClient *self,
                     const gchar *method,
                     GVariant *params,
                     GCancellable *cancellable,
                     GVariant **return_value,
                     GError **error);

Synchronously calls method with params on the remote peer.

once a reply has been received, or failure, this function will return. If successful, return_value will be set with the reslut field of the response.

If params is floating then this function consumes the reference.

Since: 3.26

jsonrpc_client_call_async ()

void
jsonrpc_client_call_async (JsonrpcClient *self,
                           const gchar *method,
                           GVariant *params,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Asynchronously calls method with params on the remote peer.

Upon completion or failure, callback is executed and it should call jsonrpc_client_call_finish() to complete the request and release any memory held.

If params is floating, the floating reference is consumed.

Since: 3.26

jsonrpc_client_call_finish ()

gboolean
jsonrpc_client_call_finish (JsonrpcClient *self,
                            GAsyncResult *result,
                            GVariant **return_value,
                            GError **error);

Completes an asynchronous call to jsonrpc_client_call_async().

Since: 3.26

jsonrpc_client_send_notification ()

gboolean
jsonrpc_client_send_notification (JsonrpcClient *self,
                                  const gchar *method,
                                  GVariant *params,
                                  GCancellable *cancellable,
                                  GError **error);

Synchronously calls method with params on the remote peer. This function will not wait or expect a reply from the peer.

If params is floating then the reference is consumed.

Since: 3.26

jsonrpc_client_send_notification_async ()

void
jsonrpc_client_send_notification_async
                               (JsonrpcClient *self,
                                const gchar *method,
                                GVariant *params,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously calls method with params on the remote peer. This function will not wait or expect a reply from the peer.

This function is useful when the caller wants to be notified that the bytes have been delivered to the underlying stream. This does not indicate that the peer has received them.

If params is floating then the reference is consumed.

Since: 3.26

jsonrpc_client_send_notification_finish ()

gboolean
jsonrpc_client_send_notification_finish
                               (JsonrpcClient *self,
                                GAsyncResult *result,
                                GError **error);

Completes an asynchronous call to jsonrpc_client_send_notification_async().

Successful completion of this function only indicates that the request has been written to the underlying buffer, not that the peer has received the notification.

Since: 3.26

jsonrpc_client_reply ()

gboolean
jsonrpc_client_reply (JsonrpcClient *self,
                      GVariant *id,
                      GVariant *result,
                      GCancellable *cancellable,
                      GError **error);

Synchronous variant of jsonrpc_client_reply_async().

If id or result are floating, there floating references are consumed.

Since: 3.26

jsonrpc_client_reply_async ()

void
jsonrpc_client_reply_async (JsonrpcClient *self,
                            GVariant *id,
                            GVariant *result,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

jsonrpc_client_reply_finish ()

gboolean
jsonrpc_client_reply_finish (JsonrpcClient *self,
                             GAsyncResult *result,
                             GError **error);

Completes an asynchronous request to jsonrpc_client_reply_async().

Since: 3.26

jsonrpc_client_reply_error_async ()

void
jsonrpc_client_reply_error_async (JsonrpcClient *self,
                                  GVariant *id,
                                  gint code,
                                  const gchar *message,
                                  GCancellable *cancellable,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data);

Asynchronously replies to the peer, sending a JSON-RPC error message.

Call jsonrpc_client_reply_error_finish() to get the result of this operation.

If id is floating, it's floating reference is consumed.

Since: 3.28

jsonrpc_client_reply_error_finish ()

gboolean
jsonrpc_client_reply_error_finish (JsonrpcClient *self,
                                   GAsyncResult *result,
                                   GError **error);

jsonrpc_client_start_listening ()

void
jsonrpc_client_start_listening (JsonrpcClient *self);

This function requests that client start processing incoming messages from the peer.

Since: 3.26

JSONRPC_TYPE_CLIENT

#define JSONRPC_TYPE_CLIENT  (jsonrpc_client_get_type())

JSONRPC_CLIENT_ERROR

#define JSONRPC_CLIENT_ERROR (jsonrpc_client_error_quark())

enum JsonrpcClientError

struct JsonrpcClientClass

struct JsonrpcClientClass {
  GObjectClass parent_class;

  void     (*notification) (JsonrpcClient *self,
                            const gchar   *method_name,
                            GVariant      *params);
  gboolean (*handle_call)  (JsonrpcClient *self,
                            const gchar   *method,
                            GVariant      *id,
                            GVariant      *params);
  void     (*failed)       (JsonrpcClient *self);

  gpointer _reserved2;
  gpointer _reserved3;
  gpointer _reserved4;
  gpointer _reserved5;
  gpointer _reserved6;
  gpointer _reserved7;
  gpointer _reserved8;
};

JsonrpcClient

typedef struct _JsonrpcClient JsonrpcClient;

The “io-stream” property

  “io-stream”                GIOStream *

The "io-stream" property is the GIOStream to use for communicating with a JSON-RPC peer.

Flags: Write / Construct Only

Since: 3.26

The “use-gvariant” property

  “use-gvariant”             gboolean

The "use-gvariant" property denotes if GVariant should be used to communicate with the peer instead of JSON. You should only set this if you know the peer is also a Jsonrpc-GLib based client.

Setting this property allows the peers to communicate using GVariant instead of JSON. This means that we can access the messages without expensive memory allocations and parsing costs associated with JSON. GVariant is much more optimal for memory-bassed message passing.

Flags: Read / Write

Default value: FALSE

Since: 3.26

The “failed” signal

void
user_function (JsonrpcClient *jsonrpcclient,
               gpointer       user_data)

The "failed" signal is called when the client has failed communication or the connection has been knowingly closed.

Flags: Run Last

Since: 3.28

The “handle-call” signal

gboolean
user_function (JsonrpcClient *self,
               gchar         *method,
               GVariant      *id,
               GVariant      *params,
               gpointer       user_data)

This signal is emitted when an RPC has been received from the peer we are connected to. Return TRUE if you have handled this message, even asynchronously. If no handler has returned TRUE an error will be synthesized.

If you handle the message, you are responsible for replying to the peer in a timely manner using jsonrpc_client_reply() or jsonrpc_client_reply_async().

Additionally, since 3.28 you may connect to the "detail" of this signal to handle a specific method call. Use the method name as the detail of the signal.

Flags: Has Details

Since: 3.26

The “notification” signal

void
user_function (JsonrpcClient *self,
               gchar         *method,
               GVariant      *params,
               gpointer       user_data)

This signal is emitted when a notification has been received from a peer. Unlike “handle-call”, this does not have an "id" parameter because notifications do not have ids. They do not round trip.

Flags: Has Details

Since: 3.26