2142 lines
74 KiB
C
2142 lines
74 KiB
C
/*
|
||
* This file is part of matrix-glib-sdk
|
||
*
|
||
* matrix-glib-sdk is free software: you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation, either
|
||
* version 3 of the License, or (at your option) any later version.
|
||
*
|
||
* matrix-glib-sdk is distributed in the hope that it will be
|
||
* useful, but WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
* See the GNU Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with matrix-glib-sdk. If not, see
|
||
* <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#include "matrix-api.h"
|
||
|
||
/**
|
||
* SECTION:matrix-api
|
||
* @title: MatrixAPI
|
||
* @short_description: An interface for actual API implementations,
|
||
* like #MatrixHTTPAPI
|
||
*
|
||
* This interface provides a skeleton for all API functionality for
|
||
* client communication with a Matrix.org homeserver.
|
||
**/
|
||
|
||
/**
|
||
* MatrixAPI:
|
||
*
|
||
* An opaque pointer type.
|
||
**/
|
||
|
||
/**
|
||
* MatrixAPIInterface:
|
||
* @get_token: virtual function for matrix_api_get_token()
|
||
* @set_token: virtual function for matrix_api_set_token()
|
||
* @get_refresh_token: virtual function for matrix_api_get_refresh_token()
|
||
* @set_refresh_token: virtual function for matrix_api_set_refresh_token()
|
||
* @get_user_id: virtual function for matrix_api_get_user_id()
|
||
* @get_homeserver: virtual function for matrix_api_get_homeserver()
|
||
* @media_download: virtual function for matrix_api_media_download()
|
||
* @media_thumbnail: virtual function for matrix_api_media_thumbnail()
|
||
* @media_upload: virtual function for matrix_api_media_upload()
|
||
* @get_presence_list: virtual function for matrix_api_get_presence_list()
|
||
* @update_presence_list: virtual function for matrix_api_update_presence_list()
|
||
* @get_user_presence: virtual function for matrix_api_get_user_presence()
|
||
* @set_user_presence: virtual function for matrix_api_set_user_presence()
|
||
* @update_pusher: virtual function for matrix_api_update_pusher()
|
||
* @get_pushers: virtual function for matrix_api_get_pushers()
|
||
* @delete_pusher: virtual function for matrix_api_delete_pusher()
|
||
* @get_pusher: virtual function for matrix_api_get_pusher()
|
||
* @add_pusher: virtual function for matrix_api_add_pusher()
|
||
* @toggle_pusher: virtual function for matrix_api_toggle_pusher()
|
||
* @create_room: virtual function for matrix_api_create_room()
|
||
* @delete_room_alias: virtual function for matrix_api_delete_room_alias()
|
||
* @get_room_id: virtual function for matrix_api_get_room_id()
|
||
* @create_room_alias: virtual function for matrix_api_create_room_alias()
|
||
* @list_public_rooms: virtual function for matrix_api_list_public_rooms()
|
||
* @ban_user: virtual function for matrix_api_ban_user()
|
||
* @forget_room: virtual function for matrix_api_forget_room()
|
||
* @invite_user_3rdparty: virtual function for matrix_api_invite_user_3rdparty()
|
||
* @invite_user: virtual function for matrix_api_invite_user()
|
||
* @join_room: virtual function for matrix_api_join_room()
|
||
* @leave_room: virtual function for matrix_api_leave_room()
|
||
* @event_stream: virtual function for matrix_api_event_stream()
|
||
* @get_event: virtual function for matrix_api_get_event()
|
||
* @initial_sync: virtual function for matrix_api_initial_sync()
|
||
* @get_event_context: virtual function for matrix_api_get_event_context()
|
||
* @initial_sync_room: virtual function for matrix_api_initial_sync_room()
|
||
* @list_room_members: virtual function for matrix_api_list_room_members()
|
||
* @list_room_messages: virtual function for matrix_api_list_room_messages()
|
||
* @send_event_receipt: virtual function for matrix_api_send_event_receipt()
|
||
* @redact_event: virtual function for matrix_api_redact_event()
|
||
* @send_message_event: virtual function for matrix_api_send_message_event()
|
||
* @get_room_state: virtual function for matrix_api_get_room_state()
|
||
* @send_room_event: virtual function for matrix_api_send_room_event()
|
||
* @notify_room_typing: virtual function for matrix_api_notify_room_typing()
|
||
* @sync: virtual function for matrix_api_sync()
|
||
* @create_filter: virtual function for matrix_api_create_filter()
|
||
* @download_filter: virtual function for matrix_api_download_filter()
|
||
* @whois: virtual function for matrix_api_whois()
|
||
* @versions: virtual function for matrix_api_versions()
|
||
* @login: virtual function for matrix_api_login()
|
||
* @token_refresh: virtual function for matrix_api_token_refresh()
|
||
* @get_3pids: virtual function for matrix_api_get_3pids()
|
||
* @add_3pid: virtual function for matrix_api_add_3pid()
|
||
* @change_password: virtual function for matrix_api_change_password()
|
||
* @get_profile: virtual function for matrix_api_get_profile()
|
||
* @get_avatar_url: virtual function for matrix_api_get_avatar_url()
|
||
* @set_avatar_url: virtual function for matrix_api_set_avatar_url()
|
||
* @get_display_name: virtual function for matrix_api_get_display_name()
|
||
* @set_display_name: virtual function for matrix_api_set_display_name()
|
||
* @register_account: virtual function for matrix_api_register_account()
|
||
* @set_account_data: virtual function for matrix_api_set_account_data()
|
||
* @get_room_tags: virtual function for matrix_api_get_room_tags()
|
||
* @delete_room_tag: virtual function for matrix_api_delete_room_tag()
|
||
* @add_room_tag: virtual function for matrix_api_add_room_tag()
|
||
* @get_turn_server: virtual function for matrix_api_get_turn_server()
|
||
*
|
||
* The interface vtable for #MatrixAPI
|
||
*/
|
||
|
||
/**
|
||
* MatrixAPICallback:
|
||
* @api: A #MatrixAPI implementation
|
||
* @content_type: the content_type of the response
|
||
* @json_content: (allow-none): the JSON content of the response, as a
|
||
* #JsonNode
|
||
* @raw_content: (allow-none): the raw content of the response
|
||
* @user_data: User data specified when calling original request function
|
||
* @err: a #GError. It will hold any errors from the underlying API
|
||
* (including communication or type errors)
|
||
*
|
||
* A callback function to use with API calls. Either @json_content or
|
||
* @raw_content will be set.
|
||
*/
|
||
|
||
G_DEFINE_INTERFACE(MatrixAPI, matrix_api, G_TYPE_OBJECT);
|
||
|
||
static void
|
||
matrix_api_default_init(MatrixAPIInterface *iface)
|
||
{
|
||
/**
|
||
* MatrixAPI:token:
|
||
*
|
||
* The token to use for authorization. The matrix_api_login() and
|
||
* matrix_api_register_account() calls must set this
|
||
* automatically.
|
||
*/
|
||
g_object_interface_install_property(
|
||
iface,
|
||
g_param_spec_string("token", "Authorization token",
|
||
"The authorization token to use in requests",
|
||
NULL,
|
||
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
||
|
||
/**
|
||
* MatrixAPI:refresh-token:
|
||
*
|
||
* The token to use for refreshing the authorization token. It is
|
||
* issued by the server after a successful registration, login,
|
||
* and token refresh, but can also be changed with
|
||
* matrix_api_set_refresh_token() (or setting this property).
|
||
*/
|
||
g_object_interface_install_property(
|
||
iface,
|
||
g_param_spec_string("refresh-token", "Refresh token",
|
||
"The token issued by the server for authorization token renewal",
|
||
NULL,
|
||
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
||
|
||
/**
|
||
* MatrixAPI:user-id:
|
||
*
|
||
* The Matrix user ID that is currently authenticated to the
|
||
* server. It is set by the registration and login processes
|
||
* automatically, and cannot be set from outside.
|
||
*/
|
||
g_object_interface_install_property(
|
||
iface,
|
||
g_param_spec_string("user-id", "User ID",
|
||
"The Matrix user ID that is authenticated to the server",
|
||
NULL,
|
||
G_PARAM_READABLE));
|
||
|
||
/**
|
||
* MatrixAPI:homeserver:
|
||
*
|
||
* The Matrix home server, as it calls itself. It is filled
|
||
* automatically by login and register calls.
|
||
*/
|
||
g_object_interface_install_property(
|
||
iface,
|
||
g_param_spec_string("homeserver", "Homeserver",
|
||
"The home server, as it calls itself",
|
||
NULL,
|
||
G_PARAM_READABLE));
|
||
}
|
||
|
||
/* Property getters and setters */
|
||
|
||
/**
|
||
* matrix_api_get_token:
|
||
* @api: a #MatrixAPI implementation
|
||
*
|
||
* Get the authorization token currently set. See
|
||
* matrix_api_set_token() for limitations.
|
||
*
|
||
* Returns: (transfer none) (allow-none): the authorization token that
|
||
* will be used in subsequent requests, or %NULL if none
|
||
* set. The returned value is owned by the @api object and
|
||
* should not be freed nor modified
|
||
*/
|
||
const gchar *
|
||
matrix_api_get_token(MatrixAPI *api)
|
||
{
|
||
g_return_val_if_fail(MATRIX_IS_API(api), NULL);
|
||
|
||
return MATRIX_API_GET_IFACE(api)
|
||
->get_token(api);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_token:
|
||
* @api: a #MatrixAPI implementation
|
||
* @token: the authorization token to set
|
||
*
|
||
* Set the authorization token to use in subsequent requests.
|
||
*
|
||
* <warning><para>Some implementations, like #MatrixHTTPAPI, use
|
||
* asynchronous requests. This means that pending requests will use
|
||
* the old token and thus, may fail because of this.</para></warning>
|
||
*/
|
||
void
|
||
matrix_api_set_token(MatrixAPI *api, const gchar *token)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_token(api, token);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_refresh_token:
|
||
* @api: a #MatrixAPI implementation
|
||
*
|
||
* Get the refresh token currently set. See matrix_api_set_token() for
|
||
* limitations.
|
||
*
|
||
* Returns: (transfer none) (allow-none): the refresh token to be used
|
||
* for authorization token refreshment, or %NULL if there is
|
||
* none set. The returned value is owned by the @api object
|
||
* and should not be freed nor modified
|
||
*/
|
||
const gchar *
|
||
matrix_api_get_refresh_token(MatrixAPI *api)
|
||
{
|
||
g_return_val_if_fail(MATRIX_IS_API(api), NULL);
|
||
|
||
return MATRIX_API_GET_IFACE(api)
|
||
->get_refresh_token(api);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_refresh_token:
|
||
* @api: a #MatrixAPI implementation
|
||
* @refresh_token: the refresh token to set
|
||
*
|
||
* Set the refresh token to be used in subsequent requests. See
|
||
* matrix_api_set_token() for limitations.
|
||
*/
|
||
void
|
||
matrix_api_set_refresh_token(MatrixAPI *api, const gchar *refresh_token)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_refresh_token(api, refresh_token);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_user_id:
|
||
* @api: a #MatrixAPI implementation
|
||
*
|
||
* Get the Matrix user ID that is currently authenticated with the
|
||
* server.
|
||
*
|
||
* Returns: (transfer none) (allow-none): the Matrix user ID
|
||
* authenticated by the last successful register or login
|
||
* call (ie. matrix_api_login() or
|
||
* matrix_api_register_account()). If no user is
|
||
* authenticated, this function returns %NULL. The returned
|
||
* value is owned by the @api object and should not be freed
|
||
* nor modified
|
||
*/
|
||
const gchar *
|
||
matrix_api_get_user_id(MatrixAPI *api)
|
||
{
|
||
g_return_val_if_fail(MATRIX_IS_API(api), NULL);
|
||
|
||
return MATRIX_API_GET_IFACE(api)
|
||
->get_user_id(api);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_homeserver:
|
||
* @api: a #MatrixAPI implementation
|
||
*
|
||
* Get the homeserver's name, as it calls itself. It gets set
|
||
* automatically by login and register calls, e.g. matrix_api_login()
|
||
* or matrix_api_register_account().
|
||
*
|
||
* Returns: (transfer none) (allow-none): the Matrix homeserver's
|
||
* name, as it calls itself. If no homeserver name is reported yet
|
||
* (e.g. because login or register wasn't called yet), this function
|
||
* returns %NULL.
|
||
*/
|
||
const gchar *
|
||
matrix_api_get_homeserver(MatrixAPI *api)
|
||
{
|
||
g_return_val_if_fail(MATRIX_IS_API(api), NULL);
|
||
|
||
return MATRIX_API_GET_IFACE(api)
|
||
->get_homeserver(api);
|
||
}
|
||
|
||
/* Media */
|
||
|
||
/**
|
||
* matrix_api_media_download:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @server_name: the server name from the <code>mxc://</code> URI (the
|
||
* authority component)
|
||
* @media_id: the media ID from the <code>mxc://</code> URI (the path
|
||
* component)
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Download content from the content repository.
|
||
*/
|
||
void
|
||
matrix_api_media_download(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *server_name,
|
||
const gchar *media_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->media_download(api,
|
||
callback, user_data,
|
||
server_name, media_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_media_thumbnail:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @server_name: the server name from the <code>mxc://</code> URI (the
|
||
* authority component)
|
||
* @media_id: the media ID from the <code>mxc://</code> URI (the path
|
||
* component)
|
||
* @width: the desired width of the thumbnail, or 0 to use the default
|
||
* @height: the desired height of the thumbnail, or 0 to use the
|
||
* default
|
||
* @method: the resizing method to use
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Download a thumbnail of the content from the content
|
||
* repository. The actual thumbnail may not match the size specified.
|
||
*/
|
||
void
|
||
matrix_api_media_thumbnail(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *server_name,
|
||
const gchar *media_id,
|
||
guint width,
|
||
guint height,
|
||
MatrixAPIResizeMethod method,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->media_thumbnail(api,
|
||
callback, user_data,
|
||
server_name, media_id,
|
||
width, height, method,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_media_upload:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @content_type: (allow-none): the content type of the file being
|
||
* uploaded
|
||
* @content: (transfer full): the content to be uploaded
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Upload some content to the content repository.
|
||
*/
|
||
void
|
||
matrix_api_media_upload(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *content_type,
|
||
GByteArray *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->media_upload(api, callback, user_data, content_type, content, error);
|
||
}
|
||
|
||
/* Presence */
|
||
|
||
/**
|
||
* matrix_api_get_presence_list:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose presence list should be retrieved
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Retrieve a list of presence events for every user on this list.
|
||
*/
|
||
void
|
||
matrix_api_get_presence_list(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_presence_list(api, callback, user_data, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_update_presence_list:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose presence list is being modified
|
||
* @drop_ids: (element-type utf8): a list of user IDs to remove
|
||
* from the list
|
||
* @invite_ids: (element-type utf8): a list of user IDs to add to
|
||
* the list
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Add or remove users from the specified user's presence list.
|
||
*/
|
||
void
|
||
matrix_api_update_presence_list(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GList *drop_ids,
|
||
GList *invite_ids,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->update_presence_list(api,
|
||
callback, user_data,
|
||
user_id, drop_ids, invite_ids, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_user_presence:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose presence list is being modified
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the given user's presence state.
|
||
*/
|
||
void
|
||
matrix_api_get_user_presence(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_user_presence(api,
|
||
callback, user_data,
|
||
user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_user_presence:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose presence list is being modified
|
||
* @presence: the new presence state
|
||
* @status_message: a status message attached to this state
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Set the given user's presence. You cannot set the presence of
|
||
* another user.
|
||
*/
|
||
void
|
||
matrix_api_set_user_presence(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
MatrixAPIPresence presence,
|
||
const gchar *status_message,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_user_presence(api,
|
||
callback, user_data,
|
||
user_id, presence, status_message,
|
||
error);
|
||
}
|
||
|
||
/* Push notifications */
|
||
|
||
/**
|
||
* matrix_api_update_pusher:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @pusher: the pusher information
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Create, update or delete a pusher for the active user on this
|
||
* homeserver.
|
||
*/
|
||
void
|
||
matrix_api_update_pusher(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
MatrixAPIPusher *pusher,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->update_pusher(api,
|
||
callback, user_data,
|
||
pusher, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_pushers:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Retrieve all push rulesets.
|
||
*/
|
||
void
|
||
matrix_api_get_pushers(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_pushers(api, callback, user_data, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_delete_pusher:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @scope: either <code>global</code> to specify global rules, or
|
||
* <code>device/<profile tag></code> for rules for a
|
||
* given <code>profile tag</code>.
|
||
* @kind: the kind of rule
|
||
* @rule_id: an identifier for the rule
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Delete a push rule.
|
||
*/
|
||
void
|
||
matrix_api_delete_pusher(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *scope,
|
||
MatrixAPIPusherKind kind,
|
||
const gchar *rule_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->delete_pusher(api,
|
||
callback, user_data,
|
||
scope, kind, rule_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_pusher:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @scope: either <code>global</code> to specify global rules, or
|
||
* <code>device/<profile tag></code> for rules for a
|
||
* given <code>profile tag</code>.
|
||
* @kind: the kind of rule
|
||
* @rule_id: an identifier for the rule
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Retrieve a specific push rule.
|
||
*/
|
||
void
|
||
matrix_api_get_pusher(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *scope,
|
||
MatrixAPIPusherKind kind,
|
||
const gchar *rule_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_pusher(api,
|
||
callback, user_data,
|
||
scope, kind, rule_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_add_pusher:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @scope: either <code>global</code> to specify global rules, or
|
||
* <code>device/<profile tag></code> for rules for a
|
||
* given <code>profile tag</code>.
|
||
* @kind: the kind of rule
|
||
* @rule_id: an identifier for the rule
|
||
* @before: (allow-none): make the new rule the next-most important
|
||
* than this rule ID
|
||
* @after: (allow-none): make the new rule the next-less important
|
||
* than this rule ID
|
||
* @actions: (element-type utf8): the actions to perform when the
|
||
* conditions for this rule are met
|
||
* @conditions: (element-type MatrixAPIPusherConditionKind) (allow-none):
|
||
* the conditions that must hold true for an event for a
|
||
* rule to be applied. A rule with no conditions always
|
||
* matches
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Add or change a push rule.
|
||
*/
|
||
void
|
||
matrix_api_add_pusher(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *scope,
|
||
MatrixAPIPusherKind kind,
|
||
const gchar *rule_id,
|
||
const gchar *before,
|
||
const gchar *after,
|
||
GList *actions,
|
||
GList *conditions,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->add_pusher(api,
|
||
callback, user_data,
|
||
scope, kind, rule_id, before, after,
|
||
actions, conditions,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_toggle_pusher:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): a function to call when the
|
||
* request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @scope: either <code>global</code> to specify global rules, or
|
||
* <code>device/<profile tag></code> for rules for a
|
||
* given <code>profile tag</code>.
|
||
* @kind: the kind of rule
|
||
* @rule_id: an identifier for the rule
|
||
* @enabled: if %TRUE, the rule will be enabled, otherwise it gets
|
||
* disabled
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Enable or disable the specified push rule.
|
||
*/
|
||
void matrix_api_toggle_pusher(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *scope,
|
||
MatrixAPIPusherKind kind,
|
||
const gchar *rule_id,
|
||
gboolean enabled,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->toggle_pusher(api,
|
||
callback, user_data,
|
||
scope, kind, rule_id, enabled, error);
|
||
}
|
||
|
||
/* Room creation */
|
||
|
||
/**
|
||
* matrix_api_create_room:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): the function to call when
|
||
* the request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @preset: a room preset to use
|
||
* @room_name: (allow-none): the desired display name for the room
|
||
* @room_alias: (allow-none): an alias of the room
|
||
* @topic: (allow-none): the topic of the room
|
||
* @visibility: the initial visibility of the room
|
||
* @creation_content: (allow-none): extra keys to be added to the
|
||
* content of m.room.create
|
||
* @initial_state: (element-type MatrixAPIStateEvent) (allow-none): A
|
||
* list of state events to set in the new room
|
||
* @invitees: (element-type utf8) (allow-none): list of user IDs to
|
||
* invite to the new room
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Create a new room with the given name and invite the users in
|
||
* @invitees.
|
||
*/
|
||
void
|
||
matrix_api_create_room(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
MatrixAPIRoomPreset preset,
|
||
const gchar *room_name,
|
||
const gchar *room_alias,
|
||
const gchar *topic,
|
||
MatrixAPIRoomVisibility visibility,
|
||
JsonNode *creation_content,
|
||
GList *initial_state,
|
||
GList *invitees,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->create_room(api, callback, user_data,
|
||
preset, room_name, room_alias, topic,
|
||
visibility, creation_content,
|
||
initial_state, invitees,
|
||
error);
|
||
}
|
||
|
||
/* Room directory */
|
||
|
||
/**
|
||
* matrix_api_delete_room_alias:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): the function to call when
|
||
* the request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_alias: the alias name to remove
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Remove the mapping of @room_alias to its room ID
|
||
*
|
||
* Servers may choose to implement additional access control checks
|
||
* here, for instance that room aliases can only be deleted by their
|
||
* creator or a server administrator.
|
||
*/
|
||
void
|
||
matrix_api_delete_room_alias(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_alias,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->delete_room_alias(api, callback, user_data, room_alias, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_room_id:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): the function to call when
|
||
* the request is finished
|
||
* @user_data: (closure) (allow-none): user data to pass to the callback function
|
||
* @room_alias: the room alias
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the room ID corresponding to this room alias.
|
||
*/
|
||
void
|
||
matrix_api_get_room_id(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_alias,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_room_id(api, callback, user_data, room_alias, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_create_room_alias:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): the function to call when
|
||
* the request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to add this alias to
|
||
* @room_alias: the room alias to set
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Create a new mapping from room alias to room ID.
|
||
*/
|
||
void
|
||
matrix_api_create_room_alias(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *room_alias,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->create_room_alias(api,
|
||
callback, user_data,
|
||
room_id, room_alias,
|
||
error);
|
||
}
|
||
|
||
/* Room discovery */
|
||
|
||
/**
|
||
* matrix_api_list_public_rooms:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async) (allow-none): the function to call when
|
||
* the request is finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* List the public rooms on the server.
|
||
*/
|
||
void
|
||
matrix_api_list_public_rooms(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->list_public_rooms(api, callback, user_data, error);
|
||
}
|
||
|
||
/* Room membership */
|
||
|
||
/**
|
||
* matrix_api_ban_user:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID where the user should be banned
|
||
* @user_id: the user ID to ban
|
||
* @reason: (allow-none): the reason of the ban
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Ban the specified user from the specified room. An optional reason
|
||
* can be specified.
|
||
*/
|
||
void
|
||
matrix_api_ban_user(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *user_id,
|
||
const gchar *reason,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->ban_user(api, callback, user_data, room_id, user_id, reason, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_forget_room:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to forget
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Stop the requesting user remembering about a particular room.
|
||
*
|
||
* In general, history is a first class citizen in Matrix. After this
|
||
* API is called, however, a user will no longer be able to retrieve
|
||
* history for this room. If all users on a homeserver forget a room,
|
||
* the room is eligible for deletion from that homeserver.
|
||
*
|
||
* If the user is currently joined to the room, they will implicitly
|
||
* leave the room as part of this API call.
|
||
*/
|
||
void
|
||
matrix_api_forget_room(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->forget_room(api, callback, user_data, room_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_invite_user_3rdparty:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to which to invite the user
|
||
* @address: the invitee's 3rd party identifier
|
||
* @medium: the kind of address being passed in the address field,
|
||
* e.g. <code>email</code>
|
||
* @id_server: the hostname+port of the identity server which should
|
||
* be used for 3rd party identifier lookups
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Invite a user to the room by a 3rd party identifier. They do not
|
||
* start participating in the room until they actually join the room.
|
||
*
|
||
* If the identity server does not know a Matrix user identifier for
|
||
* the passed third party identifier, the homeserver will issue an
|
||
* invitation which can be accepted upon providing proof of ownership
|
||
* of the third party identifier.
|
||
*/
|
||
void matrix_api_invite_user_3rdparty(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *address,
|
||
const gchar *medium,
|
||
const gchar *id_server,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->invite_user_3rdparty(api,
|
||
callback, user_data,
|
||
room_id, address, medium, id_server,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_invite_user:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to invite the user to
|
||
* @user_id: the user ID to invite
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Invite a user to a room.
|
||
*/
|
||
void
|
||
matrix_api_invite_user(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->invite_user(api, callback, user_data, room_id, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_join_room:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to join to
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Join a room.
|
||
*/
|
||
void
|
||
matrix_api_join_room(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->join_room(api, callback, user_data, room_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_leave_room:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to kick the user from
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Leave a room
|
||
*/
|
||
void
|
||
matrix_api_leave_room(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->leave_room(api, callback, user_data, room_id, error);
|
||
}
|
||
|
||
/* Room participation */
|
||
|
||
/**
|
||
* matrix_api_event_stream:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @from_token: (allow-none): events will be listed from this token
|
||
* @timeout: timeout of the request
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the event stream, optionally beginning from @from_token.
|
||
*/
|
||
void
|
||
matrix_api_event_stream(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *from_token,
|
||
gulong timeout,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->event_stream(api, callback, user_data, from_token, timeout, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_event:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @event_id: the event ID to get
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get a single event by event ID.
|
||
*/
|
||
void
|
||
matrix_api_get_event(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *event_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_event(api, callback, user_data, event_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_initial_sync:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @limit: the maximum number of events to get
|
||
* @archived: whether to include rooms that the user has left
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* perform an initial sync of events
|
||
*/
|
||
void
|
||
matrix_api_initial_sync(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
guint limit,
|
||
gboolean archived,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->initial_sync(api, callback, user_data, limit, archived, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_event_context:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room to get events from
|
||
* @event_id: the event to get context around
|
||
* @limit: the maximum number of events to get. If 0, a default value
|
||
* is used (10, according to the specification)
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Gets a number of events that happened just before and after the
|
||
* specified event.
|
||
*/
|
||
void
|
||
matrix_api_get_event_context(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *event_id,
|
||
guint limit,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_event_context(api,
|
||
callback, user_data,
|
||
room_id, event_id, limit, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_initial_sync_room:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room to get the data for
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get a copy of the current state and the most recent messages in a
|
||
* room.
|
||
*/
|
||
void
|
||
matrix_api_initial_sync_room(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->initial_sync_room(api, callback, user_data, room_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_list_room_members:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room to get the member events for
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the list of members for a room.
|
||
*/
|
||
void
|
||
matrix_api_list_room_members(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->list_room_members(api, callback, user_data, room_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_list_room_messages:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room to get the events for
|
||
* @from_token: the token to start returning events from. This token
|
||
* can be obtained by calling matrix_api_initial_sync()
|
||
* or matrix_api_initial_sync_room()
|
||
* @direction: the direction of the returned events
|
||
* @limit: the maximum number of events to return. If 0, a default
|
||
* value will be used (10, according to the specification
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get a list of message and state events for a room.
|
||
*/
|
||
void
|
||
matrix_api_list_room_messages(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *from_token,
|
||
MatrixAPIEventDirection direction,
|
||
guint limit,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->list_room_messages(api,
|
||
callback, user_data,
|
||
room_id, from_token, direction, limit,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_send_event_receipt:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room in which to send the event
|
||
* @receipt_type: type of the receipt
|
||
* @event_id: the event ID to acknowledge up to
|
||
* @receipt: extra receipt information to attach. Note that the server
|
||
* will automatically attach the <code>ts</code> field
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Update the marker for the given receipt type to the event ID specified.
|
||
*/
|
||
void
|
||
matrix_api_send_event_receipt(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
MatrixAPIReceiptType receipt_type,
|
||
const gchar *event_id,
|
||
JsonNode *receipt,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->send_event_receipt(api,
|
||
callback, user_data,
|
||
room_id, receipt_type, event_id, receipt,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_redact_event:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room from which to redact the event
|
||
* @event_id: the event ID to acknowledge up to
|
||
* @txn_id: the transaction ID for this event. Clients should generate
|
||
* a unique ID; it will be used by the server to ensure
|
||
* idempotency of requests
|
||
* @reason: (allow-none): the reason for the event being redacted
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Strip all information out of an event which isn't critical to the
|
||
* integrity of the server-side representation of the room. This
|
||
* cannot be undone.
|
||
*
|
||
* Users may redact their own events, and any user with a power level
|
||
* greater than or equal to <code>redact</code> power level of the
|
||
* room may redact events there.
|
||
*/
|
||
void
|
||
matrix_api_redact_event(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *event_id,
|
||
const gchar *txn_id,
|
||
const gchar *reason,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->redact_event(api,
|
||
callback, user_data,
|
||
room_id, event_id, txn_id, reason,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_send_message_event:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room to send the event to
|
||
* @event_type: the type of event to send
|
||
* @txn_id: the transaction ID for this event. Clients should generate
|
||
* a unique ID; it will be used by the server to ensure
|
||
* idempotency of requests
|
||
* @content: (transfer full): the content of the event as a #JsonNode
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Send a message event to the room.
|
||
*/
|
||
void
|
||
matrix_api_send_message_event(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *event_type,
|
||
const gchar *txn_id,
|
||
JsonNode *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->send_message_event(api,
|
||
callback, user_data,
|
||
room_id,
|
||
event_type, txn_id,
|
||
content, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_room_state:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to get a state for
|
||
* @event_type: (allow-none): the type of state to look up
|
||
* @state_key: (allow-none): the key of the state to look up. If
|
||
* @event_type is %NULL, this parameter is ignored
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Look up the contents of a state event in a room. If both
|
||
* @event_type and @state_key are empty, get a list of state events
|
||
* for that room.
|
||
*/
|
||
void
|
||
matrix_api_get_room_state(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *event_type,
|
||
const gchar *state_key,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_room_state(api,
|
||
callback, user_data,
|
||
room_id, event_type, state_key, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_send_room_event:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @room_id: the room ID to get a state for
|
||
* @event_type: the type of state to look up
|
||
* @state_key: (allow-none): the key of the state to look up. If
|
||
* @event_type is %NULL, this parameter is ignored
|
||
* @content: (transfer full): the content of the state event
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Send a state event to the room. These events will be overwritten if
|
||
* @room_id, @event_type and @state_key all match.
|
||
*
|
||
* This request cannot use transaction IDs.
|
||
*
|
||
* The required fields in the body of the request (@content) vary
|
||
* depending on the type of the event.
|
||
*/
|
||
void
|
||
matrix_api_send_room_event(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *room_id,
|
||
const gchar *event_type,
|
||
const gchar *state_key,
|
||
JsonNode *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->send_room_event(api,
|
||
callback, user_data,
|
||
room_id, event_type, state_key, content,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_notify_room_typing:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user who has started to type
|
||
* @room_id: the room in which the user is typing
|
||
* @timeout: the length of time in milliseconds to mark this user as
|
||
* typing
|
||
* @typing: whether the user is typing or not. If %FALSE, @timeout can
|
||
* be omitted (ie. set to 0)
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Tell the server the user is typing for the next @timeout
|
||
* milliseconds. If @typing is %FALSE, it tells the server that the
|
||
* user stopped typing.
|
||
*/
|
||
void
|
||
matrix_api_notify_room_typing(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *room_id,
|
||
guint timeout,
|
||
gboolean typing,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->notify_room_typing(api,
|
||
callback, user_data,
|
||
user_id, room_id, timeout, typing,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_sync:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @filter_id: (allow-none): a filter ID created by the filter API
|
||
* (e.g. matrix_api_create_filter())
|
||
* @filter: (allow-none): a definition on what events to fetch
|
||
* @since: (allow-none): a point in time to continue a sync from
|
||
* @full_state: if %TRUE, all state events will be returned, even if
|
||
* @since is not empty. If %FALSE, and @since is not
|
||
* empty, only states which have changed since the point
|
||
* indicated by @since will be returned
|
||
* @set_presence: controls whether the client is automatically marked
|
||
* as online by polling this API.
|
||
* @timeout: the maximum time to poll in milliseconds
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Synchronize the client's state with the latest state on the
|
||
* server. Clients should use this API when they first log in to get
|
||
* an initial snapshot of the state on the server and then continue to
|
||
* call this API to get incremental details to the state and to
|
||
* receive new messages.
|
||
*
|
||
* Only one of @filter and @filter_id should be specified, or both of
|
||
* them should be set to %NULL to receive all events.
|
||
*/
|
||
void
|
||
matrix_api_sync(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *filter_id,
|
||
const MatrixAPIFilter *filter,
|
||
const gchar *since,
|
||
gboolean full_state,
|
||
gboolean set_presence,
|
||
gulong timeout,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->sync(api,
|
||
callback, user_data,
|
||
filter_id, filter, since,
|
||
full_state, set_presence, timeout,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_create_filter:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the ID of the user uploading the filter. An access token
|
||
* must be present (either specifying one with
|
||
* matrix_api_set_token() or requested from the server via
|
||
* matrix_api_register_account() or matrix_api_login().
|
||
* @filter: the filter to upload
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Upload a new filter definition to the homeserver. It will return a
|
||
* filter ID that may be used in future requests.
|
||
*/
|
||
void
|
||
matrix_api_create_filter(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
MatrixAPIFilter *filter,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->create_filter(api,
|
||
callback, user_data,
|
||
user_id, filter,
|
||
error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_download_filter:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user ID to download a filter from
|
||
* @filter_id: the filter ID to download
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Download a filter.
|
||
*/
|
||
void
|
||
matrix_api_download_filter(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *filter_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->download_filter(api,
|
||
callback, user_data,
|
||
user_id, filter_id, error);
|
||
}
|
||
|
||
/* Search */
|
||
|
||
/* Server administration */
|
||
|
||
/**
|
||
* matrix_api_whois:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user ID to look up
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get information about a particular user.
|
||
*/
|
||
void
|
||
matrix_api_whois(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->whois(api, callback, user_data, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_versions:
|
||
* @api: a #MatrixAPI iplementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the versions of the specification supported by the server.
|
||
*/
|
||
void
|
||
matrix_api_versions(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->versions(api, callback, user_data, error);
|
||
}
|
||
|
||
/* Session management */
|
||
|
||
/**
|
||
* matrix_api_login:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @login_type: the login type to use
|
||
* @content: (allow-none): parameters to pass for the login request
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Attempt to login with type @type. Implementations of this method
|
||
* must set the token property on a successful login.
|
||
*/
|
||
void
|
||
matrix_api_login(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *login_type,
|
||
const JsonNode *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->login(api, callback, user_data, login_type, content, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_token_refresh:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @refresh_token: (allow-none): the refresh token that was issued by
|
||
* the server
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Exchanges a refresh token for a new access token. This is intended
|
||
* to be used if the access token has expired. If @refresh_token is
|
||
* %NULL, iplementations MUST send the stored refresh token. If it is
|
||
* not pesent (e.g. because login hasn’t happened yet), this function
|
||
* MUST yield an error.
|
||
*/
|
||
void
|
||
matrix_api_token_refresh(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *refresh_token,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->token_refresh(api, callback, user_data, refresh_token, error);
|
||
}
|
||
|
||
/* User data */
|
||
|
||
/**
|
||
* matrix_api_get_3pids:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get a list of the third party identifiers that a homeserver has
|
||
* associated with the user's account.
|
||
*
|
||
* This is not the same as the list of third party identifiers bound
|
||
* to the user's Matrix ID in Identity Servers.
|
||
*
|
||
* Identifiers in this list may be used by the homeserver as, for
|
||
* example, identifiers to accept to reset the user's account
|
||
* password.
|
||
*/
|
||
void
|
||
matrix_api_get_3pids(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_3pids(api, callback, user_data, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_add_3pid:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @bind_creds: whether the homeserver should also bind this third
|
||
* party identifier to the account's Matrix ID with the
|
||
* passed Identity Server.
|
||
* @threepid_creds: the credentials to associate with the account
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Add contact information to the user's account.
|
||
*/
|
||
void
|
||
matrix_api_add_3pid(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
gboolean bind_creds,
|
||
MatrixAPI3PidCredential *threepid_creds,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->add_3pid(api, callback, user_data, bind_creds, threepid_creds, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_change_password:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @new_password: the new password for the account
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Change the active user's password.
|
||
*/
|
||
void
|
||
matrix_api_change_password(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *new_password,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->change_password(api, callback, user_data, new_password, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_profile:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose profile to get
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get a user's profile.
|
||
*/
|
||
void
|
||
matrix_api_get_profile(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_profile(api, callback, user_data, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_avatar_url:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose avatar URL to get
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the URL of the specified user's avatar.
|
||
*/
|
||
void
|
||
matrix_api_get_avatar_url(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_avatar_url(api, callback, user_data, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_avatar_url:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose avatar URL to set
|
||
* @avatar_url: the avatar URL info
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Set the user's avatar URL.
|
||
*/
|
||
void
|
||
matrix_api_set_avatar_url(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *avatar_url,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_avatar_url(api, callback, user_data, user_id, avatar_url, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_display_name:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose display name to get
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get the user's display name.
|
||
*/
|
||
void
|
||
matrix_api_get_display_name(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_display_name(api, callback, user_data, user_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_display_name:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user whose display name to set
|
||
* @display_name: the display name info
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Set the user's display name.
|
||
*/
|
||
void
|
||
matrix_api_set_display_name(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *display_name,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_display_name(api,
|
||
callback, user_data,
|
||
user_id, display_name, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_register_account:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @account_kind: the type of account to register
|
||
* @bind_email: if %TRUE, the server binds the e-mail used for
|
||
* authentication to the Matrix ID with the ID server
|
||
* @username: (allow-none): the local part of the desired Matrix
|
||
* ID. If omitted, the server will generate a local part
|
||
* @password: the desired password for the account
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Attempt to register with type @login_type. Implementations of this
|
||
* method must set the token property on a successful login.
|
||
*/
|
||
void
|
||
matrix_api_register_account(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
MatrixAPIAccountKind account_kind,
|
||
gboolean bind_email,
|
||
const gchar *username,
|
||
const gchar *password,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->register_account(api, callback, user_data, account_kind,
|
||
bind_email, username, password, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_set_account_data:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the user to set account data for. An access token must be
|
||
* present and be authorized to make requests for this user
|
||
* ID
|
||
* @room_id: (allow-none): the room to set account data for. If %NULL,
|
||
* the account data will be set globally
|
||
* @event_type: the event type of the account data to set. Custom
|
||
* types should be namespaced to avoid clashes
|
||
* @content: (transfer full): the content of the account data
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Set some account data for the client. This config is only visible
|
||
* to the user who set the account data. The config will be synced to
|
||
* clients in the top-level account data.
|
||
*/
|
||
void
|
||
matrix_api_set_account_data(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *room_id,
|
||
const gchar *event_type,
|
||
JsonNode *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->set_account_data(api,
|
||
callback, user_data,
|
||
user_id, room_id, event_type, content, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_get_room_tags:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the ID of the user to get the tags for. An access token
|
||
* must be set, and it must be authorised to make requests
|
||
* for this user ID
|
||
* @room_id: the room to get tags for
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* List the tags set by a user on a room.
|
||
*/
|
||
void
|
||
matrix_api_get_room_tags(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *room_id,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_room_tags(api, callback, user_data, user_id, room_id, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_delete_room_tag:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the id of the user to remove a tag for
|
||
* @room_id: the id of the room to remove the tag from
|
||
* @tag: the tag to remove
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Remove a tag from the room.
|
||
*/
|
||
void
|
||
matrix_api_delete_room_tag(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *room_id,
|
||
const gchar *tag,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->delete_room_tag(api,
|
||
callback, user_data,
|
||
user_id, room_id, tag, error);
|
||
}
|
||
|
||
/**
|
||
* matrix_api_add_room_tag:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @user_id: the ID of the user to add the tag for
|
||
* @room_id: the ID of the room to add the tag for
|
||
* @tag: the tag to add
|
||
* @content: (transfer full): extra data for the tag, e.g. ordering
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Add a tag to the room.
|
||
*/
|
||
void
|
||
matrix_api_add_room_tag(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
const gchar *user_id,
|
||
const gchar *room_id,
|
||
const gchar *tag,
|
||
JsonNode *content,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->add_room_tag(api,
|
||
callback, user_data,
|
||
user_id, room_id, tag, content, error);
|
||
}
|
||
|
||
/* VoIP */
|
||
|
||
/**
|
||
* matrix_api_get_turn_server:
|
||
* @api: a #MatrixAPI implementation
|
||
* @callback: (scope async): the function to call when the request is
|
||
* finished
|
||
* @user_data: (closure): user data to pass to the callback function
|
||
* @callback
|
||
* @error: return location for a #GError, or %NULL
|
||
*
|
||
* Get credentials for the client to use when initiating calls.
|
||
*/
|
||
void
|
||
matrix_api_get_turn_server(MatrixAPI *api,
|
||
MatrixAPICallback callback,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
g_return_if_fail(MATRIX_IS_API(api));
|
||
|
||
MATRIX_API_GET_IFACE(api)
|
||
->get_turn_server(api, callback, user_data, error);
|
||
}
|