2105 lines
78 KiB
Dart
2105 lines
78 KiB
Dart
/*
|
|
* Famedly Matrix SDK
|
|
* Copyright (C) 2019, 2020 Famedly GmbH
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program 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 Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
|
|
import 'package:famedlysdk/matrix_api/model/filter.dart';
|
|
import 'package:famedlysdk/matrix_api/model/keys_query_response.dart';
|
|
import 'package:famedlysdk/matrix_api/model/login_types.dart';
|
|
import 'package:famedlysdk/matrix_api/model/notifications_query_response.dart';
|
|
import 'package:famedlysdk/matrix_api/model/open_graph_data.dart';
|
|
import 'package:famedlysdk/matrix_api/model/profile.dart';
|
|
import 'package:famedlysdk/matrix_api/model/request_token_response.dart';
|
|
import 'package:famedlysdk/matrix_api/model/server_capabilities.dart';
|
|
import 'package:famedlysdk/matrix_api/model/supported_versions.dart';
|
|
import 'package:famedlysdk/matrix_api/model/sync_update.dart';
|
|
import 'package:famedlysdk/matrix_api/model/third_party_location.dart';
|
|
import 'package:famedlysdk/matrix_api/model/timeline_history_response.dart';
|
|
import 'package:famedlysdk/matrix_api/model/user_search_result.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:mime/mime.dart';
|
|
import 'package:moor/moor.dart';
|
|
|
|
import 'model/device.dart';
|
|
import 'model/event_context.dart';
|
|
import 'model/events_sync_update.dart';
|
|
import 'model/login_response.dart';
|
|
import 'model/matrix_event.dart';
|
|
import 'model/matrix_exception.dart';
|
|
import 'model/matrix_keys.dart';
|
|
import 'model/one_time_keys_claim_response.dart';
|
|
import 'model/open_id_credentials.dart';
|
|
import 'model/presence_content.dart';
|
|
import 'model/public_rooms_response.dart';
|
|
import 'model/push_rule_set.dart';
|
|
import 'model/pusher.dart';
|
|
import 'model/room_alias_informations.dart';
|
|
import 'model/room_keys_info.dart';
|
|
import 'model/room_keys_keys.dart';
|
|
import 'model/supported_protocol.dart';
|
|
import 'model/tag.dart';
|
|
import 'model/third_party_identifier.dart';
|
|
import 'model/third_party_user.dart';
|
|
import 'model/turn_server_credentials.dart';
|
|
import 'model/upload_key_signatures_response.dart';
|
|
import 'model/well_known_informations.dart';
|
|
import 'model/who_is_info.dart';
|
|
|
|
enum RequestType { GET, POST, PUT, DELETE }
|
|
enum IdServerUnbindResult { success, no_success }
|
|
enum ThirdPartyIdentifierMedium { email, msisdn }
|
|
enum Membership { join, invite, leave, ban }
|
|
enum Direction { b, f }
|
|
enum Visibility { public, private }
|
|
enum CreateRoomPreset { private_chat, public_chat, trusted_private_chat }
|
|
|
|
String describeEnum(Object enumEntry) {
|
|
final description = enumEntry.toString();
|
|
final indexOfDot = description.indexOf('.');
|
|
assert(indexOfDot != -1 && indexOfDot < description.length - 1);
|
|
return description.substring(indexOfDot + 1);
|
|
}
|
|
|
|
class MatrixApi {
|
|
/// The homeserver this client is communicating with.
|
|
Uri homeserver;
|
|
|
|
/// This is the access token for the matrix client. When it is undefined, then
|
|
/// the user needs to sign in first.
|
|
String accessToken;
|
|
|
|
/// Matrix synchronisation is done with https long polling. This needs a
|
|
/// timeout which is usually 30 seconds.
|
|
int syncTimeoutSec;
|
|
|
|
http.Client httpClient = http.Client();
|
|
|
|
bool get _testMode =>
|
|
homeserver.toString() == 'https://fakeserver.notexisting';
|
|
|
|
int _timeoutFactor = 1;
|
|
|
|
MatrixApi({
|
|
this.homeserver,
|
|
this.accessToken,
|
|
http.Client httpClient,
|
|
this.syncTimeoutSec = 30,
|
|
}) {
|
|
if (httpClient != null) {
|
|
this.httpClient = httpClient;
|
|
}
|
|
}
|
|
|
|
/// Used for all Matrix json requests using the [c2s API](https://matrix.org/docs/spec/client_server/r0.6.0.html).
|
|
///
|
|
/// Throws: TimeoutException, FormatException, MatrixException
|
|
///
|
|
/// You must first set [this.homeserver] and for some endpoints also
|
|
/// [this.accessToken] before you can use this! For example to send a
|
|
/// message to a Matrix room with the id '!fjd823j:example.com' you call:
|
|
/// ```
|
|
/// final resp = await request(
|
|
/// RequestType.PUT,
|
|
/// '/r0/rooms/!fjd823j:example.com/send/m.room.message/$txnId',
|
|
/// data: {
|
|
/// 'msgtype': 'm.text',
|
|
/// 'body': 'hello'
|
|
/// }
|
|
/// );
|
|
/// ```
|
|
///
|
|
Future<Map<String, dynamic>> request(
|
|
RequestType type,
|
|
String action, {
|
|
dynamic data = '',
|
|
int timeout,
|
|
String contentType = 'application/json',
|
|
Map<String, String> query,
|
|
}) async {
|
|
if (homeserver == null) {
|
|
throw ('No homeserver specified.');
|
|
}
|
|
timeout ??= (_timeoutFactor * syncTimeoutSec) + 5;
|
|
dynamic json;
|
|
if (data is Map) data.removeWhere((k, v) => v == null);
|
|
(!(data is String)) ? json = jsonEncode(data) : json = data;
|
|
if (data is List<int> || action.startsWith('/media/r0/upload')) json = data;
|
|
|
|
final queryPart = query?.entries
|
|
?.where((x) => x.value != null)
|
|
?.map((x) => [x.key, x.value].map(Uri.encodeQueryComponent).join('='))
|
|
?.join('&');
|
|
final url = ['${homeserver.toString()}/_matrix${action}', queryPart]
|
|
.where((x) => x != null && x != '')
|
|
.join('?');
|
|
|
|
var headers = <String, String>{};
|
|
if (type == RequestType.PUT || type == RequestType.POST) {
|
|
headers['Content-Type'] = contentType;
|
|
}
|
|
if (accessToken != null) {
|
|
headers['Authorization'] = 'Bearer ${accessToken}';
|
|
}
|
|
|
|
http.Response resp;
|
|
var jsonResp = <String, dynamic>{};
|
|
try {
|
|
switch (describeEnum(type)) {
|
|
case 'GET':
|
|
resp = await httpClient.get(url, headers: headers).timeout(
|
|
Duration(seconds: timeout),
|
|
);
|
|
break;
|
|
case 'POST':
|
|
resp =
|
|
await httpClient.post(url, body: json, headers: headers).timeout(
|
|
Duration(seconds: timeout),
|
|
);
|
|
break;
|
|
case 'PUT':
|
|
resp =
|
|
await httpClient.put(url, body: json, headers: headers).timeout(
|
|
Duration(seconds: timeout),
|
|
);
|
|
break;
|
|
case 'DELETE':
|
|
resp = await httpClient.delete(url, headers: headers).timeout(
|
|
Duration(seconds: timeout),
|
|
);
|
|
break;
|
|
}
|
|
var respBody = resp.body;
|
|
try {
|
|
respBody = utf8.decode(resp.bodyBytes);
|
|
} catch (_) {
|
|
// No-OP
|
|
}
|
|
var jsonString = String.fromCharCodes(respBody.runes);
|
|
if (jsonString.startsWith('[') && jsonString.endsWith(']')) {
|
|
jsonString = '\{"chunk":$jsonString\}';
|
|
}
|
|
jsonResp = jsonDecode(jsonString)
|
|
as Map<String, dynamic>; // May throw FormatException
|
|
|
|
if (resp.statusCode >= 400 && resp.statusCode < 500) {
|
|
// The server has responsed with an matrix related error.
|
|
var exception = MatrixException(resp);
|
|
|
|
throw exception;
|
|
}
|
|
_timeoutFactor = 1;
|
|
} on TimeoutException catch (_) {
|
|
_timeoutFactor *= 2;
|
|
rethrow;
|
|
} catch (_) {
|
|
rethrow;
|
|
}
|
|
|
|
return jsonResp;
|
|
}
|
|
|
|
/// Gets the versions of the specification supported by the server.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-versions
|
|
Future<SupportedVersions> requestSupportedVersions() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/versions',
|
|
);
|
|
return SupportedVersions.fromJson(response);
|
|
}
|
|
|
|
/// Gets discovery information about the domain. The file may include additional keys.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-well-known-matrix-client
|
|
Future<WellKnownInformations> requestWellKnownInformations() async {
|
|
var baseUrl = homeserver.toString();
|
|
if (baseUrl.endsWith('/')) {
|
|
baseUrl = baseUrl.substring(0, baseUrl.length - 1);
|
|
}
|
|
final response = await httpClient.get('$baseUrl/.well-known/matrix/client');
|
|
final rawJson = json.decode(response.body);
|
|
return WellKnownInformations.fromJson(rawJson);
|
|
}
|
|
|
|
Future<LoginTypes> requestLoginTypes() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/login',
|
|
);
|
|
return LoginTypes.fromJson(response);
|
|
}
|
|
|
|
/// Authenticates the user, and issues an access token they can use to authorize themself in subsequent requests.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-login
|
|
Future<LoginResponse> login({
|
|
String type = 'm.login.password',
|
|
String userIdentifierType,
|
|
String user,
|
|
String medium,
|
|
String address,
|
|
String password,
|
|
String token,
|
|
String deviceId,
|
|
String initialDeviceDisplayName,
|
|
}) async {
|
|
final response = await request(RequestType.POST, '/client/r0/login', data: {
|
|
'type': type,
|
|
if (userIdentifierType != null)
|
|
'identifier': {
|
|
'type': userIdentifierType,
|
|
if (user != null) 'user': user,
|
|
},
|
|
if (user != null) 'user': user,
|
|
if (medium != null) 'medium': medium,
|
|
if (address != null) 'address': address,
|
|
if (password != null) 'password': password,
|
|
if (deviceId != null) 'device_id': deviceId,
|
|
if (initialDeviceDisplayName != null)
|
|
'initial_device_display_name': initialDeviceDisplayName,
|
|
});
|
|
return LoginResponse.fromJson(response);
|
|
}
|
|
|
|
/// Invalidates an existing access token, so that it can no longer be used for authorization.
|
|
/// The device associated with the access token is also deleted. Device keys for the device
|
|
/// are deleted alongside the device.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-logout
|
|
Future<void> logout() async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/logout',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Invalidates all access tokens for a user, so that they can no longer be used
|
|
/// for authorization. This includes the access token that made this request. All
|
|
/// devices for the user are also deleted. Device keys for the device are
|
|
/// deleted alongside the device.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-logout-all
|
|
Future<void> logoutAll() async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/logout/all',
|
|
);
|
|
return;
|
|
}
|
|
|
|
Future<LoginResponse> register({
|
|
String username,
|
|
String password,
|
|
String deviceId,
|
|
String initialDeviceDisplayName,
|
|
bool inhibitLogin,
|
|
Map<String, dynamic> auth,
|
|
String kind,
|
|
}) async {
|
|
var action = '/client/r0/register';
|
|
if (kind != null) action += '?kind=${Uri.encodeQueryComponent(kind)}';
|
|
final response = await request(RequestType.POST, action, data: {
|
|
if (username != null) 'username': username,
|
|
if (password != null) 'password': password,
|
|
if (deviceId != null) 'device_id': deviceId,
|
|
if (initialDeviceDisplayName != null)
|
|
'initial_device_display_name': initialDeviceDisplayName,
|
|
if (inhibitLogin != null) 'inhibit_login': inhibitLogin,
|
|
if (auth != null) 'auth': auth,
|
|
});
|
|
return LoginResponse.fromJson(response);
|
|
}
|
|
|
|
/// The homeserver must check that the given email address is not already associated
|
|
/// with an account on this homeserver. The homeserver should validate the email
|
|
/// itself, either by sending a validation email itself or by using a service it
|
|
/// has control over.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-register-email-requesttoken
|
|
Future<RequestTokenResponse> requestEmailToken(
|
|
String email,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/register/email/requestToken',
|
|
data: {
|
|
'email': email,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
/// The homeserver must check that the given phone number is not already associated with an
|
|
/// account on this homeserver. The homeserver should validate the phone number itself,
|
|
/// either by sending a validation message itself or by using a service it has control over.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-register-msisdn-requesttoken
|
|
Future<RequestTokenResponse> requestMsisdnToken(
|
|
String country,
|
|
String phoneNumber,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/register/msisdn/requestToken',
|
|
data: {
|
|
'country': country,
|
|
'phone_number': phoneNumber,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
/// Changes the password for an account on this homeserver.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-password
|
|
Future<void> changePassword(
|
|
String newPassword, {
|
|
Map<String, dynamic> auth,
|
|
}) async {
|
|
await request(RequestType.POST, '/client/r0/account/password', data: {
|
|
'new_password': newPassword,
|
|
if (auth != null) 'auth': auth,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// The homeserver must check that the given email address is associated with
|
|
/// an account on this homeserver. This API should be used to request
|
|
/// validation tokens when authenticating for the /account/password endpoint.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-password-email-requesttoken
|
|
Future<RequestTokenResponse> resetPasswordUsingEmail(
|
|
String email,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/password/email/requestToken',
|
|
data: {
|
|
'email': email,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
/// The homeserver must check that the given phone number is associated with
|
|
/// an account on this homeserver. This API should be used to request validation
|
|
/// tokens when authenticating for the /account/password endpoint.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-password-msisdn-requesttoken
|
|
Future<RequestTokenResponse> resetPasswordUsingMsisdn(
|
|
String country,
|
|
String phoneNumber,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/password/msisdn/requestToken',
|
|
data: {
|
|
'country': country,
|
|
'phone_number': phoneNumber,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
Future<IdServerUnbindResult> deactivateAccount({
|
|
String idServer,
|
|
Map<String, dynamic> auth,
|
|
}) async {
|
|
final response =
|
|
await request(RequestType.POST, '/client/r0/account/deactivate', data: {
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (auth != null) 'auth': auth,
|
|
});
|
|
|
|
return IdServerUnbindResult.values.firstWhere(
|
|
(i) => describeEnum(i) == response['id_server_unbind_result'],
|
|
);
|
|
}
|
|
|
|
Future<bool> usernameAvailable(String username) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/register/available?username=$username',
|
|
);
|
|
return response['available'];
|
|
}
|
|
|
|
/// Gets a list of the third party identifiers that the homeserver has
|
|
/// associated with the user's account.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-register-available
|
|
Future<List<ThirdPartyIdentifier>> requestThirdPartyIdentifiers() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/account/3pid',
|
|
);
|
|
return (response['threepids'] as List)
|
|
.map((item) => ThirdPartyIdentifier.fromJson(item))
|
|
.toList();
|
|
}
|
|
|
|
/// Adds contact information to the user's account. Homeservers
|
|
/// should use 3PIDs added through this endpoint for password resets
|
|
/// instead of relying on the identity server.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-add
|
|
Future<void> addThirdPartyIdentifier(
|
|
String clientSecret,
|
|
String sid, {
|
|
Map<String, dynamic> auth,
|
|
}) async {
|
|
await request(RequestType.POST, '/client/r0/account/3pid/add', data: {
|
|
'sid': sid,
|
|
'client_secret': clientSecret,
|
|
if (auth != null && auth.isNotEmpty) 'auth': auth,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Binds a 3PID to the user's account through the specified identity server.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-bind
|
|
Future<void> bindThirdPartyIdentifier(
|
|
String clientSecret,
|
|
String sid,
|
|
String idServer,
|
|
String idAccessToken,
|
|
) async {
|
|
await request(RequestType.POST, '/client/r0/account/3pid/bind', data: {
|
|
'sid': sid,
|
|
'client_secret': clientSecret,
|
|
'id_server': idServer,
|
|
'id_access_token': idAccessToken,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Removes a third party identifier from the user's account. This might not cause an unbind of the identifier from the identity server.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-delete
|
|
Future<IdServerUnbindResult> deleteThirdPartyIdentifier(
|
|
String address,
|
|
ThirdPartyIdentifierMedium medium,
|
|
String idServer,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/3pid/delete',
|
|
data: {
|
|
'address': address,
|
|
'medium': describeEnum(medium),
|
|
'id_server': idServer,
|
|
});
|
|
return IdServerUnbindResult.values.firstWhere(
|
|
(i) => describeEnum(i) == response['id_server_unbind_result'],
|
|
);
|
|
}
|
|
|
|
/// Removes a user's third party identifier from the provided identity server without removing it from the homeserver.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-unbind
|
|
Future<IdServerUnbindResult> unbindThirdPartyIdentifier(
|
|
String address,
|
|
ThirdPartyIdentifierMedium medium,
|
|
String idServer,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/3pid/unbind',
|
|
data: {
|
|
'address': address,
|
|
'medium': describeEnum(medium),
|
|
'id_server': idServer,
|
|
});
|
|
return IdServerUnbindResult.values.firstWhere(
|
|
(i) => describeEnum(i) == response['id_server_unbind_result'],
|
|
);
|
|
}
|
|
|
|
/// This API should be used to request validation tokens when adding an email address to an account.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-email-requesttoken
|
|
Future<RequestTokenResponse> requestEmailValidationToken(
|
|
String email,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/3pid/email/requestToken',
|
|
data: {
|
|
'email': email,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
/// This API should be used to request validation tokens when adding a phone number to an account.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-account-3pid-msisdn-requesttoken
|
|
Future<RequestTokenResponse> requestMsisdnValidationToken(
|
|
String country,
|
|
String phoneNumber,
|
|
String clientSecret,
|
|
int sendAttempt, {
|
|
String nextLink,
|
|
String idServer,
|
|
String idAccessToken,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST, '/client/r0/account/3pid/msisdn/requestToken',
|
|
data: {
|
|
'country': country,
|
|
'phone_number': phoneNumber,
|
|
'send_attempt': sendAttempt,
|
|
'client_secret': clientSecret,
|
|
if (nextLink != null) 'next_link': nextLink,
|
|
if (idServer != null) 'id_server': idServer,
|
|
if (idAccessToken != null) 'id_access_token': idAccessToken,
|
|
});
|
|
return RequestTokenResponse.fromJson(response);
|
|
}
|
|
|
|
/// Gets information about the owner of a given access token.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-account-whoami
|
|
Future<String> whoAmI() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/account/whoami',
|
|
);
|
|
return response['user_id'];
|
|
}
|
|
|
|
/// Gets information about the server's supported feature set and other relevant capabilities.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-capabilities
|
|
Future<ServerCapabilities> requestServerCapabilities() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/capabilities',
|
|
);
|
|
return ServerCapabilities.fromJson(response['capabilities']);
|
|
}
|
|
|
|
/// Uploads a new filter definition to the homeserver. Returns a filter ID that may be used
|
|
/// in future requests to restrict which events are returned to the client.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-user-userid-filter
|
|
Future<String> uploadFilter(
|
|
String userId,
|
|
Filter filter,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/filter',
|
|
data: filter.toJson(),
|
|
);
|
|
return response['filter_id'];
|
|
}
|
|
|
|
/// Download a filter
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-client-r0-user-userid-filter
|
|
Future<Filter> downloadFilter(String userId, String filterId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/filter/${Uri.encodeComponent(filterId)}',
|
|
);
|
|
return Filter.fromJson(response);
|
|
}
|
|
|
|
/// Synchronise the client's state with the latest state on the server. Clients 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 deltas to the state, and to receive new messages.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-sync
|
|
Future<SyncUpdate> sync({
|
|
String filter,
|
|
String since,
|
|
bool fullState,
|
|
PresenceType setPresence,
|
|
int timeout,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/sync',
|
|
query: {
|
|
if (filter != null) 'filter': filter,
|
|
if (since != null) 'since': since,
|
|
if (fullState != null) 'full_state': fullState.toString(),
|
|
if (setPresence != null) 'set_presence': describeEnum(setPresence),
|
|
if (timeout != null) 'timeout': timeout.toString(),
|
|
},
|
|
);
|
|
return SyncUpdate.fromJson(response);
|
|
}
|
|
|
|
/// Get a single event based on roomId/eventId. You must have permission to
|
|
/// retrieve this event e.g. by being a member in the room for this event.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-event-eventid
|
|
Future<MatrixEvent> requestEvent(String roomId, String eventId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/event/${Uri.encodeComponent(eventId)}',
|
|
);
|
|
return MatrixEvent.fromJson(response);
|
|
}
|
|
|
|
/// Looks up the contents of a state event in a room. If the user is joined to the room then the
|
|
/// state is taken from the current state of the room. If the user has left the room then the
|
|
/// state is taken from the state of the room when they left.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-state-eventtype-statekey
|
|
Future<Map<String, dynamic>> requestStateContent(
|
|
String roomId, String eventType,
|
|
[String stateKey]) async {
|
|
var url =
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/state/${Uri.encodeComponent(eventType)}/';
|
|
if (stateKey != null) {
|
|
url += Uri.encodeComponent(stateKey);
|
|
}
|
|
final response = await request(
|
|
RequestType.GET,
|
|
url,
|
|
);
|
|
return response;
|
|
}
|
|
|
|
/// Get the state events for the current state of a room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-state
|
|
Future<List<MatrixEvent>> requestStates(String roomId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/state',
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => MatrixEvent.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// Get the list of members for this room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-members
|
|
Future<List<MatrixEvent>> requestMembers(
|
|
String roomId, {
|
|
String at,
|
|
Membership membership,
|
|
Membership notMembership,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/members',
|
|
query: {
|
|
if (at != null) 'at': at,
|
|
if (membership != null) 'membership': describeEnum(membership),
|
|
if (notMembership != null)
|
|
'not_membership': describeEnum(notMembership),
|
|
},
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => MatrixEvent.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// This API returns a map of MXIDs to member info objects for members of the room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-joined-members
|
|
Future<Map<String, Profile>> requestJoinedMembers(String roomId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/joined_members',
|
|
);
|
|
return (response['joined'] as Map).map(
|
|
(k, v) => MapEntry(k, Profile.fromJson(v)),
|
|
);
|
|
}
|
|
|
|
/// This API returns a list of message and state events for a room. It uses pagination query
|
|
/// parameters to paginate history in the room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-rooms-roomid-messages
|
|
Future<TimelineHistoryResponse> requestMessages(
|
|
String roomId,
|
|
String from,
|
|
Direction dir, {
|
|
String to,
|
|
int limit,
|
|
String filter,
|
|
}) async {
|
|
final response = await request(RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/messages',
|
|
query: {
|
|
'from': from,
|
|
'dir': describeEnum(dir),
|
|
if (to != null) 'to': to,
|
|
if (limit != null) 'limit': limit.toString(),
|
|
if (filter != null) 'filter': filter,
|
|
});
|
|
return TimelineHistoryResponse.fromJson(response);
|
|
}
|
|
|
|
/// State events can be sent using this endpoint.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#put-matrix-client-r0-rooms-roomid-state-eventtype-statekey
|
|
Future<String> sendState(
|
|
String roomId,
|
|
String eventType,
|
|
Map<String, dynamic> content, [
|
|
String stateKey = '',
|
|
]) async {
|
|
final response = await request(RequestType.PUT,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/state/${Uri.encodeComponent(eventType)}/${Uri.encodeComponent(stateKey)}',
|
|
data: content);
|
|
return response['event_id'];
|
|
}
|
|
|
|
/// This endpoint is used to send a message event to a room.
|
|
/// Message events allow access to historical events and pagination,
|
|
/// making them suited for "once-off" activity in a room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#put-matrix-client-r0-rooms-roomid-send-eventtype-txnid
|
|
Future<String> sendMessage(
|
|
String roomId,
|
|
String eventType,
|
|
String txnId,
|
|
Map<String, dynamic> content,
|
|
) async {
|
|
final response = await request(RequestType.PUT,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/send/${Uri.encodeComponent(eventType)}/${Uri.encodeComponent(txnId)}',
|
|
data: content);
|
|
return response['event_id'];
|
|
}
|
|
|
|
/// Strips all information out of an event which isn't critical to the integrity of
|
|
/// the server-side representation of the room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#put-matrix-client-r0-rooms-roomid-redact-eventid-txnid
|
|
Future<String> redact(
|
|
String roomId,
|
|
String eventId,
|
|
String txnId, {
|
|
String reason,
|
|
}) async {
|
|
final response = await request(RequestType.PUT,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/redact/${Uri.encodeComponent(eventId)}/${Uri.encodeComponent(txnId)}',
|
|
data: {
|
|
if (reason != null) 'reason': reason,
|
|
});
|
|
return response['event_id'];
|
|
}
|
|
|
|
Future<String> createRoom({
|
|
Visibility visibility,
|
|
String roomAliasName,
|
|
String name,
|
|
String topic,
|
|
List<String> invite,
|
|
List<Map<String, dynamic>> invite3pid,
|
|
String roomVersion,
|
|
Map<String, dynamic> creationContent,
|
|
List<Map<String, dynamic>> initialState,
|
|
CreateRoomPreset preset,
|
|
bool isDirect,
|
|
Map<String, dynamic> powerLevelContentOverride,
|
|
}) async {
|
|
final response =
|
|
await request(RequestType.POST, '/client/r0/createRoom', data: {
|
|
if (visibility != null) 'visibility': describeEnum(visibility),
|
|
if (roomAliasName != null) 'room_alias_name': roomAliasName,
|
|
if (name != null) 'name': name,
|
|
if (topic != null) 'topic': topic,
|
|
if (invite != null) 'invite': invite,
|
|
if (invite3pid != null) 'invite_3pid': invite3pid,
|
|
if (roomVersion != null) 'room_version': roomVersion,
|
|
if (creationContent != null) 'creation_content': creationContent,
|
|
if (initialState != null) 'initial_state': initialState,
|
|
if (preset != null) 'preset': describeEnum(preset),
|
|
if (isDirect != null) 'is_direct': isDirect,
|
|
if (powerLevelContentOverride != null)
|
|
'power_level_content_override': powerLevelContentOverride,
|
|
});
|
|
return response['room_id'];
|
|
}
|
|
|
|
/// Create a new mapping from room alias to room ID.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-directory-room-roomalias
|
|
Future<void> createRoomAlias(String alias, String roomId) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/directory/room/${Uri.encodeComponent(alias)}',
|
|
data: {'room_id': roomId},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Requests that the server resolve a room alias to a room ID.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-directory-room-roomalias
|
|
Future<RoomAliasInformations> requestRoomAliasInformations(
|
|
String alias) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/directory/room/${Uri.encodeComponent(alias)}',
|
|
);
|
|
return RoomAliasInformations.fromJson(response);
|
|
}
|
|
|
|
/// Remove a mapping of room alias to room ID.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#delete-matrix-client-r0-directory-room-roomalias
|
|
Future<void> removeRoomAlias(String alias) async {
|
|
await request(
|
|
RequestType.DELETE,
|
|
'/client/r0/directory/room/${Uri.encodeComponent(alias)}',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get a list of aliases maintained by the local server for the given room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-rooms-roomid-aliases
|
|
Future<List<String>> requestRoomAliases(String roomId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/room/${Uri.encodeComponent(roomId)}/aliases',
|
|
);
|
|
return List<String>.from(response['aliases']);
|
|
}
|
|
|
|
/// This API returns a list of the user's current rooms.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-joined-rooms
|
|
Future<List<String>> requestJoinedRooms() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/joined_rooms',
|
|
);
|
|
return List<String>.from(response['joined_rooms']);
|
|
}
|
|
|
|
/// This API invites a user to participate in a particular room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-invite
|
|
Future<void> inviteToRoom(String roomId, String userId) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/invite',
|
|
data: {
|
|
'user_id': userId,
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This API starts a user participating in a particular room, if that user is allowed to participate in that room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-invite
|
|
Future<String> joinRoom(
|
|
String roomId, {
|
|
String thirdPidSignedSender,
|
|
String thirdPidSignedmxid,
|
|
String thirdPidSignedToken,
|
|
Map<String, dynamic> thirdPidSignedSiganture,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/join',
|
|
data: {
|
|
if (thirdPidSignedSiganture != null)
|
|
'third_party_signed': {
|
|
'sender': thirdPidSignedSender,
|
|
'mxid': thirdPidSignedmxid,
|
|
'token': thirdPidSignedToken,
|
|
'signatures': thirdPidSignedSiganture,
|
|
}
|
|
},
|
|
);
|
|
return response['room_id'];
|
|
}
|
|
|
|
/// This API starts a user participating in a particular room, if that user is allowed to participate in that room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-join-roomidoralias
|
|
Future<String> joinRoomOrAlias(
|
|
String roomIdOrAlias, {
|
|
List<String> servers,
|
|
String thirdPidSignedSender,
|
|
String thirdPidSignedmxid,
|
|
String thirdPidSignedToken,
|
|
Map<String, dynamic> thirdPidSignedSiganture,
|
|
}) async {
|
|
var action = '/client/r0/join/${Uri.encodeComponent(roomIdOrAlias)}';
|
|
final queryPart = servers
|
|
?.map((x) => 'server_name=${Uri.encodeQueryComponent(x)}')
|
|
?.join('&');
|
|
if (queryPart != null && queryPart != '') {
|
|
action += '?' + queryPart;
|
|
}
|
|
final response = await request(
|
|
RequestType.POST,
|
|
action,
|
|
data: {
|
|
if (thirdPidSignedSiganture != null)
|
|
'third_party_signed': {
|
|
'sender': thirdPidSignedSender,
|
|
'mxid': thirdPidSignedmxid,
|
|
'token': thirdPidSignedToken,
|
|
'signatures': thirdPidSignedSiganture,
|
|
}
|
|
},
|
|
);
|
|
return response['room_id'];
|
|
}
|
|
|
|
/// This API stops a user participating in a particular room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-leave
|
|
Future<void> leaveRoom(String roomId) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/leave',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This API stops a user remembering about a particular room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-forget
|
|
Future<void> forgetRoom(String roomId) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/forget',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Kick a user from the room.
|
|
/// The caller must have the required power level in order to perform this operation.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-kick
|
|
Future<void> kickFromRoom(String roomId, String userId,
|
|
{String reason}) async {
|
|
await request(RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/kick',
|
|
data: {
|
|
'user_id': userId,
|
|
if (reason != null) 'reason': reason,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Ban a user in the room. If the user is currently in the room, also kick them.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-ban
|
|
Future<void> banFromRoom(String roomId, String userId,
|
|
{String reason}) async {
|
|
await request(
|
|
RequestType.POST, '/client/r0/rooms/${Uri.encodeComponent(roomId)}/ban',
|
|
data: {
|
|
'user_id': userId,
|
|
if (reason != null) 'reason': reason,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Unban a user from the room. This allows them to be invited to the room, and join if they
|
|
/// would otherwise be allowed to join according to its join rules.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-unban
|
|
Future<void> unbanInRoom(String roomId, String userId) async {
|
|
await request(
|
|
RequestType.POST, '/client/r0/rooms/${Uri.encodeComponent(roomId)}/ban',
|
|
data: {
|
|
'user_id': userId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Gets the visibility of a given room on the server's public room directory.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-directory-list-room-roomid
|
|
Future<Visibility> requestRoomVisibility(String roomId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/directory/list/room/${Uri.encodeComponent(roomId)}',
|
|
);
|
|
return Visibility.values
|
|
.firstWhere((v) => describeEnum(v) == response['visibility']);
|
|
}
|
|
|
|
/// Sets the visibility of a given room in the server's public room directory.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-directory-list-room-roomid
|
|
Future<void> setRoomVisibility(String roomId, Visibility visibility) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/directory/list/room/${Uri.encodeComponent(roomId)}',
|
|
data: {
|
|
'visibility': describeEnum(visibility),
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Lists the public rooms on the server.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-publicrooms
|
|
Future<PublicRoomsResponse> requestPublicRooms({
|
|
int limit,
|
|
String since,
|
|
String server,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/publicRooms',
|
|
query: {
|
|
if (limit != null) 'limit': limit.toString(),
|
|
if (since != null) 'since': since,
|
|
if (server != null) 'server': server,
|
|
},
|
|
);
|
|
return PublicRoomsResponse.fromJson(response);
|
|
}
|
|
|
|
/// Lists the public rooms on the server, with optional filter.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-publicrooms
|
|
Future<PublicRoomsResponse> searchPublicRooms({
|
|
String genericSearchTerm,
|
|
int limit,
|
|
String since,
|
|
String server,
|
|
bool includeAllNetworks,
|
|
String thirdPartyInstanceId,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/publicRooms',
|
|
query: {
|
|
if (server != null) 'server': server,
|
|
},
|
|
data: {
|
|
if (limit != null) 'limit': limit,
|
|
if (since != null) 'since': since,
|
|
if (includeAllNetworks != null)
|
|
'include_all_networks': includeAllNetworks,
|
|
if (thirdPartyInstanceId != null)
|
|
'third_party_instance_id': thirdPartyInstanceId,
|
|
if (genericSearchTerm != null)
|
|
'filter': {
|
|
'generic_search_term': genericSearchTerm,
|
|
},
|
|
},
|
|
);
|
|
return PublicRoomsResponse.fromJson(response);
|
|
}
|
|
|
|
/// Performs a search for users. The homeserver may determine which subset of users are searched,
|
|
/// however the homeserver MUST at a minimum consider the users the requesting user shares a
|
|
/// room with and those who reside in public rooms (known to the homeserver). The search MUST
|
|
/// consider local users to the homeserver, and SHOULD query remote users as part of the search.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-user-directory-search
|
|
Future<UserSearchResult> searchUser(
|
|
String searchTerm, {
|
|
int limit,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/user_directory/search',
|
|
data: {
|
|
'search_term': searchTerm,
|
|
if (limit != null) 'limit': limit,
|
|
},
|
|
);
|
|
return UserSearchResult.fromJson(response);
|
|
}
|
|
|
|
/// This API sets the given user's display name. You must have permission to
|
|
/// set this user's display name, e.g. you need to have their access_token.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-profile-userid-displayname
|
|
Future<void> setDisplayname(String userId, String displayname) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/profile/${Uri.encodeComponent(userId)}/displayname',
|
|
data: {
|
|
'displayname': displayname,
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get the user's display name. This API may be used to fetch the user's own
|
|
/// displayname or to query the name of other users; either locally or on remote homeservers.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-profile-userid-displayname
|
|
Future<String> requestDisplayname(String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/profile/${Uri.encodeComponent(userId)}/displayname',
|
|
);
|
|
return response['displayname'];
|
|
}
|
|
|
|
/// This API sets the given user's avatar URL. You must have permission to set
|
|
/// this user's avatar URL, e.g. you need to have their access_token.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-profile-userid-avatar-url
|
|
Future<void> setAvatarUrl(String userId, Uri avatarUrl) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/profile/${Uri.encodeComponent(userId)}/avatar_url',
|
|
data: {
|
|
'avatar_url': avatarUrl.toString(),
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get the user's avatar URL. This API may be used to fetch the user's own avatar URL or to
|
|
/// query the URL of other users; either locally or on remote homeservers.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-profile-userid-avatar-url
|
|
Future<Uri> requestAvatarUrl(String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/profile/${Uri.encodeComponent(userId)}/avatar_url',
|
|
);
|
|
return Uri.parse(response['avatar_url']);
|
|
}
|
|
|
|
/// Get the combined profile information for this user. This API may be used to fetch the user's
|
|
/// own profile information or other users; either locally or on remote homeservers.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-profile-userid-avatar-url
|
|
Future<Profile> requestProfile(String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/profile/${Uri.encodeComponent(userId)}',
|
|
);
|
|
return Profile.fromJson(response);
|
|
}
|
|
|
|
/// This API provides credentials for the client to use when initiating calls.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-voip-turnserver
|
|
Future<TurnServerCredentials> requestTurnServerCredentials() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/voip/turnServer',
|
|
);
|
|
return TurnServerCredentials.fromJson(response);
|
|
}
|
|
|
|
/// This tells the server that the user is typing for the next N milliseconds
|
|
/// where N is the value specified in the timeout key. Alternatively, if typing is false,
|
|
/// it tells the server that the user has stopped typing.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-rooms-roomid-typing-userid
|
|
Future<void> sendTypingNotification(
|
|
String userId,
|
|
String roomId,
|
|
bool typing, {
|
|
int timeout,
|
|
}) async {
|
|
await request(RequestType.PUT,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/typing/${Uri.encodeComponent(userId)}',
|
|
data: {
|
|
'typing': typing,
|
|
if (timeout != null) 'timeout': timeout,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// This API updates the marker for the given receipt type to the event ID specified.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-receipt-receipttype-eventid
|
|
///
|
|
Future<void> sendReceiptMarker(String roomId, String eventId) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/receipt/m.read/${Uri.encodeComponent(eventId)}',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Sets the position of the read marker for a given room, and optionally the read receipt's location.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-read-markers
|
|
Future<void> sendReadMarker(String roomId, String eventId,
|
|
{String readReceiptLocationEventId}) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/read_markers',
|
|
data: {
|
|
'm.fully_read': eventId,
|
|
if (readReceiptLocationEventId != null)
|
|
'm.read': readReceiptLocationEventId,
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This API sets the given user's presence state. When setting the status,
|
|
/// the activity time is updated to reflect that activity; the client does not need
|
|
/// to specify the last_active_ago field. You cannot set the presence state of another user.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-presence-userid-status
|
|
Future<void> sendPresence(
|
|
String userId,
|
|
PresenceType presenceType, {
|
|
String statusMsg,
|
|
}) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/presence/${Uri.encodeComponent(userId)}/status',
|
|
data: {
|
|
'presence': describeEnum(presenceType),
|
|
if (statusMsg != null) 'status_msg': statusMsg,
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get the given user's presence state.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-presence-userid-status
|
|
Future<PresenceContent> requestPresence(String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/presence/${Uri.encodeComponent(userId)}/status',
|
|
);
|
|
return PresenceContent.fromJson(response);
|
|
}
|
|
|
|
/// Uploads a file with the name [fileName] as base64 encoded to the server
|
|
/// and returns the mxc url as a string.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.0#post-matrix-media-r0-upload
|
|
Future<String> upload(Uint8List file, String fileName,
|
|
{String contentType}) async {
|
|
fileName = fileName.split('/').last;
|
|
var headers = <String, String>{};
|
|
headers['Authorization'] = 'Bearer $accessToken';
|
|
headers['Content-Type'] =
|
|
contentType ?? lookupMimeType(fileName, headerBytes: file);
|
|
fileName = Uri.encodeQueryComponent(fileName);
|
|
final url =
|
|
'${homeserver.toString()}/_matrix/media/r0/upload?filename=$fileName';
|
|
final streamedRequest = http.StreamedRequest('POST', Uri.parse(url))
|
|
..headers.addAll(headers);
|
|
streamedRequest.contentLength = await file.length;
|
|
streamedRequest.sink.add(file);
|
|
streamedRequest.sink.close();
|
|
var streamedResponse = _testMode ? null : await streamedRequest.send();
|
|
Map<String, dynamic> jsonResponse = json.decode(
|
|
String.fromCharCodes(_testMode
|
|
? ((fileName == 'file.jpeg')
|
|
? '{"content_uri": "mxc://example.com/AQwafuaFswefuhsfAFAgsw"}'
|
|
: '{"errcode":"M_FORBIDDEN","error":"Cannot upload this content"}')
|
|
.codeUnits
|
|
: await streamedResponse.stream.first),
|
|
);
|
|
if (!(jsonResponse['content_uri'] is String)) {
|
|
throw MatrixException.fromJson(jsonResponse);
|
|
}
|
|
return jsonResponse['content_uri'];
|
|
}
|
|
|
|
/// Get information about a URL for the client. Typically this is called when a client sees a
|
|
/// URL in a message and wants to render a preview for the user.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-media-r0-preview-url
|
|
Future<OpenGraphData> requestOpenGraphDataForUrl(Uri url, {int ts}) async {
|
|
var action =
|
|
'${homeserver.toString()}/_matrix/media/r0/preview_url?url=${Uri.encodeQueryComponent(url.toString())}';
|
|
if (ts != null) {
|
|
action += '&ts=${Uri.encodeQueryComponent(ts.toString())}';
|
|
}
|
|
final response = await httpClient.get(action);
|
|
final rawJson = json.decode(response.body.isEmpty ? '{}' : response.body);
|
|
return OpenGraphData.fromJson(rawJson);
|
|
}
|
|
|
|
/// This endpoint allows clients to retrieve the configuration of the content repository, such as upload limitations.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-media-r0-config
|
|
Future<int> requestMaxUploadSize() async {
|
|
var action = '${homeserver.toString()}/_matrix/media/r0/config';
|
|
final response = await httpClient.get(action);
|
|
final rawJson = json.decode(response.body.isEmpty ? '{}' : response.body);
|
|
return rawJson['m.upload.size'];
|
|
}
|
|
|
|
/// This endpoint is used to send send-to-device events to a set of client devices.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-sendtodevice-eventtype-txnid
|
|
Future<void> sendToDevice(String eventType, String txnId,
|
|
Map<String, Map<String, Map<String, dynamic>>> messages) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/sendToDevice/${Uri.encodeComponent(eventType)}/${Uri.encodeComponent(txnId)}',
|
|
data: {
|
|
'messages': messages,
|
|
},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Gets information about all devices for the current user.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-devices
|
|
Future<List<Device>> requestDevices() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/devices',
|
|
);
|
|
return (response['devices'] as List)
|
|
.map((i) => Device.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// Gets information on a single device, by device id.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-devices-deviceid
|
|
Future<Device> requestDevice(String deviceId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/devices/${Uri.encodeComponent(deviceId)}',
|
|
);
|
|
return Device.fromJson(response);
|
|
}
|
|
|
|
/// Updates the metadata on the given device.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-devices-deviceid
|
|
Future<void> setDeviceMetadata(String deviceId, {String displayName}) async {
|
|
await request(
|
|
RequestType.PUT, '/client/r0/devices/${Uri.encodeComponent(deviceId)}',
|
|
data: {
|
|
if (displayName != null) 'display_name': displayName,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Deletes the given device, and invalidates any access token associated with it.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#delete-matrix-client-r0-devices-deviceid
|
|
Future<void> deleteDevice(String deviceId,
|
|
{Map<String, dynamic> auth}) async {
|
|
await request(RequestType.DELETE,
|
|
'/client/r0/devices/${Uri.encodeComponent(deviceId)}',
|
|
data: {
|
|
if (auth != null) 'auth': auth,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Deletes the given devices, and invalidates any access token associated with them.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-delete-devices
|
|
Future<void> deleteDevices(List<String> deviceIds,
|
|
{Map<String, dynamic> auth}) async {
|
|
await request(RequestType.POST, '/client/r0/delete_devices', data: {
|
|
'devices': deviceIds,
|
|
if (auth != null) 'auth': auth,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Publishes end-to-end encryption keys for the device.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-keys-query
|
|
Future<Map<String, int>> uploadDeviceKeys(
|
|
{MatrixDeviceKeys deviceKeys, Map<String, dynamic> oneTimeKeys}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/keys/upload',
|
|
data: {
|
|
if (deviceKeys != null) 'device_keys': deviceKeys.toJson(),
|
|
if (oneTimeKeys != null) 'one_time_keys': oneTimeKeys,
|
|
},
|
|
);
|
|
return Map<String, int>.from(response['one_time_key_counts']);
|
|
}
|
|
|
|
/// Returns the current devices and identity keys for the given users.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-keys-query
|
|
Future<KeysQueryResponse> requestDeviceKeys(
|
|
Map<String, dynamic> deviceKeys, {
|
|
int timeout,
|
|
String token,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/keys/query',
|
|
data: {
|
|
'device_keys': deviceKeys,
|
|
if (timeout != null) 'timeout': timeout,
|
|
if (token != null) 'token': token,
|
|
},
|
|
);
|
|
return KeysQueryResponse.fromJson(response);
|
|
}
|
|
|
|
/// Claims one-time keys for use in pre-key messages.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-keys-claim
|
|
Future<OneTimeKeysClaimResponse> requestOneTimeKeys(
|
|
Map<String, Map<String, String>> oneTimeKeys, {
|
|
int timeout,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/keys/claim',
|
|
data: {
|
|
'one_time_keys': oneTimeKeys,
|
|
if (timeout != null) 'timeout': timeout,
|
|
},
|
|
);
|
|
return OneTimeKeysClaimResponse.fromJson(response);
|
|
}
|
|
|
|
/// Gets a list of users who have updated their device identity keys since a previous sync token.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-keys-upload
|
|
Future<DeviceListsUpdate> requestDeviceListsUpdate(
|
|
String from, String to) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/keys/changes?from=${Uri.encodeQueryComponent(from)}&to=${Uri.encodeQueryComponent(to)}',
|
|
);
|
|
return DeviceListsUpdate.fromJson(response);
|
|
}
|
|
|
|
/// Uploads your own cross-signing keys.
|
|
/// https://github.com/matrix-org/matrix-doc/pull/2536
|
|
Future<void> uploadDeviceSigningKeys({
|
|
MatrixCrossSigningKey masterKey,
|
|
MatrixCrossSigningKey selfSigningKey,
|
|
MatrixCrossSigningKey userSigningKey,
|
|
}) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/keys/device_signing/upload',
|
|
data: {
|
|
'master_key': masterKey.toJson(),
|
|
'self_signing_key': selfSigningKey.toJson(),
|
|
'user_signing_key': userSigningKey.toJson(),
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Uploads new signatures of keys
|
|
/// https://github.com/matrix-org/matrix-doc/pull/2536
|
|
Future<UploadKeySignaturesResponse> uploadKeySignatures(
|
|
List<MatrixSignableKey> keys) async {
|
|
final payload = <String, dynamic>{};
|
|
for (final key in keys) {
|
|
if (key.identifier == null ||
|
|
key.signatures == null ||
|
|
key.signatures.isEmpty) {
|
|
continue;
|
|
}
|
|
if (!payload.containsKey(key.userId)) {
|
|
payload[key.userId] = <String, dynamic>{};
|
|
}
|
|
if (payload[key.userId].containsKey(key.identifier)) {
|
|
// we need to merge signature objects
|
|
payload[key.userId][key.identifier]['signatures']
|
|
.addAll(key.signatures);
|
|
} else {
|
|
// we can just add signatures
|
|
payload[key.userId][key.identifier] = key.toJson();
|
|
}
|
|
}
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/keys/signatures/upload',
|
|
data: payload,
|
|
);
|
|
return UploadKeySignaturesResponse.fromJson(response);
|
|
}
|
|
|
|
/// Gets all currently active pushers for the authenticated user.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-pushers
|
|
Future<List<Pusher>> requestPushers() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/pushers',
|
|
);
|
|
return (response['pushers'] as List)
|
|
.map((i) => Pusher.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// This endpoint allows the creation, modification and deletion of pushers
|
|
/// for this user ID. The behaviour of this endpoint varies depending on the
|
|
/// values in the JSON body.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-pushers-set
|
|
Future<void> setPusher(Pusher pusher, {bool append}) async {
|
|
var data = pusher.toJson();
|
|
if (append != null) {
|
|
data['append'] = append;
|
|
}
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/pushers/set',
|
|
data: data,
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This API is used to paginate through the list of events that the user has
|
|
/// been, or would have been notified about.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-notifications
|
|
Future<NotificationsQueryResponse> requestNotifications({
|
|
String from,
|
|
int limit,
|
|
String only,
|
|
}) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/notifications',
|
|
query: {
|
|
if (from != null) 'from': from,
|
|
if (limit != null) 'limit': limit.toString(),
|
|
if (only != null) 'only': only,
|
|
},
|
|
);
|
|
return NotificationsQueryResponse.fromJson(response);
|
|
}
|
|
|
|
/// Retrieve all push rulesets for this user. Clients can "drill-down"
|
|
/// on the rulesets by suffixing a scope to this path e.g. /pushrules/global/.
|
|
/// This will return a subset of this data under the specified key e.g. the global key.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-pushrules
|
|
Future<PushRuleSet> requestPushRules() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/pushrules',
|
|
);
|
|
return PushRuleSet.fromJson(response['global']);
|
|
}
|
|
|
|
/// Retrieve a single specified push rule.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-pushrules-scope-kind-ruleid
|
|
Future<PushRule> requestPushRule(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}',
|
|
);
|
|
return PushRule.fromJson(response);
|
|
}
|
|
|
|
/// This endpoint removes the push rule defined in the path.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#delete-matrix-client-r0-pushrules-scope-kind-ruleid
|
|
Future<void> deletePushRule(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
) async {
|
|
await request(
|
|
RequestType.DELETE,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This endpoint allows the creation, modification and deletion of pushers for this user ID.
|
|
/// The behaviour of this endpoint varies depending on the values in the JSON body.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-pushrules-scope-kind-ruleid
|
|
Future<void> setPushRule(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
List<PushRuleAction> actions, {
|
|
String before,
|
|
String after,
|
|
List<PushConditions> conditions,
|
|
String pattern,
|
|
}) async {
|
|
await request(RequestType.PUT,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}',
|
|
query: {
|
|
if (before != null) 'before': before,
|
|
if (after != null) 'after': after,
|
|
},
|
|
data: {
|
|
'actions': actions.map(describeEnum).toList(),
|
|
if (conditions != null)
|
|
'conditions': conditions.map((c) => c.toJson()).toList(),
|
|
if (pattern != null) 'pattern': pattern,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// This endpoint gets whether the specified push rule is enabled.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-pushrules-scope-kind-ruleid-enabled
|
|
Future<bool> requestPushRuleEnabled(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}/enabled',
|
|
);
|
|
return response['enabled'];
|
|
}
|
|
|
|
/// This endpoint allows clients to enable or disable the specified push rule.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-pushrules-scope-kind-ruleid-enabled
|
|
Future<void> enablePushRule(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
bool enabled,
|
|
) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}/enabled',
|
|
data: {'enabled': enabled},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// This endpoint get the actions for the specified push rule.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-pushrules-scope-kind-ruleid-actions
|
|
Future<List<PushRuleAction>> requestPushRuleActions(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}/actions',
|
|
);
|
|
return (response['actions'] as List)
|
|
.map((i) =>
|
|
PushRuleAction.values.firstWhere((a) => describeEnum(a) == i))
|
|
.toList();
|
|
}
|
|
|
|
/// This endpoint allows clients to change the actions of a push rule. This can be used to change the actions of builtin rules.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-pushrules-scope-kind-ruleid-actions
|
|
Future<void> setPushRuleActions(
|
|
String scope,
|
|
PushRuleKind kind,
|
|
String ruleId,
|
|
List<PushRuleAction> actions,
|
|
) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/pushrules/${Uri.encodeComponent(scope)}/${Uri.encodeComponent(describeEnum(kind))}/${Uri.encodeComponent(ruleId)}/actions',
|
|
data: {'actions': actions.map((a) => describeEnum(a)).toList()},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Performs a full text search across different categories.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-search
|
|
/// Please note: The specification is not 100% clear what it is expecting and sending here.
|
|
/// So we stick with pure json until we have more informations.
|
|
Future<Map<String, dynamic>> globalSearch(Map<String, dynamic> query) async {
|
|
return await request(
|
|
RequestType.POST,
|
|
'/client/r0/search',
|
|
data: query,
|
|
);
|
|
}
|
|
|
|
/// This will listen for new events related to a particular room and return them to the
|
|
/// caller. This will block until an event is received, or until the timeout is reached.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-events
|
|
Future<EventsSyncUpdate> requestEvents({
|
|
String from,
|
|
int timeout,
|
|
String roomId,
|
|
}) async {
|
|
final response =
|
|
await request(RequestType.GET, '/client/r0/events', query: {
|
|
if (from != null) 'from': from,
|
|
if (timeout != null) 'timeout': timeout.toString(),
|
|
if (roomId != null) 'roomId': roomId,
|
|
});
|
|
return EventsSyncUpdate.fromJson(response);
|
|
}
|
|
|
|
/// List the tags set by a user on a room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-user-userid-rooms-roomid-tags
|
|
Future<Map<String, Tag>> requestRoomTags(String userId, String roomId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/rooms/${Uri.encodeComponent(roomId)}/tags',
|
|
);
|
|
return (response['tags'] as Map).map(
|
|
(k, v) => MapEntry(k, Tag.fromJson(v)),
|
|
);
|
|
}
|
|
|
|
/// Add a tag to the room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-user-userid-rooms-roomid-tags-tag
|
|
Future<void> addRoomTag(
|
|
String userId,
|
|
String roomId,
|
|
String tag, {
|
|
double order,
|
|
}) async {
|
|
await request(RequestType.PUT,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/rooms/${Uri.encodeComponent(roomId)}/tags/${Uri.encodeComponent(tag)}',
|
|
data: {
|
|
if (order != null) 'order': order,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Remove a tag from the room.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-user-userid-rooms-roomid-tags-tag
|
|
Future<void> removeRoomTag(String userId, String roomId, String tag) async {
|
|
await request(
|
|
RequestType.DELETE,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/rooms/${Uri.encodeComponent(roomId)}/tags/${Uri.encodeComponent(tag)}',
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Set some account_data for the client. This config is only visible to the user that set the account_data.
|
|
/// The config will be synced to clients in the top-level account_data.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-user-userid-account-data-type
|
|
Future<void> setAccountData(
|
|
String userId,
|
|
String type,
|
|
Map<String, dynamic> content,
|
|
) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/account_data/${Uri.encodeComponent(type)}',
|
|
data: content,
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get some account_data for the client. This config is only visible to the user that set the account_data.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-user-userid-account-data-type
|
|
Future<Map<String, dynamic>> requestAccountData(
|
|
String userId,
|
|
String type,
|
|
) async {
|
|
return await request(
|
|
RequestType.GET,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/account_data/${Uri.encodeComponent(type)}',
|
|
);
|
|
}
|
|
|
|
/// Set some account_data for the client on a given room. This config is only visible to the user that set
|
|
/// the account_data. The config will be synced to clients in the per-room account_data.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-user-userid-rooms-roomid-account-data-type
|
|
Future<void> setRoomAccountData(
|
|
String userId,
|
|
String roomId,
|
|
String type,
|
|
Map<String, dynamic> content,
|
|
) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/rooms/${Uri.encodeComponent(roomId)}/account_data/${Uri.encodeComponent(type)}',
|
|
data: content,
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Get some account_data for the client on a given room. This config is only visible to the user that set the account_data.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-user-userid-rooms-roomid-account-data-type
|
|
Future<Map<String, dynamic>> requestRoomAccountData(
|
|
String userId,
|
|
String roomId,
|
|
String type,
|
|
) async {
|
|
return await request(
|
|
RequestType.GET,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/rooms/${Uri.encodeComponent(roomId)}/account_data/${Uri.encodeComponent(type)}',
|
|
);
|
|
}
|
|
|
|
/// Gets information about a particular user.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-admin-whois-userid
|
|
Future<WhoIsInfo> requestWhoIsInfo(String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/admin/whois/${Uri.encodeComponent(userId)}',
|
|
);
|
|
return WhoIsInfo.fromJson(response);
|
|
}
|
|
|
|
/// This API returns a number of events that happened just before and after the specified event.
|
|
/// This allows clients to get the context surrounding an event.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-rooms-roomid-context-eventid
|
|
Future<EventContext> requestEventContext(
|
|
String roomId,
|
|
String eventId, {
|
|
int limit,
|
|
String filter,
|
|
}) async {
|
|
final response = await request(RequestType.GET,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/context/${Uri.encodeComponent(eventId)}',
|
|
query: {
|
|
if (filter != null) 'filter': filter,
|
|
if (limit != null) 'limit': limit.toString(),
|
|
});
|
|
return EventContext.fromJson(response);
|
|
}
|
|
|
|
/// Reports an event as inappropriate to the server, which may then notify the appropriate people.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#post-matrix-client-r0-rooms-roomid-report-eventid
|
|
Future<void> reportEvent(
|
|
String roomId,
|
|
String eventId,
|
|
String reason,
|
|
int score,
|
|
) async {
|
|
await request(RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/report/${Uri.encodeComponent(eventId)}',
|
|
data: {
|
|
'reason': reason,
|
|
'score': score,
|
|
});
|
|
return;
|
|
}
|
|
|
|
/// Fetches the overall metadata about protocols supported by the homeserver. Includes
|
|
/// both the available protocols and all fields required for queries against each protocol.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-protocols
|
|
Future<Map<String, SupportedProtocol>> requestSupportedProtocols() async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/protocols',
|
|
);
|
|
return response.map((k, v) => MapEntry(k, SupportedProtocol.fromJson(v)));
|
|
}
|
|
|
|
/// Fetches the metadata from the homeserver about a particular third party protocol.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-protocol-protocol
|
|
Future<SupportedProtocol> requestSupportedProtocol(String protocol) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/protocol/${Uri.encodeComponent(protocol)}',
|
|
);
|
|
return SupportedProtocol.fromJson(response);
|
|
}
|
|
|
|
/// Requesting this endpoint with a valid protocol name results in a list of successful
|
|
/// mapping results in a JSON array.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-location-protocol
|
|
Future<List<ThirdPartyLocation>> requestThirdPartyLocations(
|
|
String protocol) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/location/${Uri.encodeComponent(protocol)}',
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => ThirdPartyLocation.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// Retrieve a Matrix User ID linked to a user on the third party service, given a set of
|
|
/// user parameters.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-user-protocol
|
|
Future<List<ThirdPartyUser>> requestThirdPartyUsers(String protocol) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/user/${Uri.encodeComponent(protocol)}',
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => ThirdPartyUser.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// Retrieve an array of third party network locations from a Matrix room alias.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-location
|
|
Future<List<ThirdPartyLocation>> requestThirdPartyLocationsByAlias(
|
|
String alias) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/location?alias=${Uri.encodeComponent(alias)}',
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => ThirdPartyLocation.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
/// Retrieve an array of third party users from a Matrix User ID.
|
|
/// https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-thirdparty-user
|
|
Future<List<ThirdPartyUser>> requestThirdPartyUsersByUserId(
|
|
String userId) async {
|
|
final response = await request(
|
|
RequestType.GET,
|
|
'/client/r0/thirdparty/user?userid=${Uri.encodeComponent(userId)}',
|
|
);
|
|
return (response['chunk'] as List)
|
|
.map((i) => ThirdPartyUser.fromJson(i))
|
|
.toList();
|
|
}
|
|
|
|
Future<OpenIdCredentials> requestOpenIdCredentials(String userId) async {
|
|
final response = await request(
|
|
RequestType.POST,
|
|
'/client/r0/user/${Uri.encodeComponent(userId)}/openid/request_token',
|
|
data: {},
|
|
);
|
|
return OpenIdCredentials.fromJson(response);
|
|
}
|
|
|
|
Future<void> upgradeRoom(String roomId, String version) async {
|
|
await request(
|
|
RequestType.POST,
|
|
'/client/r0/rooms/${Uri.encodeComponent(roomId)}/upgrade',
|
|
data: {'new_version': version},
|
|
);
|
|
return;
|
|
}
|
|
|
|
/// Create room keys backup
|
|
/// https://matrix.org/docs/spec/client_server/unstable#post-matrix-client-r0-room-keys-version
|
|
Future<String> createRoomKeysBackup(
|
|
RoomKeysAlgorithmType algorithm, Map<String, dynamic> authData) async {
|
|
final ret = await request(
|
|
RequestType.POST,
|
|
'/client/unstable/room_keys/version',
|
|
data: {
|
|
'algorithm': algorithm.algorithmString,
|
|
'auth_data': authData,
|
|
},
|
|
);
|
|
return ret['version'];
|
|
}
|
|
|
|
/// Gets a room key backup
|
|
/// https://matrix.org/docs/spec/client_server/unstable#get-matrix-client-r0-room-keys-version
|
|
Future<RoomKeysVersionResponse> getRoomKeysBackup([String version]) async {
|
|
var url = '/client/unstable/room_keys/version';
|
|
if (version != null) {
|
|
url += '/${Uri.encodeComponent(version)}';
|
|
}
|
|
final ret = await request(
|
|
RequestType.GET,
|
|
url,
|
|
);
|
|
return RoomKeysVersionResponse.fromJson(ret);
|
|
}
|
|
|
|
/// Updates a room key backup
|
|
/// https://matrix.org/docs/spec/client_server/unstable#put-matrix-client-r0-room-keys-version-version
|
|
Future<void> updateRoomKeysBackup(String version,
|
|
RoomKeysAlgorithmType algorithm, Map<String, dynamic> authData) async {
|
|
await request(
|
|
RequestType.PUT,
|
|
'/client/unstable/room_keys/version/${Uri.encodeComponent(version)}',
|
|
data: {
|
|
'algorithm': algorithm.algorithmString,
|
|
'auth_data': authData,
|
|
'version': version,
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Deletes a room key backup
|
|
/// https://matrix.org/docs/spec/client_server/unstable#delete-matrix-client-r0-room-keys-version-version
|
|
Future<void> deleteRoomKeysBackup(String version) async {
|
|
await request(
|
|
RequestType.DELETE,
|
|
'/client/unstable/room_keys/version/${Uri.encodeComponent(version)}',
|
|
);
|
|
}
|
|
|
|
/// Stores a single room key
|
|
/// https://matrix.org/docs/spec/client_server/unstable#put-matrix-client-r0-room-keys-keys-roomid-sessionid
|
|
Future<RoomKeysUpdateResponse> storeRoomKeysSingleKey(String roomId,
|
|
String sessionId, String version, RoomKeysSingleKey session) async {
|
|
final ret = await request(
|
|
RequestType.PUT,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}/${Uri.encodeComponent(sessionId)}?version=${Uri.encodeComponent(version)}',
|
|
data: session.toJson(),
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
|
|
/// Gets a single room key
|
|
/// https://matrix.org/docs/spec/client_server/unstable#get-matrix-client-r0-room-keys-keys-roomid-sessionid
|
|
Future<RoomKeysSingleKey> getRoomKeysSingleKey(
|
|
String roomId, String sessionId, String version) async {
|
|
final ret = await request(
|
|
RequestType.GET,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}/${Uri.encodeComponent(sessionId)}?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeysSingleKey.fromJson(ret);
|
|
}
|
|
|
|
/// Deletes a single room key
|
|
/// https://matrix.org/docs/spec/client_server/unstable#delete-matrix-client-r0-room-keys-keys-roomid-sessionid
|
|
Future<RoomKeysUpdateResponse> deleteRoomKeysSingleKey(
|
|
String roomId, String sessionId, String version) async {
|
|
final ret = await request(
|
|
RequestType.DELETE,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}/${Uri.encodeComponent(sessionId)}?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
|
|
/// Stores room keys for a room
|
|
/// https://matrix.org/docs/spec/client_server/unstable#put-matrix-client-r0-room-keys-keys-roomid
|
|
Future<RoomKeysUpdateResponse> storeRoomKeysRoom(
|
|
String roomId, String version, RoomKeysRoom keys) async {
|
|
final ret = await request(
|
|
RequestType.PUT,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}?version=${Uri.encodeComponent(version)}',
|
|
data: keys.toJson(),
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
|
|
/// Gets room keys for a room
|
|
/// https://matrix.org/docs/spec/client_server/unstable#get-matrix-client-r0-room-keys-keys-roomid
|
|
Future<RoomKeysRoom> getRoomKeysRoom(String roomId, String version) async {
|
|
final ret = await request(
|
|
RequestType.GET,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeysRoom.fromJson(ret);
|
|
}
|
|
|
|
/// Deletes room ekys for a room
|
|
/// https://matrix.org/docs/spec/client_server/unstable#delete-matrix-client-r0-room-keys-keys-roomid
|
|
Future<RoomKeysUpdateResponse> deleteRoomKeysRoom(
|
|
String roomId, String version) async {
|
|
final ret = await request(
|
|
RequestType.DELETE,
|
|
'/client/unstable/room_keys/keys/${Uri.encodeComponent(roomId)}?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
|
|
/// Store multiple room keys
|
|
/// https://matrix.org/docs/spec/client_server/unstable#put-matrix-client-r0-room-keys-keys
|
|
Future<RoomKeysUpdateResponse> storeRoomKeys(
|
|
String version, RoomKeys keys) async {
|
|
final ret = await request(
|
|
RequestType.PUT,
|
|
'/client/unstable/room_keys/keys?version=${Uri.encodeComponent(version)}',
|
|
data: keys.toJson(),
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
|
|
/// get all room keys
|
|
/// https://matrix.org/docs/spec/client_server/unstable#get-matrix-client-r0-room-keys-keys
|
|
Future<RoomKeys> getRoomKeys(String version) async {
|
|
final ret = await request(
|
|
RequestType.GET,
|
|
'/client/unstable/room_keys/keys?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeys.fromJson(ret);
|
|
}
|
|
|
|
/// delete all room keys
|
|
/// https://matrix.org/docs/spec/client_server/unstable#delete-matrix-client-r0-room-keys-keys
|
|
Future<RoomKeysUpdateResponse> deleteRoomKeys(String version) async {
|
|
final ret = await request(
|
|
RequestType.DELETE,
|
|
'/client/unstable/room_keys/keys?version=${Uri.encodeComponent(version)}',
|
|
);
|
|
return RoomKeysUpdateResponse.fromJson(ret);
|
|
}
|
|
}
|