wasm work

veilid-flutter/lib/veilid.dart

@@ -996,6 +996,6 @@ abstract class Veilid {
   Future<void> changeLogLevel(VeilidConfigLogLevel logLevel);
   Future<void> shutdownVeilidCore();
   Future<String> debug(String command);
-  String veilidVersionString();
-  VeilidVersion veilidVersion();
+  Future<String> veilidVersionString();
+  Future<VeilidVersion> veilidVersion();
 }

veilid-flutter/lib/veilid_ffi.dart

@@ -326,7 +326,7 @@ class VeilidFFI implements Veilid {
   }
 
   @override
-  String veilidVersionString() {
+  Future<String> veilidVersionString() async {
     final versionString = _veilidVersionString();
     String ret = versionString.toDartString();
     _freeString(versionString);
@@ -334,7 +334,7 @@ class VeilidFFI implements Veilid {
   }
 
   @override
-  VeilidVersion veilidVersion() {
+  Future<VeilidVersion> veilidVersion() async {
     final version = _veilidVersion();
     return VeilidVersion(
       version.major,

veilid-flutter/lib/veilid_js.dart

@@ -1,46 +1,82 @@
 import 'veilid.dart';
 
 import 'dart:js';
+import 'dart:js_util';
 import 'dart:async';
-import 'dart:typed_data';
+import 'dart:convert';
+import 'package:flutter/services.dart' show NetworkAssetBundle;
+import 'package:wasm_interop/wasm_interop.dart';
+import 'package:mutex/mutex.dart';
 
 //////////////////////////////////////////////////////////
 
 Veilid getVeilid() => VeilidJS();
 
+Instance? _wasmInstance;
+final _wasmInstanceMutex = Mutex();
+
+Future<Instance> getWasmInstance() async {
+  await _wasmInstanceMutex.acquire();
+  var _wi = _wasmInstance;
+  if (_wi == null) {
+    final bytes = await http???.get(Uri.parse("/wasm/veilid_wasm.wasm"));
+    _wi = await Instance.fromBufferAsync(bytes.buffer);
+    _wasmInstance = _wi;
+  }
+  _wasmInstanceMutex.release();
+  return _wi;
+}
+
 class VeilidJS implements Veilid {
   @override
-  Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config) {
-    throw UnimplementedError();
+  Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config) async* {
+    var wasm = (await getWasmInstance());
+    var streamController = StreamController<VeilidUpdate>();
+    await promiseToFuture(
+        wasm.functions["startup_veilid_core"]!.call((String update) {
+      streamController.add(VeilidUpdate.fromJson(jsonDecode(update)));
+    }, jsonEncode(config.json, toEncodable: veilidApiToEncodable)));
+    yield* streamController.stream;
   }
 
   @override
-  Future<VeilidState> getVeilidState() {
-    throw UnimplementedError();
+  Future<VeilidState> getVeilidState() async {
+    var wasm = (await getWasmInstance());
+    return VeilidState.fromJson(jsonDecode(
+        await promiseToFuture(wasm.functions["get_veilid_state"]!.call())));
   }
 
   @override
-  Future<void> changeLogLevel(VeilidConfigLogLevel logLevel) {
-    throw UnimplementedError();
+  Future<void> changeLogLevel(VeilidConfigLogLevel logLevel) async {
+    var wasm = (await getWasmInstance());
+    await promiseToFuture(wasm.functions["change_log_level"]!
+        .call(jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable)));
   }
 
   @override
-  Future<void> shutdownVeilidCore() {
-    throw UnimplementedError();
+  Future<void> shutdownVeilidCore() async {
+    var wasm = (await getWasmInstance());
+    await promiseToFuture(wasm.functions["shutdown_veilid_core"]!.call());
   }
 
   @override
-  Future<String> debug(String command) {
-    throw UnimplementedError();
+  Future<String> debug(String command) async {
+    var wasm = (await getWasmInstance());
+    return await promiseToFuture(wasm.functions["debug"]!.call(command));
   }
 
   @override
-  String veilidVersionString() {
-    throw UnimplementedError();
+  Future<String> veilidVersionString() async {
+    var wasm = (await getWasmInstance());
+    return await promiseToFuture(wasm.functions["debug"]!.call());
   }
 
   @override
-  VeilidVersion veilidVersion() {
-    throw UnimplementedError();
+  Future<VeilidVersion> veilidVersion() async {
+    var wasm = (await getWasmInstance());
+    var jsonVersion = jsonDecode(
+        await promiseToFuture(wasm.functions["get_veilid_state"]!.call()));
+    return VeilidVersion(
+        jsonVersion["major"], jsonVersion["minor"], jsonVersion["patch"]);
   }
 }

veilid-flutter/lib/veilid_plugin_stub_web.dart

@@ -1,41 +1,17 @@
 import 'dart:async';
-// In order to *not* need this ignore, consider extracting the "web" version
-// of your plugin as a separate package, instead of inlining it in the same
-// package as the core of your plugin.
-// ignore: avoid_web_libraries_in_flutter
-import 'dart:html' as html show window;
 
 import 'package:flutter/services.dart';
 import 'package:flutter_web_plugins/flutter_web_plugins.dart';
 
-// xxx link in WASM version of veilid-flutter
-
-/// A web implementation of the Veilid plugin.
+/// A stub web implementation of the Veilid plugin
+/// Because everything is done with FFI or WASM, we don't use this interface
 class VeilidPluginStubWeb {
-  static void registerWith(Registrar registrar) {
-    // final MethodChannel channel = MethodChannel(
-    //   'veilid',
-    //   const StandardMethodCodec(),
-    //   registrar,
-    // );
+  static void registerWith(Registrar registrar) {}
 
-    // final pluginInstance = VeilidWeb();
-    // channel.setMethodCallHandler(pluginInstance.handleMethodCall);
-  }
-
-  /// Handles method calls over the MethodChannel of this plugin.
-  /// Note: Check the "federated" architecture for a new way of doing this:
-  /// https://flutter.dev/go/federated-plugins
   Future<dynamic> handleMethodCall(MethodCall call) async {
-    // switch (call.method) {
-    //   case 'getPlatformVersion':
-    //     return getPlatformVersion();
-    //   default:
-        throw PlatformException(
-          code: 'Unimplemented',
-          details: 'veilid for web doesn\'t implement \'${call.method}\'',
-        );
-    // }
+    throw PlatformException(
+      code: 'Unimplemented',
+      details: 'Veilid for Web doesn\'t implement \'${call.method}\'',
+    );
   }
-
 }