veilid/veilid-flutter/lib/veilid_js.dart

339 lines
9.7 KiB
Dart
Raw Normal View History

2022-02-07 02:18:42 +00:00
import 'veilid.dart';
2022-03-17 14:31:10 +00:00
import 'dart:html' as html;
import 'dart:js' as js;
import 'dart:js_util' as js_util;
2022-02-07 02:18:42 +00:00
import 'dart:async';
2022-03-16 03:02:24 +00:00
import 'dart:convert';
2022-10-01 02:37:55 +00:00
import 'dart:typed_data';
2022-02-07 02:18:42 +00:00
//////////////////////////////////////////////////////////
Veilid getVeilid() => VeilidJS();
2022-03-17 14:31:10 +00:00
Object wasm = js_util.getProperty(html.window, "veilid_wasm");
2022-03-16 03:02:24 +00:00
2022-03-17 14:31:10 +00:00
Future<T> _wrapApiPromise<T>(Object p) {
return js_util.promiseToFuture(p).then((value) => value as T).catchError(
(error) => Future<T>.error(
VeilidAPIException.fromJson(jsonDecode(error as String))));
2022-03-16 03:02:24 +00:00
}
2022-12-03 03:52:03 +00:00
class _Ctx {
final int id;
final VeilidJS js;
_Ctx(this.id, this.js);
}
2022-11-26 19:16:02 +00:00
// JS implementation of VeilidRoutingContext
class VeilidRoutingContextJS implements VeilidRoutingContext {
2022-12-03 03:52:03 +00:00
final _Ctx _ctx;
static final Finalizer<_Ctx> _finalizer = Finalizer((ctx) => {
js_util.callMethod(wasm, "release_routing_context", [ctx.id])
});
VeilidRoutingContextJS._(this._ctx) {
_finalizer.attach(this, _ctx, detach: this);
}
2022-11-26 19:16:02 +00:00
@override
2022-12-03 03:52:03 +00:00
VeilidRoutingContextJS withPrivacy() {
int newId =
js_util.callMethod(wasm, "routing_context_with_privacy", [_ctx.id]);
return VeilidRoutingContextJS._(_Ctx(newId, _ctx.js));
2022-11-26 19:16:02 +00:00
}
@override
2022-12-03 03:52:03 +00:00
VeilidRoutingContextJS withCustomPrivacy(Stability stability) {
final newId = js_util.callMethod(
wasm, "routing_context_with_custom_privacy", [_ctx.id, stability.json]);
return VeilidRoutingContextJS._(_Ctx(newId, _ctx.js));
2022-11-26 19:16:02 +00:00
}
@override
2022-12-03 03:52:03 +00:00
VeilidRoutingContextJS withSequencing(Sequencing sequencing) {
final newId = js_util.callMethod(
wasm, "routing_context_with_sequencing", [_ctx.id, sequencing.json]);
return VeilidRoutingContextJS._(_Ctx(newId, _ctx.js));
2022-11-26 19:16:02 +00:00
}
@override
Future<Uint8List> appCall(String target, Uint8List request) async {
2022-12-03 03:52:03 +00:00
var encodedRequest = base64UrlEncode(request);
2022-11-26 19:16:02 +00:00
2022-12-03 03:52:03 +00:00
return base64Decode(await _wrapApiPromise(js_util.callMethod(
wasm, "routing_context_app_call", [_ctx.id, encodedRequest])));
2022-11-26 19:16:02 +00:00
}
@override
2022-12-29 03:53:58 +00:00
Future<void> appMessage(String target, Uint8List message) {
2022-12-03 03:52:03 +00:00
var encodedMessage = base64UrlEncode(message);
2022-11-26 19:16:02 +00:00
2022-12-03 03:52:03 +00:00
return _wrapApiPromise(js_util.callMethod(
wasm, "routing_context_app_message", [_ctx.id, encodedMessage]));
2022-11-26 19:16:02 +00:00
}
}
2022-12-29 03:53:58 +00:00
class _TDBT {
final int id;
VeilidTableDBJS tdbjs;
VeilidJS js;
_TDBT(this.id, this.tdbjs, this.js);
}
// JS implementation of VeilidTableDBTransaction
class VeilidTableDBTransactionJS extends VeilidTableDBTransaction {
final _TDBT _tdbt;
static final Finalizer<_TDBT> _finalizer = Finalizer((tdbt) => {
js_util.callMethod(wasm, "release_table_db_transaction", [tdbt.id])
});
VeilidTableDBTransactionJS._(this._tdbt) {
_finalizer.attach(this, _tdbt, detach: this);
}
@override
Future<void> commit() {
return _wrapApiPromise(js_util
.callMethod(wasm, "veilid_table_db_transaction_commit", [_tdbt.id]));
}
@override
Future<void> rollback() {
return _wrapApiPromise(js_util
.callMethod(wasm, "veilid_table_db_transaction_rollback", [_tdbt.id]));
}
@override
Future<void> store(int col, Uint8List key, Uint8List value) {
final encodedKey = base64UrlEncode(key);
final encodedValue = base64UrlEncode(value);
return _wrapApiPromise(js_util.callMethod(
wasm,
"veilid_table_db_transaction_store",
[_tdbt.id, encodedKey, encodedValue]));
}
@override
Future<bool> delete(int col, Uint8List key) {
final encodedKey = base64UrlEncode(key);
return _wrapApiPromise(js_util.callMethod(
wasm, "veilid_table_db_transaction_delete", [_tdbt.id, encodedKey]));
}
}
class _TDB {
final int id;
VeilidJS js;
_TDB(this.id, this.js);
}
// JS implementation of VeilidTableDB
class VeilidTableDBJS extends VeilidTableDB {
final _TDB _tdb;
static final Finalizer<_TDB> _finalizer = Finalizer((tdb) => {
js_util.callMethod(wasm, "release_table_db", [tdb.id])
});
VeilidTableDBJS._(this._tdb) {
_finalizer.attach(this, _tdb, detach: this);
}
@override
int getColumnCount() {
return js_util.callMethod(wasm, "table_db_get_column_count", [_tdb.id]);
}
@override
List<Uint8List> getKeys(int col) {
String? s = js_util.callMethod(wasm, "table_db_get_keys", [_tdb.id, col]);
if (s == null) {
throw VeilidAPIExceptionInternal("No db for id");
}
List<dynamic> jarr = jsonDecode(s);
return jarr.map((e) => base64Decode(e)).toList();
}
@override
VeilidTableDBTransaction transact() {
final id = js_util.callMethod(wasm, "table_db_transact", [_tdb.id]);
return VeilidTableDBTransactionJS._(_TDBT(id, this, _tdb.js));
}
@override
Future<void> store(int col, Uint8List key, Uint8List value) {
final encodedKey = base64UrlEncode(key);
final encodedValue = base64UrlEncode(value);
return _wrapApiPromise(js_util.callMethod(
wasm, "veilid_table_db_store", [_tdb.id, encodedKey, encodedValue]));
}
@override
Future<Uint8List?> load(int col, Uint8List key) async {
final encodedKey = base64UrlEncode(key);
String? out = await _wrapApiPromise(js_util
.callMethod(wasm, "veilid_table_db_store", [_tdb.id, encodedKey]));
if (out == null) {
return null;
}
return base64Decode(out);
}
@override
Future<bool> delete(int col, Uint8List key) {
final encodedKey = base64UrlEncode(key);
return _wrapApiPromise(js_util
.callMethod(wasm, "veilid_table_db_delete", [_tdb.id, encodedKey]));
}
}
2022-11-26 19:16:02 +00:00
// JS implementation of high level Veilid API
2022-02-14 02:09:43 +00:00
class VeilidJS implements Veilid {
2022-06-16 01:51:38 +00:00
@override
2022-07-01 20:20:43 +00:00
void initializeVeilidCore(Map<String, dynamic> platformConfigJson) {
2022-06-16 01:51:38 +00:00
var platformConfigJsonString =
jsonEncode(platformConfigJson, toEncodable: veilidApiToEncodable);
2022-07-01 20:20:43 +00:00
js_util
.callMethod(wasm, "initialize_veilid_core", [platformConfigJsonString]);
2022-06-16 01:51:38 +00:00
}
2022-07-01 16:13:52 +00:00
@override
void changeLogLevel(String layer, VeilidConfigLogLevel logLevel) {
var logLevelJsonString =
jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable);
js_util.callMethod(wasm, "change_log_level", [layer, logLevelJsonString]);
}
2022-03-04 01:45:39 +00:00
@override
2022-09-09 20:27:13 +00:00
Future<Stream<VeilidUpdate>> startupVeilidCore(VeilidConfig config) async {
2022-03-16 03:02:24 +00:00
var streamController = StreamController<VeilidUpdate>();
2022-03-17 14:31:10 +00:00
updateCallback(String update) {
var updateJson = jsonDecode(update);
if (updateJson["kind"] == "Shutdown") {
streamController.close();
} else {
var update = VeilidUpdate.fromJson(updateJson);
streamController.add(update);
}
}
await _wrapApiPromise(js_util.callMethod(wasm, "startup_veilid_core", [
js.allowInterop(updateCallback),
jsonEncode(config.json, toEncodable: veilidApiToEncodable)
]));
2022-09-09 20:27:13 +00:00
return streamController.stream;
2022-02-07 02:18:42 +00:00
}
2022-03-04 01:45:39 +00:00
@override
2022-03-16 03:02:24 +00:00
Future<VeilidState> getVeilidState() async {
2022-03-17 14:31:10 +00:00
return VeilidState.fromJson(jsonDecode(await _wrapApiPromise(
js_util.callMethod(wasm, "get_veilid_state", []))));
2022-02-07 02:18:42 +00:00
}
2022-09-06 22:59:41 +00:00
@override
2022-12-29 03:53:58 +00:00
Future<void> attach() {
2022-09-06 22:59:41 +00:00
return _wrapApiPromise(js_util.callMethod(wasm, "attach", []));
}
@override
2022-12-29 03:53:58 +00:00
Future<void> detach() {
2022-09-06 22:59:41 +00:00
return _wrapApiPromise(js_util.callMethod(wasm, "detach", []));
}
2022-03-04 01:45:39 +00:00
@override
2022-03-17 14:31:10 +00:00
Future<void> shutdownVeilidCore() {
return _wrapApiPromise(
js_util.callMethod(wasm, "shutdown_veilid_core", []));
2022-02-07 02:18:42 +00:00
}
2022-03-04 01:45:39 +00:00
@override
2022-11-26 19:16:02 +00:00
Future<VeilidRoutingContext> routingContext() async {
2022-12-03 03:52:03 +00:00
int id = jsonDecode(
await _wrapApiPromise(js_util.callMethod(wasm, "routing_context", [])));
return VeilidRoutingContextJS._(_Ctx(id, this));
2022-11-26 19:16:02 +00:00
}
@override
Future<KeyBlob> newPrivateRoute() async {
2022-12-03 03:52:03 +00:00
Map<String, dynamic> blobJson = jsonDecode(await _wrapApiPromise(
js_util.callMethod(wasm, "new_private_route", [])));
return KeyBlob.fromJson(blobJson);
2022-11-26 19:16:02 +00:00
}
@override
Future<KeyBlob> newCustomPrivateRoute(
Stability stability, Sequencing sequencing) async {
2022-12-03 03:52:03 +00:00
var stabilityString =
jsonEncode(stability, toEncodable: veilidApiToEncodable);
var sequencingString =
jsonEncode(sequencing, toEncodable: veilidApiToEncodable);
2022-11-26 19:16:02 +00:00
2022-12-03 03:52:03 +00:00
Map<String, dynamic> blobJson = jsonDecode(await _wrapApiPromise(js_util
.callMethod(
wasm, "new_private_route", [stabilityString, sequencingString])));
return KeyBlob.fromJson(blobJson);
2022-11-26 19:16:02 +00:00
}
@override
2022-12-29 03:53:58 +00:00
Future<String> importRemotePrivateRoute(Uint8List blob) {
2022-11-26 19:16:02 +00:00
var encodedBlob = base64UrlEncode(blob);
return _wrapApiPromise(
js_util.callMethod(wasm, "import_remote_private_route", [encodedBlob]));
}
@override
2022-12-29 03:53:58 +00:00
Future<void> releasePrivateRoute(String key) {
2022-11-26 19:16:02 +00:00
return _wrapApiPromise(
js_util.callMethod(wasm, "release_private_route", [key]));
2022-03-04 01:45:39 +00:00
}
2022-10-01 02:37:55 +00:00
@override
Future<void> appCallReply(String id, Uint8List message) {
var encodedMessage = base64UrlEncode(message);
return _wrapApiPromise(
js_util.callMethod(wasm, "app_call_reply", [id, encodedMessage]));
}
2022-12-03 03:52:03 +00:00
2022-12-29 03:53:58 +00:00
@override
Future<VeilidTableDB> openTableDB(String name, int columnCount) async {
int id = await _wrapApiPromise(
js_util.callMethod(wasm, "open_table_db", [name, columnCount]));
return VeilidTableDBJS._(_TDB(id, this));
}
@override
Future<bool> deleteTableDB(String name) {
return _wrapApiPromise(js_util.callMethod(wasm, "delete_table_db", [name]));
}
2022-11-26 19:16:02 +00:00
@override
2022-12-11 00:11:58 +00:00
Future<String> debug(String command) async {
return jsonDecode(
await _wrapApiPromise(js_util.callMethod(wasm, "debug", [command])));
2022-11-26 19:16:02 +00:00
}
2022-10-01 02:37:55 +00:00
2022-03-04 01:45:39 +00:00
@override
2022-03-17 14:31:10 +00:00
String veilidVersionString() {
return js_util.callMethod(wasm, "veilid_version_string", []);
2022-02-07 02:18:42 +00:00
}
2022-03-04 01:45:39 +00:00
@override
2022-03-17 14:31:10 +00:00
VeilidVersion veilidVersion() {
2022-12-03 03:52:03 +00:00
Map<String, dynamic> jsonVersion =
2022-03-17 14:31:10 +00:00
jsonDecode(js_util.callMethod(wasm, "veilid_version", []));
2022-03-16 03:02:24 +00:00
return VeilidVersion(
jsonVersion["major"], jsonVersion["minor"], jsonVersion["patch"]);
2022-02-07 02:18:42 +00:00
}
}