gergely
/
matrix-glib-sdk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
matrix-glib-sdk/src/matrix-types.c

2872 lines
79 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* 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-types.h"
#include "matrix-enumtypes.h"
#include "utils.h"
/**
* SECTION:matrix-types
* @title: Generic types
* @short_description: Generic types for Matrix GLib SDK calls
*
* These are the generic types used by many SDK calls for
* communication with the homeserver.
*/
/**
* MatrixError:
* @MATRIX_ERROR_NONE: no error
* @MATRIX_ERROR_COMMUNICATION_ERROR: there was a problem in
* communication (e.g. connection
* error)
* @MATRIX_ERROR_INCOMPLETE: the passed/generated data is incomplete
* @MATRIX_ERROR_BAD_REQUEST: the request is invalid
* @MATRIX_ERROR_BAD_RESPONSE: malformed response, or the response is
* not a JSON object
* @MATRIX_ERROR_INVALID_ROOM_ID: the provided string doesn’t contain
* a valid room ID
* @MATRIX_ERROR_UNKNOWN_VALUE: the response from the Matrix.org
* server contains a value unknown to
* this library. These should be reported
* to the Matrix GLib SDK developers
* @MATRIX_ERROR_M_MISSING_TOKEN: authorization token is missing from
* the request
* @MATRIX_ERROR_M_FORBIDDEN: access was forbidden (e.g. due to a
* missing/invalid token, or using a bad
* password during login)
* @MATRIX_ERROR_M_UNKNOWN: an error unknown to the Matrix homeserver
* @MATRIX_ERROR_M_UNKNOWN_TOKEN: the token provided is not known for
* the homeserver
* @MATRIX_ERROR_M_NOT_JSON: illegal request, the content is not valid
* JSON
* @MATRIX_ERROR_M_UNRECOGNIZED: the homeserver didn't understand the
* request
* @MATRIX_ERROR_UNSPECIFIED: no error code was sent by the
* homeserver. If you see this error, that
* usually indicates a homeserver bug
* @MATRIX_ERROR_UNKNOWN_ERROR: an error unknown to this library
*
* Value mappings from Matrix.org API error codes
* (e.g. <code>M_MISSING_TOKEN</code>). They should be set
* automatically by API calls, if the response contains an error code.
*/
/**
* MATRIX_ERROR:
*
* Error domain for Matrix GLib SDK. See #GError for more information
* on error domains.
*/
/**
* matrix_error_quark:
*
* Gets the Matrix error #GQuark
*/
G_DEFINE_QUARK(matrix-error-quark, matrix_error);
/**
* MatrixEventFormat:
* @MATRIX_EVENT_FORMAT_DEFAULT: event format will be omitted from the
* filter, so the server will use its
* default (usually
* @MATRIX_EVENT_FORMAT_FEDERATION)
* @MATRIX_EVENT_FORMAT_CLIENT: return the events in a format suitable
* for clients
* @MATRIX_EVENT_FORMAT_FEDERATION: return the raw event as receieved
* over federation
*
* Event format received when synchronizing.
*/
/**
* MatrixRoomPreset:
* @MATRIX_ROOM_PRESET_NONE: no preset
* @MATRIX_ROOM_PRESET_PRIVATE: preset for private rooms
* @MATRIX_ROOM_PRESET_TRUSTED_PRIVATE: same as private rooms, but all
* users get the same power level
* as the room creator
* @MATRIX_ROOM_PRESET_PUBLIC: preset for public rooms
*
* Preset values for matrix_api_create_room() calls.
*/
/**
* MatrixRoomVisibility:
* @MATRIX_ROOM_VISIBILITY_DEFAULT: use a server-assigned value
* (usually <code>private</code>
* @MATRIX_ROOM_VISIBILITY_PUBLIC: make the room visible in the public
* room list
* @MATRIX_ROOM_VISIBILITY_PRIVATE: hide the room from the public room
* list
*
* Visibility values for room creation. Not to be confused with join
* rules.
*/
/**
* MatrixResizeMethod:
* @MATRIX_RESIZE_METHOD_DEFAULT: use the server default value
* @MATRIX_RESIZE_METHOD_CROP: crop thumbnail to the requested size
* @MATRIX_RESIZE_METHOD_SCALE: scale thumbnail to the requested size
*
* Resizing methods for matrix_api_media_thumbnail().
*/
/**
* MatrixPresence:
* @MATRIX_PRESENCE_UNKNOWN: user's presence is unknown
* @MATRIX_PRESENCE_ONLINE: user is online
* @MATRIX_PRESENCE_OFFLINE: user is offline
* @MATRIX_PRESENCE_UNAVAILABLE: user is unavailable (i.e. busy)
* @MATRIX_PRESENCE_FREE_FOR_CHAT: user is free for chat
*
* Presence values for matrix_api_set_user_presence() and other
* presence related queries.
*/
/**
* MatrixPusherKind:
* @MATRIX_PUSHER_KIND_OVERRIDE: highest priority rules
* @MATRIX_PUSHER_KIND_SENDER: for (unencrypted) messages that match
* certain patterns
* @MATRIX_PUSHER_KIND_ROOM: for all messages for a given room. The
* rule ID of a room rule is always the ID
* of the room that it affects
* @MATRIX_PUSHER_KIND_CONTENT: for messages from a specific Matrix
* user ID. The rule ID of such rules is
* always the Matrix ID of the user whose
* messages they'd apply to
* @MATRIX_PUSHER_KIND_UNDERRIDE: lowest priority rules
*
* Pusher types.
*/
/**
* MatrixPusherConditionKind:
* @MATRIX_PUSHER_CONDITION_KIND_EVENT_MATCH: glob pattern match on a
* field of the
* event. Requires a
* <code>key</code> and a
* <code>pattern</code>
* parameter
* @MATRIX_PUSHER_CONDITION_KIND_PROFILE_TAG: matches the profile tag
* of the device that the
* notification would be
* delivered to. Requires a
* <code>profile_tag</code>
* parameter
* @MATRIX_PUSHER_CONDITION_KIND_CONTAINS_DISPLAY_NAME: matches
* unencrypted
* messages where
* the content's
* body contains
* the owner's
* display name
* in that room.
* @MATRIX_PUSHER_CONDITION_KIND_ROOM_MEMBER_COUNT: matches the
* current number of
* members in the
* room. Requires an
* <code>is</code>
* parameter, which
* must be an
* integer,
* optionally
* prefixed by
* <code>==</code>,
* <code>&lt;</code>,
* <code>&gt;</code>,
* <code>&lt;=</code>
* or
* <code>&gt;=</code>. If
* the prefix is
* omitted, it
* defaults to
* <code>==</code>
*
* Condition types for pushers.
*/
/**
* MatrixAccountKind:
* @MATRIX_ACCOUNT_KIND_DEFAULT: use the server default (usually
* %MATRIX_ACCOUNT_KIND_USER)
* @MATRIX_ACCOUNT_KIND_USER: normal user
* @MATRIX_ACCOUNT_KIND_GUEST: guest user
*
* User account types.
*/
/**
* MatrixEventDirection:
* @MATRIX_EVENT_DIRECTION_FORWARD: List events after the specified
* one
* @MATRIX_EVENT_DIRECTION_BACKWARD: List events before the specified
* one
*
* Direction of events when requesting an event context.
*/
/**
* MatrixReceiptType:
* @MATRIX_RECEIPT_TYPE_READ: indicate that the message has been read
*
* Receipt types of acknowledgment.
*/
/**
* MatrixFilterRules: (ref-func matrix_filter_rules_ref) (unref-func matrix_filter_rules_unref)
*
* An opaque structure to hold filter rules that can be used to filter
* events in the event stream. It is possible to filter by event type,
* room and sender ID.
*/
struct _MatrixFilterRules {
guint limit;
GList *rooms;
GList *excluded_rooms;
GList *senders;
GList *excluded_senders;
GList *types;
GList *excluded_types;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixFilterRules, matrix_filter_rules,
(GBoxedCopyFunc)matrix_filter_rules_ref,
(GBoxedFreeFunc)matrix_filter_rules_unref);
/**
* matrix_filter_rules_new:
*
* Create a new #MatrixFilterRules object with reference count of
* 1.
*
* Returns: (transfer full): a new #MatrixFilterRules
*/
MatrixFilterRules *
matrix_filter_rules_new(void)
{
MatrixFilterRules *rules;
rules = g_new0(MatrixFilterRules, 1);
rules->refcount = 1;
return rules;
}
static void
matrix_filter_rules_free(MatrixFilterRules *rules)
{
g_list_free_full(rules->rooms, g_free);
g_list_free_full(rules->excluded_rooms, g_free);
g_list_free_full(rules->senders, g_free);
g_list_free_full(rules->excluded_senders, g_free);
g_list_free_full(rules->types, g_free);
g_list_free_full(rules->excluded_types, g_free);
g_free(rules);
}
/**
* matrix_filter_rules_ref:
* @rules: a #MatrixFilterRules
*
* Increase reference count of @rules by one.
*
* Returns: (transfer none): the same #MatrixFilterRules
*/
MatrixFilterRules *
matrix_filter_rules_ref(MatrixFilterRules *rules)
{
rules->refcount++;
return rules;
}
/**
* matrix_filter_rules_unref:
* @rules: a #MatrixFilterRules
*
* Decrease reference count of @rules by one. If reference count
* reaches zero, @rules is freed.
*/
void
matrix_filter_rules_unref(MatrixFilterRules *rules)
{
if (--rules->refcount == 0) {
matrix_filter_rules_free(rules);
}
}
/**
* matrix_filter_rules_set_limit:
* @rules: a #MatrixFilterRules
* @limit: (in): the maximum number of events to return.
*
* Set the maximum number of events to return by the filter. If @limit
* is <code>0</code>, no limit will be applied.
*/
void
matrix_filter_rules_set_limit(MatrixFilterRules *rules, guint limit)
{
rules->limit = limit;
}
/**
* matrix_filter_rules_get_limit:
* @rules: a #MatrixFilterRules
*
* Get the current limit set in @rules.
*
* Returns: the limit currently set
*/
guint
matrix_filter_rules_get_limit(MatrixFilterRules *rules)
{
return rules->limit;
}
/**
* matrix_filter_rules_set_senders:
* @rules: a #MatrixFilterRules
* @senders: (in) (element-type utf8) (transfer full) (allow-none):
* a list of Matrix user IDs. Events from these users will
* be included in the filtered event list.If %NULL then all
* senders are included. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Set the list of user IDs to include in the filtered events. @rules
* takes ownership of @senders, so it should not be freed nor modified
* directly after this call.
*/
void
matrix_filter_rules_set_senders(MatrixFilterRules *rules, GList *senders)
{
g_list_free_full(rules->senders, g_free);
rules->senders = senders;
}
/**
* matrix_filter_rules_add_sender:
* @rules: a #MatrixFilterRules
* @sender: (in): a Matrix user ID to add to the included senders
* list. A <code>*</code> can be used as a wildcard to match
* any sequence of characters
*
* Add @sender to the list of user IDs to include in the filtered
* event list. If @sender is already included in the senders list,
* nothing happens.
*/
void
matrix_filter_rules_add_sender(MatrixFilterRules *rules, const gchar *sender)
{
g_return_if_fail(sender != NULL);
if (!g_list_find_custom(rules->senders, sender, (GCompareFunc)g_strcmp0)) {
rules->senders = g_list_prepend(rules->senders, g_strdup(sender));
}
}
/**
* matrix_filter_rules_delete_sender:
* @rules: a #MatrixFilterRules
* @sender: (in): the user ID to remove from the senders list
*
* Remove @sender from the list of user IDs to include in the filtered
* event list.
*/
void
matrix_filter_rules_delete_sender(MatrixFilterRules *rules, const gchar *sender)
{
GList *sender_element;
g_return_if_fail(sender != NULL);
while ((sender_element = g_list_find_custom(rules->senders, sender,
(GCompareFunc)g_strcmp0))) {
rules->senders = g_list_remove_link(rules->senders, sender_element);
g_list_free_full(sender_element, g_free);
}
}
/**
* matrix_filter_rules_get_senders:
* @rules: a #MatrixFilterRules
*
* Get the list of user IDs that will be included in the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of user IDs. The returned value is owned by @rules
* and should not be freed nor modified
*/
const GList *
matrix_filter_rules_get_senders(MatrixFilterRules *rules)
{
return rules->senders;
}
/**
* matrix_filter_rules_set_excluded_senders:
* @rules: a #MatrixFilterRules
* @senders: (in) (element-type utf8) (transfer full) (allow-none): a
* list of Matrix user IDs. Events from these users will be
* included in the filtered event list.If %NULL then all
* senders are included. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Set the list of Matrix user IDs to exclude from the filtered
* events. A matching sender will be excluded even if it is listed in
* the senders list (specified by
* e.g. matrix_filter_rules_set_senders()). @rules takes ownership of
* @senders, so it should not be freed nor modified directly after
* this call.
*/
void
matrix_filter_rules_set_excluded_senders(MatrixFilterRules *rules,
GList *senders)
{
g_list_free_full(rules->excluded_senders, g_free);
rules->excluded_senders = senders;
}
/**
* matrix_filter_rules_add_excluded_sender:
* @rules: a #MatrixFilterRules
* @sender: (in): a Matrix user ID to add to the excluded senders
* list. See matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Add @sender to the list of user IDs to exclude from the filtered
* event list. If @sender is already in the excluded senders list,
* nothing happens.
*/
void
matrix_filter_rules_add_excluded_sender(MatrixFilterRules *rules,
const gchar *sender)
{
g_return_if_fail(sender != NULL);
if (!g_list_find_custom(rules->excluded_senders, sender,
(GCompareFunc)g_strcmp0)) {
rules->excluded_senders = g_list_prepend(rules->excluded_senders,
g_strdup(sender));
}
}
/**
* matrix_filter_rules_delete_excluded_sender:
* @rules: a #MatrixFilterRules
* @sender: (in): the Matrix user ID to remove from the excluded
* senders list
*
* Remove @sender from the list of user IDs to exclude from the
* filtered event list.
*/
void
matrix_filter_rules_delete_excluded_sender(MatrixFilterRules *rules,
const gchar *sender)
{
GList *sender_element;
g_return_if_fail(sender != NULL);
while ((sender_element = g_list_find_custom(rules->excluded_senders, sender,
(GCompareFunc)g_strcmp0))) {
rules->excluded_senders = g_list_remove_link(rules->excluded_senders,
sender_element);
g_list_free_full(sender_element, g_free);
}
}
/**
* matrix_filter_rules_get_excluded_senders:
* @rules: a #MatrixFilterRules
*
* Get the list of user IDs that will be excluded in the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of user IDs to be excluded. The returned value is
* owned by @rules and should not be freed nor modified.
*/
const GList *
matrix_filter_rules_get_excluded_senders(MatrixFilterRules *rules)
{
return rules->excluded_senders;
}
/**
* matrix_filter_rules_set_rooms:
* @rules: a #MatrixFilterRules
* @rooms: (in) (element-type utf8) (transfer full) (allow-none): a
* list of room IDs. Events from these rooms will be included
* in the filtered event list.If %NULL then all rooms are
* included. See matrix_filter_rules_add_sender() for
* wildcarding possibilities
*
* Set the list of room IDs to include in the filtered events. @rules
* takes ownership of @rooms, so it should not be freed nor modified
* directly after this call.
*/
void
matrix_filter_rules_set_rooms(MatrixFilterRules *rules, GList *rooms)
{
g_list_free_full(rules->rooms, g_free);
rules->rooms = rooms;
}
/**
* matrix_filter_rules_add_room:
* @rules: a #MatrixFilterRules
* @room: (in): a room ID to add to the included rooms list. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Add @room to the list of room IDs to include in the filtered
* event list. If @room is already included in the rooms list,
* nothing happens.
*/
void
matrix_filter_rules_add_room(MatrixFilterRules *rules, const gchar *room)
{
g_return_if_fail(room != NULL);
if (!g_list_find_custom(rules->rooms, room, (GCompareFunc)g_strcmp0)) {
rules->rooms = g_list_prepend(rules->rooms, g_strdup(room));
}
}
/**
* matrix_filter_rules_delete_room:
* @rules: a #MatrixFilterRules
* @room: (in): the room ID to remove from the rooms list
*
* Remove @room from the list of room IDs to include in the filtered
* event list.
*/
void
matrix_filter_rules_delete_room(MatrixFilterRules *rules, const gchar *room)
{
GList *room_element;
g_return_if_fail(room != NULL);
while ((room_element = g_list_find_custom(rules->rooms, room,
(GCompareFunc)g_strcmp0))) {
rules->rooms = g_list_remove_link(rules->rooms, room_element);
g_list_free_full(room_element, g_free);
}
}
/**
* matrix_filter_rules_get_rooms:
* @rules: a #MatrixFilterRules
*
* Get the list of room IDs that will be included in the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of room IDs. The returned value is owned by @rules
* and should not be freed nor modified
*/
const GList *
matrix_filter_rules_get_rooms(MatrixFilterRules *rules)
{
return rules->rooms;
}
/**
* matrix_filter_rules_set_excluded_rooms:
* @rules: a #MatrixFilterRules
* @rooms: (in) (element-type utf8) (transfer full) (allow-none): a
* list of room IDs. Events from these rooms will be included
* in the filtered event list.If %NULL, then all rooms are
* included. See matrix_filter_rules_add_sender() for
* wildcarding possibilities
*
* Set the list of room IDs to exclude from the filtered events. A
* matching room will be excluded even if it is listed in the rooms
* list (specified by e.g. matrix_filter_rules_set_rooms()). @rules
* takes ownership of @rooms, so it should not be freed nor modified
* directly after this call.
*/
void
matrix_filter_rules_set_excluded_rooms(MatrixFilterRules *rules, GList *rooms)
{
g_list_free_full(rules->excluded_rooms, g_free);
rules->excluded_rooms = rooms;
}
/**
* matrix_filter_rules_add_excluded_room:
* @rules: a #MatrixFilterRules
* @room: (in): a room ID to add to the excluded rooms list. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Add @room to the list of room IDs to exclude from the filtered
* event list. If @room is already in the excluded rooms list, nothing
* happens.
*/
void
matrix_filter_rules_add_excluded_room(MatrixFilterRules *rules,
const gchar *room)
{
g_return_if_fail(room != NULL);
if (!g_list_find_custom(rules->excluded_rooms, room,
(GCompareFunc)g_strcmp0)) {
rules->excluded_rooms = g_list_prepend(rules->excluded_rooms,
g_strdup(room));
}
}
/**
* matrix_filter_rules_delete_excluded_room:
* @rules: a #MatrixFilterRules
* @room: (in): the room ID to remove from the excluded rooms list
*
* Remove @room from the list of room IDs to exclude from the filtered
* event list.
*/
void
matrix_filter_rules_delete_excluded_room(MatrixFilterRules *rules,
const gchar *room)
{
GList *room_element;
g_return_if_fail(room != NULL);
while ((room_element = g_list_find_custom(rules->excluded_rooms, room,
(GCompareFunc)g_strcmp0))) {
rules->excluded_rooms = g_list_remove_link(rules->excluded_rooms,
room_element);
g_list_free_full(room_element, g_free);
}
}
/**
* matrix_filter_rules_get_excluded_rooms:
* @rules: a #MatrixFilterRules
*
* Get the list of room IDs that will be excluded in the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of room IDs to be excluded. The returned value is
* owned by @rules and should not be freed nor modified.
*/
const GList *
matrix_filter_rules_get_excluded_rooms(MatrixFilterRules *rules)
{
return rules->excluded_rooms;
}
/**
* matrix_filter_rules_set_types:
* @rules: a #MatrixFilterRules
* @types: (in) (element-type utf8) (transfer full) (allow-none): a
* list of event types to include. If %NULL then all event
* types are included. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Set the list of event types to be included in the filtered events.
*/
void
matrix_filter_rules_set_types(MatrixFilterRules *rules, GList *types)
{
g_list_free_full(rules->types, g_free);
rules->types = types;
}
/**
* matrix_filter_rules_add_type:
* @rules: a #MatrixFilterRules
* @type: (in): an event type to add to the list of included
* events. See matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Add @type to the list of event types to include in the filtered
* event list. If @type is already included in the types list, nothing
* happens.
*/
void
matrix_filter_rules_add_type(MatrixFilterRules *rules, const gchar *event_type)
{
g_return_if_fail(event_type != NULL);
if (g_list_find_custom(rules->types, event_type, (GCompareFunc)g_strcmp0)) {
rules->types = g_list_prepend(rules->types, g_strdup(event_type));
}
}
/**
* matrix_filter_rules_delete_type:
* @rules: a #MatrixFilterRules
* @type: (in): a type to remove from the list of included event
* types. See matrix_filter_rules_add_sender() for
* wildcarding possibilities
*
* Remove @type from the list of excluded event type list.
*/
void
matrix_filter_rules_delete_type(MatrixFilterRules *rules,
const gchar *event_type)
{
GList *type_element;
g_return_if_fail(event_type != NULL);
while ((type_element = g_list_find_custom(rules->types, event_type,
(GCompareFunc)g_strcmp0))) {
rules->types = g_list_remove_link(rules->types, type_element);
g_list_free_full(type_element, g_free);
}
}
/**
* matrix_filter_rules_get_types:
* @rules: a #MatrixFilterRules
*
* Get the list of event types that will be included in the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of event types. The returned values is owned by
* @rules and should not be freed nor modified
*/
const GList *
matrix_filter_rules_get_types(MatrixFilterRules *rules)
{
return rules->types;
}
/**
* matrix_filter_rules_set_excluded_types:
* @rules: a #MatrixFilterRules
* @types: (in) (element-type utf8) (transfer full) (allow-none): a
* list of event types to exclude. If %NULL then no event
* types are excluded. A matching type will be excluded even
* if it is listed in the included types. See
* matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Set the list of event types to be excluded from the filtered
* events. A matching type will be excluded even if it is listed in
* the types list (specified by
* e.g. matrix_filter_rules_set_types()).
*/
void
matrix_filter_rules_set_excluded_types(MatrixFilterRules *rules, GList *types)
{
g_list_free_full(rules->excluded_types, g_free);
rules->excluded_types = types;
}
/**
* matrix_filter_rules_add_excluded_type:
* @rules: a #MatrixFilterRules
* @type: (in): an event type to add to the excluded event type
* list. See matrix_filter_rules_add_sender() for wildcarding
* possibilities
*
* Add @type to the list of excluded event types.
*/
void
matrix_filter_rules_add_excluded_type(MatrixFilterRules *rules,
const gchar *event_type)
{
g_return_if_fail(event_type != NULL);
if (!g_list_find_custom(rules->excluded_types, event_type,
(GCompareFunc)g_strcmp0)) {
rules->excluded_types = g_list_prepend(rules->excluded_types,
g_strdup(event_type));
}
}
/**
* matrix_filter_rules_delete_excluded_type:
* @rules: a #MatrixFilterRules
* @type: (in): the event type to be removed from the excluded types
* list
*
* Remove @type from the list of event types to be excluded from the
* filtered event list.
*/
void
matrix_filter_rules_delete_excluded_type(MatrixFilterRules *rules,
const gchar *event_type)
{
GList *type_element;
g_return_if_fail(event_type != NULL);
while ((type_element = g_list_find_custom(rules->excluded_types, event_type,
(GCompareFunc)g_strcmp0))) {
rules->excluded_types = g_list_remove_link(rules->excluded_types,
type_element);
g_list_free_full(type_element, g_free);
}
}
/**
* matrix_filter_rules_get_excluded_types:
* @rules: a #MatrixFilterRules
*
* Get the list of event types that will be excluded from the filtered
* events.
*
* Returns: (element-type utf8) (allow-none) (transfer none): the
* list of event types. The returned value is owned by
* @rules and should not be freed nor modified
*/
const GList *
matrix_filter_rules_get_excluded_types(MatrixFilterRules *rules)
{
return rules->excluded_types;
}
static void
json_add_string(gchar *str, JsonBuilder *builder)
{
json_builder_add_string_value(builder, str);
}
/**
* matrix_filter_rules_get_json_node:
* @rules: a #MatrixFilterRules
*
* Gets the #JsonNode representation of this filtering ruleset.
*
* Returns: (transfer full): the JSON representation of the filtering
* data as a #JsonNode
*/
JsonNode *
matrix_filter_rules_get_json_node(MatrixFilterRules *rules)
{
JsonBuilder *builder;
JsonNode *node;
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "limit");
json_builder_add_int_value(builder, rules->limit);
if (rules->rooms) {
json_builder_set_member_name(builder, "rooms");
json_builder_begin_array(builder);
g_list_foreach(rules->rooms, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
if (rules->excluded_rooms) {
json_builder_set_member_name(builder, "not_rooms");
json_builder_begin_array(builder);
g_list_foreach(rules->excluded_rooms, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
if (rules->senders) {
json_builder_set_member_name(builder, "senders");
json_builder_begin_array(builder);
g_list_foreach(rules->senders, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
if (rules->excluded_senders) {
json_builder_set_member_name(builder, "not_senders");
json_builder_begin_array(builder);
g_list_foreach(rules->excluded_senders,
(GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
if (rules->types) {
json_builder_set_member_name(builder, "types");
json_builder_begin_array(builder);
g_list_foreach(rules->types, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
if (rules->excluded_types) {
json_builder_set_member_name(builder, "not_types");
json_builder_begin_array(builder);
g_list_foreach(rules->excluded_types, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
}
json_builder_end_object(builder);
node = json_builder_get_root(builder);
g_object_unref(builder);
return node;
}
/**
* matrix_filter_rules_get_json_data:
* @rules: a #MatrixFilterRules
* @datalen: (out): storage for the the length of the JSON data or
* %NULL
*
* Gets the string representation of these filtering rules, as a JSON
* object.
*
* Returns: (transfer full): the JSON representation of the filtering
* rule data as a string
*/
gchar *
matrix_filter_rules_get_json_data(MatrixFilterRules *rules, gsize *datalen)
{
JsonGenerator *generator;
JsonNode *node = matrix_filter_rules_get_json_node(rules);
gchar *data;
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* MatrixRoomFilter:
*
* An opaque structure to hold room filters.
*/
struct _MatrixRoomFilter {
gboolean include_leave;
MatrixFilterRules *ephemeral;
MatrixFilterRules *state;
MatrixFilterRules *timeline;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixRoomFilter, matrix_room_filter,
(GBoxedCopyFunc)matrix_room_filter_ref,
(GBoxedFreeFunc)matrix_room_filter_unref);
/**
* matrix_room_filter_new:
*
* Create a new #MatrixRoomFilter object with reference count of 1.
*
* Returns: (transfer full): a new #MatrixRoomFilter
*/
MatrixRoomFilter *
matrix_room_filter_new(void)
{
MatrixRoomFilter *filter;
filter = g_new0(MatrixRoomFilter, 1);
filter->refcount = 1;
return filter;
}
static void
matrix_room_filter_free(MatrixRoomFilter *filter)
{
if (filter->ephemeral) {
matrix_filter_rules_unref(filter->ephemeral);
}
if (filter->state) {
matrix_filter_rules_unref(filter->state);
}
if (filter->timeline) {
matrix_filter_rules_unref(filter->timeline);
}
g_free(filter);
}
/**
* matrix_room_filter_ref:
* @filter: a #MatrixRoomFilter
*
* Increase reference count of @filter by one.
*
* Returns: (transfer none): the same #MatrixRoomFilter
*/
MatrixRoomFilter *
matrix_room_filter_ref(MatrixRoomFilter *filter)
{
filter->refcount++;
return filter;
}
/**
* matrix_room_filter_unref:
* @filter: a #MatrixRoomFilter
*
* Decrease reference count of @filter by one. If reference count
* reaches zero, @filter is freed.
*/
void
matrix_room_filter_unref(MatrixRoomFilter *filter)
{
if (--filter->refcount == 0) {
matrix_room_filter_free(filter);
}
}
/**
* matrix_room_filter_set_include_leave:
* @filter: a #MatrixRoomFilter
* @include_leave: %TRUE if events from left rooms should be included
*
* Sets if events for rooms that the user has left should be included
* in the filtered event list.
*/
void
matrix_room_filter_set_include_leave(MatrixRoomFilter *filter,
gboolean include_leave)
{
filter->include_leave = include_leave;
}
/**
* matrix_room_filter_get_include_leave:
* @filter: a #MatrixRoomFilter
*
* If %TRUE, events from rooms that the user has left will be included
* in the filtered event list.
*
* Returns: the value of <code>include_leave</code>
*/
gboolean
matrix_room_filter_get_include_leave(MatrixRoomFilter *filter)
{
return filter->include_leave;
}
/**
* matrix_room_filter_set_ephemeral:
* @filter: a #MatrixRoomFilter
* @rules: (transfer none): filtering rules for ephemeral events
*
* Set filtering rules for ephemeral events, i.e. events that are not
* recorded in the room history (typing notifications, receipts, etc.)
* @filter gets a reference on @rules, so the caller may unref it.
*/
void
matrix_room_filter_set_ephemeral(MatrixRoomFilter *filter,
MatrixFilterRules *rules)
{
if (filter->ephemeral) {
matrix_filter_rules_unref(filter->ephemeral);
}
filter->ephemeral = matrix_filter_rules_ref(rules);
}
/**
* matrix_room_filter_get_ephemeral:
* @filter: a #MatrixRoomFilter
*
* Gets the filtering rules for ephemeral events. See
* matrix_room_filter_set_ephemeral() for details.
*
* Returns: (transfer none): the filtering rules for ephemeral events.
*/
MatrixFilterRules *
matrix_room_filter_get_ephemeral(MatrixRoomFilter *filter)
{
return filter->ephemeral;
}
/**
* matrix_room_filter_set_state:
* @filter: a #MatrixRoomFilter
* @rules: (transfer none): filtering rules for state events
*
* Sets filtering rules for state events. @filter obtains a reference
* on @rules, so the caller may unref it safely.
*/
void
matrix_room_filter_set_state(MatrixRoomFilter *filter, MatrixFilterRules *rules)
{
if (filter->state) {
matrix_filter_rules_unref(filter->state);
}
filter->state = matrix_filter_rules_ref(rules);
}
/**
* matrix_room_filter_get_state:
* @filter: a #MatrixRoomFilter
*
* Gets the filtering rules for state events.
*
* Returns: (transfer none): the filtering rules for state events
*/
MatrixFilterRules *
matrix_room_filter_get_state(MatrixRoomFilter *filter)
{
return filter->state;
}
/**
* matrix_room_filter_set_timeline:
* @filter: a #MatrixRoomFilter
* @rules: (transfer none): filtering rules for timeline events
* (messages and state events from rooms)
*
* Set filtering rules for timeline events.
*/
void
matrix_room_filter_set_timeline(MatrixRoomFilter *filter,
MatrixFilterRules *rules)
{
if (filter->timeline) {
matrix_filter_rules_unref(filter->timeline);
}
filter->timeline = matrix_filter_rules_ref(rules);
}
/**
* matrix_room_filter_get_timeline:
* @filter: a #MatrixRoomFilter
*
* Gets filtering rules for timeline events (see
* matrix_room_filter_set_timeline() for details.
*
* Returns: (transfer none): the filtering rules for timeline events
*/
MatrixFilterRules *
matrix_room_filter_get_timeline(MatrixRoomFilter *filter)
{
return filter->timeline;
}
/**
* matrix_room_filter_get_json_node:
* @filter: a #MatrixRoomFilter
*
* Gets the #JsonNode representation of the filtering ruleset.
*
* Returns: (transfer full): the JSON representation of the filtering
* ruleset as a #JsonNode
*/
JsonNode *
matrix_room_filter_get_json_node(MatrixRoomFilter *filter)
{
JsonBuilder *builder;
JsonNode *node;
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "include_leave");
json_builder_add_boolean_value(builder, filter->include_leave);
if (filter->ephemeral) {
json_builder_set_member_name(builder, "ephemeral");
json_builder_add_value(builder,
matrix_filter_rules_get_json_node(
filter->ephemeral));
}
if (filter->state) {
json_builder_set_member_name(builder, "state");
json_builder_add_value(builder,
matrix_filter_rules_get_json_node(
filter->state));
}
if (filter->timeline) {
json_builder_set_member_name(builder, "timeline");
json_builder_add_value(builder,
matrix_filter_rules_get_json_node(
filter->timeline));
}
json_builder_end_object(builder);
node = json_builder_get_root(builder);
g_object_unref(builder);
return node;
}
/**
* matrix_room_filter_get_json_data:
* @filter: a #MatrixRoomFilter
* @datalen: (out) (allow-none): storage for the length of the JSON
* data, or %NULL
*
* Get the string representation of the filtering ruleset as a JSON
* object.
*
* Returns: the JSON object representation of the filtering ruleset
* data as a string
*/
gchar *
matrix_room_filter_get_json_data(MatrixRoomFilter *filter, gsize *datalen)
{
JsonGenerator *generator;
JsonNode *node = matrix_room_filter_get_json_node(filter);
gchar *data;
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* MatrixFilter:
*
* An opaque structure to hold an event filter.
*/
struct _MatrixFilter {
GList *event_fields;
MatrixEventFormat event_format;
MatrixFilterRules *presence;
MatrixRoomFilter *room;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixFilter, matrix_filter,
(GBoxedCopyFunc)matrix_filter_ref,
(GBoxedFreeFunc)matrix_filter_unref);
/**
* matrix_filter_new:
*
* Create a new #MatrixFilter object with reference count of 1.
*
* Returns: (transfer full): a new #MatrixFilter
*/
MatrixFilter *
matrix_filter_new(void)
{
MatrixFilter *filter;
filter = g_new0(MatrixFilter, 1);
filter->refcount = 1;
return filter;
}
static void
matrix_filter_free(MatrixFilter *filter)
{
g_list_free_full(filter->event_fields, g_free);
if (filter->presence) {
matrix_filter_rules_unref(filter->presence);
}
if (filter->room) {
matrix_room_filter_unref(filter->room);
}
g_free(filter);
}
/**
* matrix_filter_ref:
* @filter: a #MatrixFilter
*
* Increase reference count of @filter by one.
*
* Returns: (transfer none): the same #MatrixFilter
*/
MatrixFilter *
matrix_filter_ref(MatrixFilter *filter)
{
filter->refcount++;
return filter;
}
/**
* matrix_filter_unref:
* @filter: a #MatrixFilter
*
* Decrease reference count of @filter by one. If reference count
* reaches zero, @filter is freed.
*/
void
matrix_filter_unref(MatrixFilter *filter)
{
if (--filter->refcount == 0) {
matrix_filter_free(filter);
}
}
/**
* matrix_filter_set_event_fields:
* @filter: a #MatrixFilter
* @event_fields: (in) (element-type utf8) (transfer full) (allow-none):
* a list of event fields to include. If %NULL then all
* fields are included. The entries may include
* <code>.</code> charaters to indicate sub-fields. So
* <code>['content.body']</code> will include the
* <code>body</code> field of the <code>content</code>
* object. A literal <code>.</code> character in a
* field name may be escaped using a <code>\</code>. A
* server may include more fields than were requested
*
* Set the event fields to include in the filtered events.
*/
void
matrix_filter_set_event_fields(MatrixFilter *filter, GList *event_fields)
{
g_list_free_full(filter->event_fields, g_free);
filter->event_fields = event_fields;
}
/**
* matrix_filter_add_event_field:
* @filter: a #MatrixFilter
* @event_field: an event field to add to the list. See
* matrix_filter_set_event_fields() for details
*
* Add an event field to the list of fields that will be present in
* the filtered events.
*/
void
matrix_filter_add_event_field(MatrixFilter *filter, const gchar *event_field)
{
g_return_if_fail(event_field != NULL);
if (!g_list_find_custom(filter->event_fields, event_field,
(GCompareFunc)g_strcmp0)) {
filter->event_fields = g_list_prepend(filter->event_fields,
g_strdup(event_field));
}
}
/**
* matrix_filter_delete_event_field:
* @filter: a #MatrixFilter
* @event_field: an event field to remove from the list
*
* Remove @event_field from the list of fields that will be present in
* the filtered events.
*/
void
matrix_filter_delete_event_field(MatrixFilter *filter, const gchar *event_field)
{
GList *event_field_element;
g_return_if_fail(event_field != NULL);
while ((event_field_element = g_list_find_custom(filter->event_fields,
event_field,
(GCompareFunc)g_strcmp0))) {
filter->event_fields = g_list_remove_link(filter->event_fields,
event_field_element);
g_list_free_full(event_field_element, g_free);
}
}
/**
* matrix_filter_get_event_fields:
* @filter: a #MatrixFilter
*
* Get the list of event fields that will be present in the filtered
* events.
*
* Returns: (transfer none) (element-type utf8) (allow-none): the list
* of event fields. The returned value is owned by @filter
* and should not be freed nor modified.
*/
const GList *
matrix_filter_get_event_fields(MatrixFilter *filter)
{
return filter->event_fields;
}
/**
* matrix_filter_set_event_format:
* @filter: a #MatrixFilter
* @event_format: the desired event format for filtered events
*
* Set the desired event format for the filtered events (e.g. for
* matrix_api_sync())
*/
void
matrix_filter_set_event_format(MatrixFilter *filter,
MatrixEventFormat event_format)
{
filter->event_format = event_format;
}
/**
* matrix_filter_get_event_format:
* @filter: a #MatrixFilter
*
* Get the desired event format set in @filter.
*
* Returns: the event format currently set
*/
MatrixEventFormat
matrix_filter_get_event_format(MatrixFilter *filter)
{
return filter->event_format;
}
/**
* matrix_filter_set_presence_filter:
* @filter: a #MatrixFilter
* @presence_filter: (transfer none): the desired filters to use
*
* Set a filtering ruleset for presence events.
*/
void
matrix_filter_set_presence_filter(MatrixFilter *filter,
MatrixFilterRules *presence_filter)
{
if (filter->presence) {
matrix_filter_rules_unref(filter->presence);
}
filter->presence = matrix_filter_rules_ref(presence_filter);
}
/**
* matrix_filter_get_presence_filter:
* @filter: a #MatrixFilter
*
* Get the current filtering ruleset for presence events.
*
* Returns: (transfer none): the current ruleset. The returned value
* is owned by @filter; if the callee wants to use it
* separately, it should create a reference for it
*/
MatrixFilterRules *
matrix_filter_get_presence_filter(MatrixFilter *filter)
{
return filter->presence;
}
/**
* matrix_filter_set_room_filter:
* @filter: a #MatrixFilter
* @room_filter: the desired room filters to use in @filter
*
* Set a new filtering ruleset for room events in @filter.
*/
void
matrix_filter_set_room_filter(MatrixFilter *filter,
MatrixRoomFilter *room_filter)
{
if (filter->room) {
matrix_room_filter_unref(filter->room);
}
filter->room = matrix_room_filter_ref(room_filter);
}
/**
* matrix_filter_get_room_filter:
* @filter: a #MatrixFilter
*
* Get the filtering ruleset for room events in @filter.
*
* Returns: (transfer none): the current filtering ruleset for room
* events
*/
MatrixRoomFilter *
matrix_filter_get_room_filter(MatrixFilter *filter)
{
return filter->room;
}
/**
* matrix_filter_get_json_node:
* @filter: a #MatrixFilter
*
* Get the JSON representation of @filter as a #JsonNode
*
* Returns: (transfer full): the JSON representation of @filter
*/
JsonNode *
matrix_filter_get_json_node(MatrixFilter *filter)
{
JsonBuilder *builder;
JsonNode *root, *tmp;
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "event_fields");
json_builder_begin_array(builder);
g_list_foreach(filter->event_fields, (GFunc)json_add_string, builder);
json_builder_end_array(builder);
json_builder_set_member_name(builder, "event_format");
json_builder_add_string_value(builder,
_g_enum_to_string(
MATRIX_TYPE_EVENT_FORMAT,
filter->event_format,
TRUE));
json_builder_set_member_name(builder, "presence");
tmp = matrix_filter_rules_get_json_node(filter->presence);
json_builder_add_value(builder, tmp);
json_node_free(tmp);
json_builder_set_member_name(builder, "room");
tmp = matrix_room_filter_get_json_node(filter->room);
json_builder_add_value(builder, tmp);
json_node_free(tmp);
json_builder_end_object(builder);
root = json_builder_get_root(builder);
g_object_unref(builder);
return root;
}
/**
* matrix_filter_get_json_data:
* @filter: a #MatrixFilter
* @datalen: storage for the length of the JSON data, or %NULL
*
* Get the JSON representation of @filter as a string.
*
* Returns: (transfer full): the JSON representation of @filter
*/
gchar *
matrix_filter_get_json_data(MatrixFilter *filter, gsize *datalen)
{
JsonGenerator *generator;
JsonNode *node = matrix_filter_get_json_node(filter);
gchar *data;
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* Matrix3PidCredential:
*
* An opaque structure to store credentials to use with Identity
* Server communication.
*/
struct _Matrix3PidCredential {
gchar *id_server;
gchar *session_id;
gchar *client_secret;
guint refcount;
};
G_DEFINE_BOXED_TYPE(Matrix3PidCredential, matrix_3pid_credential,
(GBoxedCopyFunc)matrix_3pid_credential_ref,
(GBoxedFreeFunc)matrix_3pid_credential_unref);
/**
* matrix_3pid_credential_new:
*
* Create a new #Matrix3PidCredential object with reference count
* of 1.
*
* Returns: (transfer full): a new #Matrix3PidCredential
*/
Matrix3PidCredential *
matrix_3pid_credential_new(void)
{
Matrix3PidCredential *credential;
credential = g_new0(Matrix3PidCredential, 1);
credential->refcount = 1;
return credential;
}
static void
matrix_3pid_credential_free(Matrix3PidCredential *credential)
{
g_free(credential->id_server);
g_free(credential->session_id);
g_free(credential->client_secret);
g_free(credential);
}
/**
* matrix_3pid_credential_ref:
* @credential: a #Matrix3PidCredential
*
* Increase reference count of @credential by one.
*
* Returns: (transfer none): the same #Matrix3PidCredential
*/
Matrix3PidCredential *
matrix_3pid_credential_ref(Matrix3PidCredential *credential)
{
credential->refcount++;
return credential;
}
/**
* matrix_3pid_credential_unref:
* @credential: a #Matrix3PidCredential
*
* Decrease reference count of @credential by one. If reference count
* reaches zero, @credential gets freed.
*/
void
matrix_3pid_credential_unref(Matrix3PidCredential *credential)
{
if (--credential->refcount == 0) {
matrix_3pid_credential_free(credential);
}
}
/**
* matrix_3pid_credential_set_id_server:
* @credential: a #Matrix3PidCredential
* @id_server: the Identity Server to use
*
* Set the Identity Server to use for this credential.
*/
void
matrix_3pid_credential_set_id_server(Matrix3PidCredential *credential,
const gchar *id_server)
{
g_free(credential->id_server);
credential->id_server = g_strdup(id_server);
}
/**
* matrix_3pid_credential_get_id_server:
* @credential: a #Matrix3PidCredential
*
* Get the Identity Server used for this credential.
*
* Returns: the Identity Server's name. The returned value is owned by
* @credential and should not be freed nor modified
*/
const gchar *
matrix_3pid_credential_get_id_server(Matrix3PidCredential *credential)
{
return credential->id_server;
}
/**
* matrix_3pid_credential_set_session_id:
* @credential: a #Matrix3PidCredential
* @session_id: the session identifier given by the Identity Server
*
* Set the session identifier got from the Identity Server.
*/
void
matrix_3pid_credential_set_session_id(Matrix3PidCredential *credential,
const gchar *session_id)
{
g_free(credential->session_id);
credential->session_id = g_strdup(session_id);
}
/**
* matrix_3pid_credential_get_session_id:
* @credential: a #Matrix3PidCredential
*
* Get the session identifier for this credential.
*
* Returns: the session identifier. The returned value is owned by
* @credential and should not be freed nor modified.
*/
const gchar *
matrix_3pid_credential_get_session_id(Matrix3PidCredential *credential)
{
return credential->session_id;
}
/**
* matrix_3pid_credential_set_client_secret:
* @credential: a #Matrix3PidCredential
* @client_secret: the client secret used in the session with the
* Identity Server
*
* Set the client secret that was used in the session with the
* Identity Server.
*/
void
matrix_3pid_credential_set_client_secret(Matrix3PidCredential *credential,
const gchar *client_secret)
{
g_free(credential->client_secret);
credential->client_secret = g_strdup(client_secret);
}
/**
* matrix_3pid_credential_get_client_secret:
* @credential: a #Matrix3PidCredential
*
* Get the client secret that was used in the session with the
* Identity Server.
*
* Returns: the client secret. The returned value is owned by
* @credential and should not be freed nor modified.
*/
const gchar *
matrix_3pid_credential_get_client_secret(Matrix3PidCredential *credential)
{
return credential->client_secret;
}
/**
* matrix_3pid_credential_get_json_node:
* @credential: a #Matrix3PidCredential
* @error: return location for a #GError, or %NULL
*
* Get the JSON representation of @credential as a #JsonNode. If any
* fields of @credential are empty, it will yield an error, as all
* fields are mandatory. In this case, the return value is %NULL.
*
* Returns: (transfer full) (allow-none): the #JsonNode representation
* of @credential
*/
JsonNode *
matrix_3pid_credential_get_json_node(Matrix3PidCredential *credential,
GError **error)
{
JsonBuilder *builder;
JsonNode *node;
if (!credential->id_server
|| !credential->session_id
|| !credential->client_secret) {
g_set_error(error,
MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
"All fields of the 3PID credential must be filled!");
return NULL;
}
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "id_server");
json_builder_add_string_value(builder, credential->id_server);
json_builder_set_member_name(builder, "session_id");
json_builder_add_string_value(builder, credential->session_id);
json_builder_set_member_name(builder, "client_secret");
json_builder_add_string_value(builder, credential->client_secret);
json_builder_end_object(builder);
node = json_builder_get_root(builder);
g_object_unref(builder);
return node;
}
/**
* matrix_3pid_credential_get_json_data:
* @credential: a #Matrix3PidCredential
* @datalen: (out): storage location for the length of the JSON data,
* or %NULL
* @error: a #GError
*
* Get the JSON representation of @credential as a string. If any
* fields of @credential is %NULL, this function returns %NULL and
* fills @error wich %MATRIX_ERROR_INCOMPLETE.
*
* Returns: (transfer full) (allow-none): the JSON representation of
* @credential, or %NULL
*/
gchar *
matrix_3pid_credential_get_json_data(Matrix3PidCredential *credential,
gsize *datalen,
GError **error)
{
JsonGenerator *generator;
JsonNode *node;
gchar *data;
if ((node = matrix_3pid_credential_get_json_node(
credential, error)) == NULL) {
return NULL;
}
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* MatrixPusher:
*
* An opaque structure for pusher rulesets.
*/
struct _MatrixPusher {
gchar *device_display_name;
gchar *app_display_name;
gchar *app_id;
gboolean append;
gchar *kind;
gchar *lang;
gchar *profile_tag;
gchar *pushkey;
JsonNode *data;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixPusher, matrix_pusher,
(GBoxedCopyFunc)matrix_pusher_ref,
(GBoxedFreeFunc)matrix_pusher_unref);
/**
* matrix_pusher_new:
*
* Create a new #MatrixPusher object with reference count of 1.
*
* Returns: (transfer full): a new #MatrixPusher
*/
MatrixPusher *
matrix_pusher_new(void)
{
MatrixPusher *pusher;
pusher = g_new0(MatrixPusher, 1);
pusher->refcount = 1;
return pusher;
}
static void
matrix_pusher_free(MatrixPusher *pusher)
{
g_free(pusher->device_display_name);
g_free(pusher->app_display_name);
g_free(pusher->app_id);
g_free(pusher->kind);
g_free(pusher->lang);
g_free(pusher->profile_tag);
g_free(pusher->pushkey);
json_node_free(pusher->data);
g_free(pusher);
}
/**
* matrix_pusher_ref:
* @pusher: a #MatrixPusher
*
* Increase reference count of @pusher by one.
*
* Returns: (transfer none): the same #MatrixPusher
*/
MatrixPusher *
matrix_pusher_ref(MatrixPusher *pusher)
{
pusher->refcount++;
return pusher;
}
/**
* matrix_pusher_unref:
* @pusher: a #MatrixPusher
*
* Decrease reference count of @pusher by one. If reference count
* reaches zero, @pusher is freed.
*/
void
matrix_pusher_unref(MatrixPusher *pusher)
{
if (--pusher->refcount == 0) {
matrix_pusher_free(pusher);
}
}
/**
* matrix_pusher_set_device_display_name:
* @pusher: a #MatrixPusher
* @device_display_name: a string that will allow the user to identify
* what device owns this pusher
*
* Set the device display name for @pusher.
*/
void
matrix_pusher_set_device_display_name(MatrixPusher *pusher,
const gchar *device_display_name)
{
g_free(pusher->device_display_name);
pusher->device_display_name = g_strdup(device_display_name);
}
/**
* matrix_pusher_get_device_display_name:
* @pusher: a #MatrixPusher
*
* Get the device display name from pusher.
*
* Returns: the device display name. The returned value is owned by
* @pusher and should not be freed nor modified.
*/
const gchar *
matrix_pusher_get_device_display_name(MatrixPusher *pusher)
{
return pusher->device_display_name;
}
/**
* matrix_pusher_set_app_display_name:
* @pusher: a #MatrixPusher
* @app_display_name: a string that will allow the user to identify
* what application owns the pusher
*
* Sets the app display name for the pusher.
*/
void
matrix_pusher_set_app_display_name(MatrixPusher *pusher,
const gchar *app_display_name)
{
g_free(pusher->app_display_name);
pusher->app_display_name = g_strdup(app_display_name);
}
/**
* matrix_pusher_get_app_display_name:
* @pusher: a #MatrixPusher
*
* Get the app display name for this pusher.
*
* Returns: the app display name. The returned value is owned by
* @pusher and should not be freed nor modified.
*/
const gchar *
matrix_pusher_get_app_display_name(MatrixPusher *pusher)
{
return pusher->app_display_name;
}
/**
* matrix_pusher_set_app_id:
* @pusher: a #MatrixPusher
* @app_id: a reverse DNS style identifier for the application. It is
* recommended that this ends with the platform, such that
* different platform versions get different app
* identifiers. Maximum length is 64 characters. If @app_id
* is longer than this, it will be truncated.
*
* Sets the application ID for this pusher.
*/
void
matrix_pusher_set_app_id(MatrixPusher *pusher, const gchar *app_id)
{
g_free(pusher->app_id);
pusher->app_id = g_strndup(app_id, 64);
}
/**
* matrix_pusher_get_app_id:
* @pusher: a #MatrixPusher
*
* Get the application ID for this pusher.
*
* Returns: the application ID. The returned value is owned by @pusher
* and should not be freed nor modified.
*/
const gchar *
matrix_pusher_get_app_id(MatrixPusher *pusher)
{
return pusher->app_id;
}
/**
* matrix_pusher_set_append:
* @pusher: a #MatrixPusher
* @append: if %TRUE, the homeserver should add another pusher with
* the given push key and app ID in addition to any others
* with different user IDs. Otherwise, the homeserver must
* remove any other pushers with the same App ID and pushkey
* for different users
*
* Set the appending rule for this pusher.
*/
void
matrix_pusher_set_append(MatrixPusher *pusher, gboolean append)
{
pusher->append = append;
}
/**
* matrix_pusher_get_append:
* @pusher: a #MatrixPusher
*
* Get the appending rule for this pusher. See
* matrix_pusher_set_append() for details.
*
* Returns: the append rule
*/
gboolean
matrix_pusher_get_append(MatrixPusher *pusher)
{
return pusher->append;
}
/**
* matrix_pusher_set_kind:
* @pusher: a #MatrixPusher
* @kind: the kind of pusher to configure. "http" makes a pusher that
* sends HTTP pokes. %NULL deletes the pusher.
*
* Set the kind of pusher to configure.
*/
void
matrix_pusher_set_kind(MatrixPusher *pusher, const gchar *kind)
{
g_free(pusher->kind);
pusher->kind = g_strdup(kind);
}
/**
* matrix_pusher_get_kind:
* @pusher: a #MatrixPusher
*
* Get the kind of pusher in @pusher.
*
* Returns: the kind of this pusher. The returned value is owned by
* @pusher and should not be freed nor modified
*/
const gchar *
matrix_pusher_get_kind(MatrixPusher *pusher)
{
return pusher->kind;
}
/**
* matrix_pusher_set_lang:
* @pusher: a #MatrixPusher
* @lang: the preferred language for receiving notifications,
* e.g. "en" or "en-US"
*
* Set the preferred language for receiving notifications.
*/
void
matrix_pusher_set_lang(MatrixPusher *pusher, const gchar *lang)
{
g_free(pusher->lang);
pusher->lang = g_strdup(lang);
}
/**
* matrix_pusher_get_lang:
* @pusher: a #MatrixPusher
*
* Get the preferred language for receiving notifications.
*
* Returns: the preferred language. The returned value is owned by
* @pusher and should not be modified nor freed
*/
const gchar *
matrix_pusher_get_lang(MatrixPusher *pusher)
{
return pusher->lang;
}
/**
* matrix_pusher_set_profile_tag:
* @pusher: a #MatrixPusher
* @profile_tag: a string that determines what set of device rules
* will be matched when evaluating push rules for this
* pusher. It is an arbitrary string. Multiple devices
* may use the same <code>profile_tag</code>. It is
* advised that when an app's data is copied or restored
* to a different device, this value remain the
* same. Client apps should offer ways to change the
* profile_tag, optionally copying rules from the old
* profile tag. Maximum length is 32 bytes. If
* @profile_tag is longer than this, it will be
* truncated
*
* Set the profile tag of this pusher.
*/
void
matrix_pusher_set_profile_tag(MatrixPusher *pusher, const gchar *profile_tag)
{
g_free(pusher->profile_tag);
pusher->profile_tag = g_strndup(profile_tag, 32);
}
/**
* matrix_pusher_get_profile_tag:
* @pusher: a #MatrixPusher
*
* Get the profile tag of this pusher.
*
* Returns: the profile tag. The returned value is owned by @pusher
* and should not be freed nor modified
*/
const gchar *
matrix_pusher_get_profile_tag(MatrixPusher *pusher)
{
return pusher->profile_tag;
}
/**
* matrix_pusher_set_pushkey:
* @pusher: a #MatrixPusher
* @pushkey: a unique identifier for this pusher. The value you should
* use for this is the routing or destination address
* information for the notification, for example, the APNS
* token for APNS or the Registration ID for GCM. If your
* notification client has no such concept, use any unique
* identifier. Maximum length is 512 bytes. If @pushkey is
* longer than this, it will be truncated
*
* Set the pushkey for this pusher.
*/
void
matrix_pusher_set_pushkey(MatrixPusher *pusher, const gchar *pushkey)
{
g_free(pusher->pushkey);
pusher->pushkey = g_strndup(pushkey, 512);
}
/**
* matrix_pusher_get_pushkey:
* @pusher: a #MatrixPusher
*
* Get the pushkey for this pusher.
*
* Returns: the pushkey. The returned value is owned by @pusher and
* should not be freed nor modified
*/
const gchar *
matrix_pusher_get_pushkey(MatrixPusher *pusher)
{
return pusher->pushkey;
}
/**
* matrix_pusher_set_data:
* @pusher: a #MatrixPusher
* @data: (transfer none): a dictionary of information for the pusher
* implementation itself. For example, if kind is "http", this
* should contain an "url" member, which is the URL to use to
* send notifications to. This function creates a deep copy of
* @data, so it can be freed after this call.
*
* Set some extra data for the pusher.
*/
void
matrix_pusher_set_data(MatrixPusher *pusher, const JsonNode *data)
{
if (pusher->data) {
json_node_free(pusher->data);
}
pusher->data = json_node_copy((JsonNode *)data);
}
/**
* matrix_pusher_take_data:
* @pusher: a #MatrixPusher
* @data: (transfer full): extra data for the pusher. See
* matrix_pusher_set_data() for details.
*
* Set some extra data for the pusher. It differs from
* matrix_pusher_set_data() that this call assumes ownership over
* @data, so it should not be freed by the caller.
*/
void
matrix_pusher_take_data(MatrixPusher *pusher, JsonNode *data)
{
if (pusher->data) {
json_node_free(pusher->data);
}
pusher->data = data;
}
/**
* matrix_pusher_get_data:
* @pusher: a #MatrixPusher
*
* Get the extra data of this pusher.
*
* Returns: (transfer none): the extra data. The returned value is
* owned by @pusher and should not be freed nor modified
*/
const JsonNode *
matrix_pusher_get_data(MatrixPusher *pusher)
{
return pusher->data;
}
/**
* matrix_pusher_get_json_node:
* @pusher: a #MatrixPusher
* @err: a #GError
*
* Get the JSON representation of the pusher data as a #JsonNode
* object. As in the pusher object all fields are mandatory, if any of
* them is %NULL, this function returns %NULL, and fills @err with
* %MATRIX_ERROR_INCOMPLETE.
*
* Returns: (transfer full): the JSON representation of the pusher
* data.
*/
JsonNode *
matrix_pusher_get_json_node(MatrixPusher *pusher, GError **err)
{
JsonBuilder *builder;
JsonNode *node;
if (!pusher->device_display_name
|| !pusher->app_display_name
|| !pusher->app_id
|| !pusher->data
|| !pusher->kind
|| !pusher->lang
|| !pusher->profile_tag
|| !pusher->pushkey) {
g_set_error(err,
MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
"Pusher data incomplete");
return NULL;
}
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "device_display_name");
json_builder_add_string_value(builder, pusher->device_display_name);
json_builder_set_member_name(builder, "app_display_name");
json_builder_add_string_value(builder, pusher->app_display_name);
json_builder_set_member_name(builder, "app_id");
json_builder_add_string_value(builder, pusher->app_id);
json_builder_set_member_name(builder, "append");
json_builder_add_boolean_value(builder, pusher->append);
json_builder_set_member_name(builder, "kind");
json_builder_add_string_value(builder, pusher->kind);
json_builder_set_member_name(builder, "lang");
json_builder_add_string_value(builder, pusher->lang);
json_builder_set_member_name(builder, "profile_tag");
json_builder_add_string_value(builder, pusher->profile_tag);
json_builder_set_member_name(builder, "pushkey");
json_builder_add_string_value(builder, pusher->pushkey);
json_builder_set_member_name(builder, "data");
json_builder_add_value(builder, pusher->data);
json_builder_end_object(builder);
node = json_builder_get_root(builder);
g_object_unref(builder);
return node;
}
/**
* matrix_pusher_get_json_data:
* @pusher: a #MatrixPusher
* @datalen: (out): storage for the the length of the JSON data or
* %NULL
* @err: a #GError
*
* Get the JSON representation of the pusher data as a string. As in
* the pusher object all fields are mandatory, if any of them is
* %NULL, this function returns %NULL, and fills @err with
* %MATRIX_ERROR_INCOMPLETE.
*
* Returns: (transfer full): the JSON representation of the pusher
* data.
*/
gchar *matrix_pusher_get_json_data(MatrixPusher *pusher,
gsize *datalen,
GError **err)
{
JsonGenerator *generator;
JsonNode *node;
gchar *data;
if ((node = matrix_pusher_get_json_node(pusher, err)) == NULL) {
return NULL;
}
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* MatrixStateEvent:
*
* An opaque structure to hold a state event filter.
*/
struct _MatrixStateEvent {
gchar *type;
gchar *state_key;
JsonNode *content;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixStateEvent, matrix_state_event,
(GBoxedCopyFunc)matrix_state_event_ref,
(GBoxedFreeFunc)matrix_state_event_unref);
/**
* matrix_state_event_new:
*
* Create a new #MatrixStateEvent object with reference count of 1.
*
* Returns: (transfer full): a new #MatrixStateEvent
*/
MatrixStateEvent *
matrix_state_event_new(void)
{
MatrixStateEvent *event;
event = g_new0(MatrixStateEvent, 1);
event->refcount = 1;
return event;
}
static void
matrix_state_event_free(MatrixStateEvent *event)
{
g_free(event->type);
g_free(event->state_key);
if (event->content) {
json_node_free(event->content);
}
g_free(event);
}
/**
* matrix_state_event_ref:
* @event: a #MatrixStateEvent
*
* Increase reference count of @event by one.
*
* Returns: (transfer none): the same #MatrixStateEvent
*/
MatrixStateEvent *
matrix_state_event_ref(MatrixStateEvent *event)
{
event->refcount++;
return event;
}
/**
* matrix_state_event_unref:
* @event: a #MatrixStateEvent
*
* Decrease reference count of @event by one. If reference count
* reaches zero, @event is freed.
*/
void
matrix_state_event_unref(MatrixStateEvent *event)
{
if (--event->refcount == 0) {
matrix_state_event_free(event);
}
}
/**
* matrix_state_event_set_event_type:
* @event: a #MatrixStateEvent
* @event_type: the type of the state event
*
* Set the type of the state event in @event.
*/
void
matrix_state_event_set_event_type(MatrixStateEvent *event,
const gchar *event_type)
{
g_free(event->type);
event->type = g_strdup(event_type);
}
/**
* matrix_state_event_get_event_type:
* @event: a #MatrixStateEvent
*
* Get the type of the state event in @event.
*
* Returns: (transfer none): the event type. The returned value is
* owned by @event and should not be freed nor modified.
*/
const gchar *
matrix_state_event_get_event_type(MatrixStateEvent *event)
{
return event->type;
}
/**
* matrix_state_event_set_state_key:
* @event: a #MatrixStateEvent
* @state_key: the key of the state event
*
* Set the state key for the state event @event.
*/
void
matrix_state_event_set_state_key(MatrixStateEvent *event,
const gchar *state_key)
{
g_free(event->state_key);
event->state_key = g_strdup(state_key);
}
/**
* matrix_state_event_get_state_key:
* @event: a #MatrixStateEvent
*
* Get the state key of @event.
*
* Returns: (transfer none): the state key. The returned value is
* owned by @event and should not be freed nor modified
*/
const gchar *
matrix_state_event_get_state_key(MatrixStateEvent *event)
{
return event->state_key;
}
/**
* matrix_state_event_set_content:
* @event: a #MatrixStateEvent
* @content: the desired content of the state event
*
* Set the content of the state event.
*/
void
matrix_state_event_set_content(MatrixStateEvent *event, const JsonNode *content)
{
if (event->content) {
json_node_free(event->content);
}
event->content = json_node_copy((JsonNode *)content);
}
/**
* matrix_state_event_get_content:
* @event: a #MatrixStateEvent
*
* Get the contents of the state event.
*
* Returns: (transfer none): the contents of the state event. The
* returned value is owned by @event and should not be freed
* nor modified
*/
const JsonNode *
matrix_state_event_get_content(MatrixStateEvent *event)
{
return event->content;
}
/**
* matrix_state_event_get_json_node:
* @event: a #MatrixStateEvent
*
* Get the JSON representation of the state event as a #JsonNode
* object.
*
* Returns: (transfer full): the JSON representation of the state
* event
*/
JsonNode *
matrix_state_event_get_json_node(MatrixStateEvent *event)
{
JsonBuilder *builder;
JsonNode *node;
builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "state_key");
json_builder_add_string_value(builder, event->state_key);
json_builder_set_member_name(builder, "type");
json_builder_add_string_value(builder, event->type);
json_builder_set_member_name(builder, "content");
json_builder_add_value(builder, event->content);
json_builder_end_object(builder);
node = json_builder_get_root(builder);
g_object_unref(builder);
return node;
}
/**
* matrix_state_event_get_json_data:
* @event: a #MatrixStateEvent
* @datalen: (out): storage for the the length of the JSON data or
* %NULL
*
* Get the JSON representation of the state event as a string.
*
* Returns: (transfer full): the JSON representation of the state
* event
*/
gchar *
matrix_state_event_get_json_data(MatrixStateEvent *event, gsize *datalen)
{
JsonGenerator *generator;
JsonNode *node = matrix_state_event_get_json_node(event);
gchar *data;
generator = json_generator_new();
json_generator_set_root(generator, node);
json_node_free(node);
data = json_generator_to_data(generator, datalen);
g_object_unref(generator);
return data;
}
/**
* MatrixPresenceEvent:
*
* An opaque structure to hold a presence event.
*/
struct _MatrixPresenceEvent {
gchar *user_id;
gchar *display_name;
gchar *avatar_url;
gulong last_active_ago;
MatrixPresence presence;
guint refcount;
};
G_DEFINE_BOXED_TYPE(MatrixPresenceEvent, matrix_presence_event,
(GBoxedCopyFunc)matrix_presence_event_ref,
(GBoxedFreeFunc)matrix_presence_event_unref);
/**
* matrix_presence_event_new:
*
* Create a new #MatrixPresenceEvent object with reference count of 1.
*
* Returns: (transfer full): a new #MatrixPresenceEvent
*/
MatrixPresenceEvent *
matrix_presence_event_new(void)
{
MatrixPresenceEvent *event;
event = g_new0(MatrixPresenceEvent, 1);
event->refcount = 1;
return event;
}
#define try_get_string_member(evt, nd, obj, m_n, s_m) \
if ((nd = json_object_get_member(obj, (m_n))) != NULL) { \
g_free(evt->s_m); \
evt->s_m = g_strdup(json_node_get_string (nd)); \
json_object_remove_member(obj, m_n); \
}
#define try_get_member(evt, nd, obj, m_n, typ, s_m) \
if ((nd = json_object_get_member(obj, (m_n))) != NULL) { \
evt->s_m = json_node_get_##typ (nd); \
json_object_remove_member(obj, m_n); \
}
/**
* matrix_presence_event_new_from_json: (constructor)
* @json_data: a #JsonNode to convert to #MatrixPresenceEvent
*
* Converts a #JsonNode (usually from the response from a homeserver)
* to a #MatrixPresenceEvent.
*
* Returns: (transfer full): a new #MatrixPresenceEvent with all
* values from #JsonNode
*/
MatrixPresenceEvent *
matrix_presence_event_new_from_json(JsonNode *json_data)
{
JsonNode *node, *copied_data;
JsonObject *root;
MatrixPresenceEvent *event;
GError *err = NULL;
g_return_val_if_fail(JSON_NODE_HOLDS_OBJECT(json_data), NULL);
copied_data = _json_node_deep_copy(json_data);
event = matrix_presence_event_new();
root = json_node_get_object(copied_data);
try_get_string_member(event, node, root, "user_id", user_id);
try_get_string_member(event, node, root, "displayname", display_name);
try_get_string_member(event, node, root, "avatar_url", avatar_url);
try_get_member(event, node, root, "last_active_ago", int, last_active_ago);
if ((node = json_object_get_member(root, "presence")) != NULL) {
int val;
const gchar *value = json_node_get_string(node);
val = _g_enum_nick_to_value(MATRIX_TYPE_PRESENCE, value, &err);
if (!err) {
event->presence = val;
} else {
g_warning("Unknown presence value '%s'. Please report it to the Matrix.org GLib SDK project.", value);
}
json_object_remove_member(root, "presence");
}
// By now, root_object should be empty.
if (json_object_get_size(root) > 0) {
g_warning("Some members remained in the received presence event. This may be a bug in Matrix GLib");
}
return event;
}
static void
matrix_presence_event_free(MatrixPresenceEvent *event)
{
g_free(event);
}
/**
* matrix_presence_event_ref:
* @event: a #MatrixPresenceEvent
*
* Increase reference count of @event by one.
*
* Returns: (transfer none): the same #MatrixPresenceEvent
*/
MatrixPresenceEvent *
matrix_presence_event_ref(MatrixPresenceEvent *event)
{
event->refcount++;
return event;
}
/**
* matrix_presence_event_unref:
* @event: a #MatrixPresenceEvent
*
* Decrease reference count of @event by one. If reference count drops
* to zero, @event is freed.
*/
void
matrix_presence_event_unref(MatrixPresenceEvent *event)
{
if (--event->refcount == 0) {
matrix_presence_event_free(event);
}
}
/**
* matrix_presence_event_set_user_id:
* @event: a #MatrixPresenceEvent
* @user_id: (transfer none): a Matrix.org user ID
*
* Set the user ID in the presence event.
*/
void
matrix_presence_event_set_user_id(MatrixPresenceEvent *event,
const gchar *user_id)
{
g_free(event->user_id);
event->user_id = g_strdup(user_id);
}
/**
* matrix_presence_event_get_user_id:
* @event: a #MatrixPresenceEvent
*
* Get the user ID from the presence event.
*
* Returns: (transfer none): a user ID
*/
const gchar *
matrix_presence_event_get_user_id(MatrixPresenceEvent *event)
{
return event->user_id;
}
/**
* matrix_presence_event_set_display_name:
* @event: a #MatrixPresenceEvent
* @display_name: a display name to set
*
* Set the display name in the presence event.
*/
void
matrix_presence_event_set_display_name(MatrixPresenceEvent *event,
const gchar *display_name)
{
g_free(event->display_name);
event->display_name = g_strdup(display_name);
}
/**
* matrix_presence_event_get_display_name:
* @event: a #MatrixPresenceEvent
*
* Get the display name from the presence event.
*
* Returns: (transfer none) (allow-none): the display name
*/
const gchar *
matrix_presence_event_get_display_name(MatrixPresenceEvent *event)
{
return event->display_name;
}
/**
* matrix_presence_event_set_avatar_url:
* @event: a #MatrixPresenceEvent
* @avatar_url: (allow-none): the avatar URL to set
*
* Set the avatar URL in the presence event.
*/
void
matrix_presence_event_set_avatar_url(MatrixPresenceEvent *event,
const gchar *avatar_url)
{
g_free(event->avatar_url);
event->avatar_url = g_strdup(avatar_url);
}
/**
* matrix_presence_event_get_avatar_url:
* @event: a #MatrixPresenceEvent
*
* Gets the avatar URL from the presence event.
*
* Returns: (transfer none) (allow-none): the avatar URL
*/
const gchar *
matrix_presence_event_get_avatar_url(MatrixPresenceEvent *event)
{
return event->avatar_url;
}
/**
* matrix_presence_event_set_last_active_ago:
* @event: a #MatrixPresenceEvent
* @last_active_ago: the amount of time, in seconds
*
* Set the amount of time when the user in the presence event was last
* active.
*/
void
matrix_presence_event_set_last_active_ago(MatrixPresenceEvent *event,
gulong last_active_ago)
{
event->last_active_ago = last_active_ago;
}
/**
* matrix_presence_event_get_last_active_ago:
* @event: a #MatrixPresenceEvent
*
* Get the amount of time since the user was last active, in seconds.
*
* Returns: count of seconds
*/
gulong
matrix_presence_event_get_last_active_ago(MatrixPresenceEvent *event)
{
return event->last_active_ago;
}
/**
* matrix_presence_event_set_presence:
* @event: a #MatrixPresenceEvent
* @presence: the new presence
*
* Set the new presence state of the user in the presence event.
*/
void
matrix_presence_event_set_presence(MatrixPresenceEvent *event,
MatrixPresence presence)
{
event->presence = presence;
}
/**
* matrix_presence_event_get_presence:
* @event: a #MatrixPresenceEvent
*
* Get the new presence of the user from the presence event.
*
* Returns: the new presence state of the user
*/
MatrixPresence
matrix_presence_event_get_presence(MatrixPresenceEvent *event)
{
return event->presence;
}
Reference in New Issue View Git Blame Copy Permalink