move toward api logging

veilid-core/src/intf/native/utils/android/mod.rs

@@ -23,22 +23,7 @@ lazy_static! {
     pub static ref ANDROID_GLOBALS: Arc<Mutex<Option<AndroidGlobals>>> = Arc::new(Mutex::new(None));
 }
 
-pub fn veilid_core_setup_android<'a>(
-    env: JNIEnv<'a>,
-    ctx: JObject<'a>,
-    log_tag: &'a str,
-    log_level: Level,
-) {
-    android_logger::init_once(
-        Config::default()
-            .with_min_level(log_level)
-            .with_tag(log_tag)
-            .with_filter(
-                FilterBuilder::new()
-                    .filter(Some(log_tag), log_level.to_level_filter())
-                    .build(),
-            ),
-    );
+pub fn veilid_core_setup_android_no_log<'a>(env: JNIEnv<'a>, ctx: JObject<'a>) {
     panic::set_hook(Box::new(|panic_info| {
         let bt = Backtrace::new();
         if let Some(location) = panic_info.location() {
@@ -68,6 +53,26 @@ pub fn veilid_core_setup_android<'a>(
     });
 }
 
+pub fn veilid_core_setup_android<'a>(
+    env: JNIEnv<'a>,
+    ctx: JObject<'a>,
+    log_tag: &'a str,
+    log_level: Level,
+) {
+    android_logger::init_once(
+        Config::default()
+            .with_min_level(log_level)
+            .with_tag(log_tag)
+            .with_filter(
+                FilterBuilder::new()
+                    .filter(Some(log_tag), log_level.to_level_filter())
+                    .build(),
+            ),
+    );
+
+    veilid_core_setup_android_no_log(env, ctx);
+}
+
 pub fn get_android_globals() -> (JavaVM, GlobalRef) {
     let globals_locked = ANDROID_GLOBALS.lock();
     let globals = globals_locked.as_ref().unwrap();

veilid-core/src/tests/common/test_veilid_config.rs

@@ -175,6 +175,7 @@ pub fn config_callback(key: String) -> ConfigCallbackReturn {
     match key.as_str() {
         "program_name" => Ok(Box::new(String::from("Veilid"))),
         "namespace" => Ok(Box::new(String::from(""))),
+        "log_to_api" => Ok(Box::new(false)),
         "capabilities.protocol_udp" => Ok(Box::new(true)),
         "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
         "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),
@@ -275,6 +276,7 @@ pub async fn test_config() {
     let inner = vc.get();
     assert_eq!(inner.program_name, String::from("Veilid"));
     assert_eq!(inner.namespace, String::from(""));
+    assert_eq!(inner.log_to_api, false);
     assert_eq!(inner.capabilities.protocol_udp, true);
     assert_eq!(inner.capabilities.protocol_connect_tcp, true);
     assert_eq!(inner.capabilities.protocol_accept_tcp, true);

veilid-core/src/veilid_api/mod.rs

@@ -106,12 +106,34 @@ macro_rules! parse_error {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
+pub enum VeilidLogLevel {
+    Error = 1,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl VeilidLogLevel {
+    pub fn from_log_level(level: log::Level) -> VeilidLogLevel {
+        match level {
+            Level::Error => VeilidLogLevel::Error,
+            Level::Warn => VeilidLogLevel::Warn,
+            Level::Info => VeilidLogLevel::Info,
+            Level::Debug => VeilidLogLevel::Debug,
+            Level::Trace => VeilidLogLevel::Trace,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
 pub enum VeilidUpdate {
+    Log(VeilidLogLevel, String),
     Attachment(AttachmentState),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct VeilidState {
     pub attachment: AttachmentState,
 }
@@ -1144,6 +1166,9 @@ impl VeilidAPI {
         timeout_ms: Option<u32>,
     ) -> Result<(), VeilidAPIError> {
         match update {
+            VeilidUpdate::Log(_l, _s) => {
+                // No point in waiting for a log
+            }
             VeilidUpdate::Attachment(cs) => {
                 self.attachment_manager()?
                     .wait_for_state(cs, timeout_ms)

veilid-core/src/veilid_config.rs

@@ -176,6 +176,7 @@ pub struct VeilidConfigCapabilities {
 pub struct VeilidConfigInner {
     pub program_name: String,
     pub namespace: String,
+    pub log_to_api: bool,
     pub capabilities: VeilidConfigCapabilities,
     pub protected_store: VeilidConfigProtectedStore,
     pub table_store: VeilidConfigTableStore,
@@ -220,6 +221,7 @@ impl VeilidConfig {
             let mut inner = self.inner.write();
             get_config!(inner.program_name);
             get_config!(inner.namespace);
+            get_config!(inner.log_to_api);
             get_config!(inner.capabilities.protocol_udp);
             get_config!(inner.capabilities.protocol_connect_tcp);
             get_config!(inner.capabilities.protocol_accept_tcp);

veilid-flutter/android/src/main/kotlin/com/veilid/veilid/VeilidPlugin.kt

@@ -16,6 +16,12 @@ class VeilidPlugin: FlutterPlugin, MethodCallHandler {
   /// when the Flutter Engine is detached from the Activity
   // private lateinit var channel : MethodChannel
 
+  // static {
+  //   System.loadLibrary("veilid_flutter");
+  // }
+// xxx get main activity
+  // private static native void init_android(Context context);
+
   override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
   //   channel = MethodChannel(flutterPluginBinding.binaryMessenger, "veilid")
   //   channel.setMethodCallHandler(this)

veilid-flutter/lib/bridge_generated.dart

@@ -12,11 +12,17 @@ import 'dart:typed_data';
 import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
 import 'dart:ffi' as ffi;
 
+
 part 'bridge_generated.freezed.dart';
 
+
+
+
+
+
+
 abstract class VeilidFlutter {
-  Stream<VeilidUpdate> startupVeilidCore(
-      {required VeilidConfig config, dynamic hint});
+            Stream<VeilidUpdate> startupVeilidCore({ required VeilidConfig config,dynamic hint });
 
 Future<VeilidState> getVeilidState({ dynamic hint });
 
@@ -106,89 +112,27 @@ class VeilidConfig {
 final int networkLeasesMaxClientSignalLeases;
 final int networkLeasesMaxClientRelayLeases;
 
-  VeilidConfig({
-    required this.programName,
-    required this.veilidNamespace,
-    required this.capabilitiesProtocolUdp,
-    required this.capabilitiesProtocolConnectTcp,
-    required this.capabilitiesProtocolAcceptTcp,
-    required this.capabilitiesProtocolConnectWs,
-    required this.capabilitiesProtocolAcceptWs,
-    required this.capabilitiesProtocolConnectWss,
-    required this.capabilitiesProtocolAcceptWss,
-    required this.protectedStoreAllowInsecureFallback,
-    required this.protectedStoreAlwaysUseInsecureStorage,
-    required this.protectedStoreInsecureFallbackDirectory,
-    required this.protectedStoreDelete,
-    required this.tableStoreDirectory,
-    required this.tableStoreDelete,
-    required this.blockStoreDirectory,
-    required this.blockStoreDelete,
-    required this.networkMaxConnections,
-    required this.networkConnectionInitialTimeoutMs,
-    required this.networkNodeId,
-    required this.networkNodeIdSecret,
-    required this.networkBootstrap,
-    required this.networkUpnp,
-    required this.networkNatpmp,
-    required this.networkEnableLocalPeerScope,
-    required this.networkRestrictedNatRetries,
-    required this.networkRpcConcurrency,
-    required this.networkRpcQueueSize,
-    this.networkRpcMaxTimestampBehindMs,
-    this.networkRpcMaxTimestampAheadMs,
-    required this.networkRpcTimeoutMs,
-    required this.networkRpcMaxRouteHopCount,
-    this.networkDhtResolveNodeTimeoutMs,
-    required this.networkDhtResolveNodeCount,
-    required this.networkDhtResolveNodeFanout,
-    required this.networkDhtMaxFindNodeCount,
-    this.networkDhtGetValueTimeoutMs,
-    required this.networkDhtGetValueCount,
-    required this.networkDhtGetValueFanout,
-    this.networkDhtSetValueTimeoutMs,
-    required this.networkDhtSetValueCount,
-    required this.networkDhtSetValueFanout,
-    required this.networkDhtMinPeerCount,
-    required this.networkDhtMinPeerRefreshTimeMs,
-    required this.networkDhtValidateDialInfoReceiptTimeMs,
-    required this.networkProtocolUdpEnabled,
-    required this.networkProtocolUdpSocketPoolSize,
-    required this.networkProtocolUdpListenAddress,
-    this.networkProtocolUdpPublicAddress,
-    required this.networkProtocolTcpConnect,
-    required this.networkProtocolTcpListen,
-    required this.networkProtocolTcpMaxConnections,
-    required this.networkProtocolTcpListenAddress,
-    this.networkProtocolTcpPublicAddress,
-    required this.networkProtocolWsConnect,
-    required this.networkProtocolWsListen,
-    required this.networkProtocolWsMaxConnections,
-    required this.networkProtocolWsListenAddress,
-    required this.networkProtocolWsPath,
-    this.networkProtocolWsUrl,
-    required this.networkProtocolWssConnect,
-    required this.networkProtocolWssMaxConnections,
-    required this.networkLeasesMaxServerSignalLeases,
-    required this.networkLeasesMaxServerRelayLeases,
-    required this.networkLeasesMaxClientSignalLeases,
-    required this.networkLeasesMaxClientRelayLeases,
-  });
+            VeilidConfig({required this.programName,required this.veilidNamespace,required this.capabilitiesProtocolUdp,required this.capabilitiesProtocolConnectTcp,required this.capabilitiesProtocolAcceptTcp,required this.capabilitiesProtocolConnectWs,required this.capabilitiesProtocolAcceptWs,required this.capabilitiesProtocolConnectWss,required this.capabilitiesProtocolAcceptWss,required this.protectedStoreAllowInsecureFallback,required this.protectedStoreAlwaysUseInsecureStorage,required this.protectedStoreInsecureFallbackDirectory,required this.protectedStoreDelete,required this.tableStoreDirectory,required this.tableStoreDelete,required this.blockStoreDirectory,required this.blockStoreDelete,required this.networkMaxConnections,required this.networkConnectionInitialTimeoutMs,required this.networkNodeId,required this.networkNodeIdSecret,required this.networkBootstrap,required this.networkUpnp,required this.networkNatpmp,required this.networkEnableLocalPeerScope,required this.networkRestrictedNatRetries,required this.networkRpcConcurrency,required this.networkRpcQueueSize,this.networkRpcMaxTimestampBehindMs,this.networkRpcMaxTimestampAheadMs,required this.networkRpcTimeoutMs,required this.networkRpcMaxRouteHopCount,this.networkDhtResolveNodeTimeoutMs,required this.networkDhtResolveNodeCount,required this.networkDhtResolveNodeFanout,required this.networkDhtMaxFindNodeCount,this.networkDhtGetValueTimeoutMs,required this.networkDhtGetValueCount,required this.networkDhtGetValueFanout,this.networkDhtSetValueTimeoutMs,required this.networkDhtSetValueCount,required this.networkDhtSetValueFanout,required this.networkDhtMinPeerCount,required this.networkDhtMinPeerRefreshTimeMs,required this.networkDhtValidateDialInfoReceiptTimeMs,required this.networkProtocolUdpEnabled,required this.networkProtocolUdpSocketPoolSize,required this.networkProtocolUdpListenAddress,this.networkProtocolUdpPublicAddress,required this.networkProtocolTcpConnect,required this.networkProtocolTcpListen,required this.networkProtocolTcpMaxConnections,required this.networkProtocolTcpListenAddress,this.networkProtocolTcpPublicAddress,required this.networkProtocolWsConnect,required this.networkProtocolWsListen,required this.networkProtocolWsMaxConnections,required this.networkProtocolWsListenAddress,required this.networkProtocolWsPath,this.networkProtocolWsUrl,required this.networkProtocolWssConnect,required this.networkProtocolWssMaxConnections,required this.networkLeasesMaxServerSignalLeases,required this.networkLeasesMaxServerRelayLeases,required this.networkLeasesMaxClientSignalLeases,required this.networkLeasesMaxClientRelayLeases,});
+        }
+
+enum VeilidLogLevel {
+            Error,
+Warn,
+Info,
+Debug,
+Trace,
         }
 
 class VeilidState {
             final AttachmentState attachment;
 
-  VeilidState({
-    required this.attachment,
-  });
+            VeilidState({required this.attachment,});
         }
 
 @freezed
             class VeilidUpdate with _$VeilidUpdate {
-  const factory VeilidUpdate.attachment(
-    AttachmentState field0,
-  ) = Attachment;
+                const factory VeilidUpdate.log(VeilidLogLevel field0,,String field1,) = Log;
+const factory VeilidUpdate.attachment(AttachmentState field0,) = Attachment;
             }
 
 class VeilidVersion {
@@ -196,80 +140,78 @@ class VeilidVersion {
 final int minor;
 final int patch;
 
-  VeilidVersion({
-    required this.major,
-    required this.minor,
-    required this.patch,
-  });
+            VeilidVersion({required this.major,required this.minor,required this.patch,});
         }
         
-class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire>
-    implements VeilidFlutter {
-  factory VeilidFlutterImpl(ffi.DynamicLibrary dylib) =>
-      VeilidFlutterImpl.raw(VeilidFlutterWire(dylib));
+
+class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire> implements VeilidFlutter {
+            factory VeilidFlutterImpl(ffi.DynamicLibrary dylib) => VeilidFlutterImpl.raw(VeilidFlutterWire(dylib));
 
             VeilidFlutterImpl.raw(VeilidFlutterWire inner) : super(inner);
 
-  Stream<VeilidUpdate> startupVeilidCore(
-          {required VeilidConfig config, dynamic hint}) =>
-      executeStream(FlutterRustBridgeTask(
-        callFfi: (port_) => inner.wire_startup_veilid_core(
-            port_, _api2wire_box_autoadd_veilid_config(config)),
+            Stream<VeilidUpdate> startupVeilidCore({ required VeilidConfig config,dynamic hint }) => executeStream(FlutterRustBridgeTask(
+            callFfi: (port_) => inner.wire_startup_veilid_core(port_, _api2wire_box_autoadd_veilid_config(config)),
             parseSuccessData: _wire2api_veilid_update,
+            
         constMeta: const FlutterRustBridgeTaskConstMeta(
             debugName: "startup_veilid_core",
             argNames: ["config"],
         ),
         argValues: [config],
         hint: hint,
+        
         ));
 
-  Future<VeilidState> getVeilidState({dynamic hint}) =>
-      executeNormal(FlutterRustBridgeTask(
+Future<VeilidState> getVeilidState({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
             callFfi: (port_) => inner.wire_get_veilid_state(port_),
             parseSuccessData: _wire2api_veilid_state,
+            
         constMeta: const FlutterRustBridgeTaskConstMeta(
             debugName: "get_veilid_state",
             argNames: [],
         ),
         argValues: [],
         hint: hint,
+        
         ));
 
-  Future<void> shutdownVeilidCore({dynamic hint}) =>
-      executeNormal(FlutterRustBridgeTask(
+Future<void> shutdownVeilidCore({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
             callFfi: (port_) => inner.wire_shutdown_veilid_core(port_),
             parseSuccessData: _wire2api_unit,
+            
         constMeta: const FlutterRustBridgeTaskConstMeta(
             debugName: "shutdown_veilid_core",
             argNames: [],
         ),
         argValues: [],
         hint: hint,
+        
         ));
 
-  Future<String> veilidVersionString({dynamic hint}) =>
-      executeNormal(FlutterRustBridgeTask(
+Future<String> veilidVersionString({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
             callFfi: (port_) => inner.wire_veilid_version_string(port_),
             parseSuccessData: _wire2api_String,
+            
         constMeta: const FlutterRustBridgeTaskConstMeta(
             debugName: "veilid_version_string",
             argNames: [],
         ),
         argValues: [],
         hint: hint,
+        
         ));
 
-  Future<VeilidVersion> veilidVersion({dynamic hint}) =>
-      executeNormal(FlutterRustBridgeTask(
+Future<VeilidVersion> veilidVersion({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
             callFfi: (port_) => inner.wire_veilid_version(port_),
             parseSuccessData: _wire2api_veilid_version,
+            
         constMeta: const FlutterRustBridgeTaskConstMeta(
             debugName: "veilid_version",
             argNames: [],
         ),
         argValues: [],
         hint: hint,
+        
         ));
 
             // Section: api2wire
@@ -277,6 +219,7 @@ class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire>
             return _api2wire_uint_8_list(utf8.encoder.convert(raw));
         }
         
+
 ffi.Pointer<wire_StringList> _api2wire_StringList(List<String> raw) {
             final ans = inner.new_StringList(raw.length);
             for (var i = 0; i < raw.length; i++) {
@@ -285,176 +228,143 @@ class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire>
             return ans;
         }
         
+
 int _api2wire_bool(bool raw) {
             return raw ? 1 : 0;
         }
         
+
 ffi.Pointer<ffi.Uint32> _api2wire_box_autoadd_u32(int raw) {
             return inner.new_box_autoadd_u32(raw);
         }
         
-  ffi.Pointer<wire_VeilidConfig> _api2wire_box_autoadd_veilid_config(
-      VeilidConfig raw) {
+
+ffi.Pointer<wire_VeilidConfig> _api2wire_box_autoadd_veilid_config(VeilidConfig raw) {
             final ptr = inner.new_box_autoadd_veilid_config();
                     _api_fill_to_wire_veilid_config(raw, ptr.ref);
                     return ptr;
         }
         
+
 ffi.Pointer<wire_uint_8_list> _api2wire_opt_String(String? raw) {
             return raw == null ? ffi.nullptr : _api2wire_String(raw);
         }
         
+
 ffi.Pointer<ffi.Uint32> _api2wire_opt_box_autoadd_u32(int? raw) {
             return raw == null ? ffi.nullptr : _api2wire_box_autoadd_u32(raw);
         }
         
+
 int _api2wire_u32(int raw) {
             return raw;
         }
         
+
 int _api2wire_u8(int raw) {
             return raw;
         }
         
+
 ffi.Pointer<wire_uint_8_list> _api2wire_uint_8_list(Uint8List raw) {
             final ans = inner.new_uint_8_list(raw.length);
                 ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
                 return ans;
         }
         
+
+
+
             // Section: api_fill_to_wire
             
-  void _api_fill_to_wire_box_autoadd_veilid_config(
-      VeilidConfig apiObj, ffi.Pointer<wire_VeilidConfig> wireObj) {
+
+
+
+
+
+
+
+void _api_fill_to_wire_box_autoadd_veilid_config(VeilidConfig apiObj, ffi.Pointer<wire_VeilidConfig> wireObj) {
              _api_fill_to_wire_veilid_config(apiObj, wireObj.ref);
         }
 
-  void _api_fill_to_wire_veilid_config(
-      VeilidConfig apiObj, wire_VeilidConfig wireObj) {
+
+
+
+
+
+
+
+
+
+
+void _api_fill_to_wire_veilid_config(VeilidConfig apiObj, wire_VeilidConfig wireObj) {
             wireObj.program_name = _api2wire_String(apiObj.programName);
 wireObj.veilid_namespace = _api2wire_String(apiObj.veilidNamespace);
-    wireObj.capabilities__protocol_udp =
-        _api2wire_bool(apiObj.capabilitiesProtocolUdp);
-    wireObj.capabilities__protocol_connect_tcp =
-        _api2wire_bool(apiObj.capabilitiesProtocolConnectTcp);
-    wireObj.capabilities__protocol_accept_tcp =
-        _api2wire_bool(apiObj.capabilitiesProtocolAcceptTcp);
-    wireObj.capabilities__protocol_connect_ws =
-        _api2wire_bool(apiObj.capabilitiesProtocolConnectWs);
-    wireObj.capabilities__protocol_accept_ws =
-        _api2wire_bool(apiObj.capabilitiesProtocolAcceptWs);
-    wireObj.capabilities__protocol_connect_wss =
-        _api2wire_bool(apiObj.capabilitiesProtocolConnectWss);
-    wireObj.capabilities__protocol_accept_wss =
-        _api2wire_bool(apiObj.capabilitiesProtocolAcceptWss);
-    wireObj.protected_store__allow_insecure_fallback =
-        _api2wire_bool(apiObj.protectedStoreAllowInsecureFallback);
-    wireObj.protected_store__always_use_insecure_storage =
-        _api2wire_bool(apiObj.protectedStoreAlwaysUseInsecureStorage);
-    wireObj.protected_store__insecure_fallback_directory =
-        _api2wire_String(apiObj.protectedStoreInsecureFallbackDirectory);
-    wireObj.protected_store__delete =
-        _api2wire_bool(apiObj.protectedStoreDelete);
-    wireObj.table_store__directory =
-        _api2wire_String(apiObj.tableStoreDirectory);
+wireObj.capabilities__protocol_udp = _api2wire_bool(apiObj.capabilitiesProtocolUdp);
+wireObj.capabilities__protocol_connect_tcp = _api2wire_bool(apiObj.capabilitiesProtocolConnectTcp);
+wireObj.capabilities__protocol_accept_tcp = _api2wire_bool(apiObj.capabilitiesProtocolAcceptTcp);
+wireObj.capabilities__protocol_connect_ws = _api2wire_bool(apiObj.capabilitiesProtocolConnectWs);
+wireObj.capabilities__protocol_accept_ws = _api2wire_bool(apiObj.capabilitiesProtocolAcceptWs);
+wireObj.capabilities__protocol_connect_wss = _api2wire_bool(apiObj.capabilitiesProtocolConnectWss);
+wireObj.capabilities__protocol_accept_wss = _api2wire_bool(apiObj.capabilitiesProtocolAcceptWss);
+wireObj.protected_store__allow_insecure_fallback = _api2wire_bool(apiObj.protectedStoreAllowInsecureFallback);
+wireObj.protected_store__always_use_insecure_storage = _api2wire_bool(apiObj.protectedStoreAlwaysUseInsecureStorage);
+wireObj.protected_store__insecure_fallback_directory = _api2wire_String(apiObj.protectedStoreInsecureFallbackDirectory);
+wireObj.protected_store__delete = _api2wire_bool(apiObj.protectedStoreDelete);
+wireObj.table_store__directory = _api2wire_String(apiObj.tableStoreDirectory);
 wireObj.table_store__delete = _api2wire_bool(apiObj.tableStoreDelete);
-    wireObj.block_store__directory =
-        _api2wire_String(apiObj.blockStoreDirectory);
+wireObj.block_store__directory = _api2wire_String(apiObj.blockStoreDirectory);
 wireObj.block_store__delete = _api2wire_bool(apiObj.blockStoreDelete);
-    wireObj.network__max_connections =
-        _api2wire_u32(apiObj.networkMaxConnections);
-    wireObj.network__connection_initial_timeout_ms =
-        _api2wire_u32(apiObj.networkConnectionInitialTimeoutMs);
+wireObj.network__max_connections = _api2wire_u32(apiObj.networkMaxConnections);
+wireObj.network__connection_initial_timeout_ms = _api2wire_u32(apiObj.networkConnectionInitialTimeoutMs);
 wireObj.network__node_id = _api2wire_String(apiObj.networkNodeId);
-    wireObj.network__node_id_secret =
-        _api2wire_String(apiObj.networkNodeIdSecret);
+wireObj.network__node_id_secret = _api2wire_String(apiObj.networkNodeIdSecret);
 wireObj.network__bootstrap = _api2wire_StringList(apiObj.networkBootstrap);
 wireObj.network__upnp = _api2wire_bool(apiObj.networkUpnp);
 wireObj.network__natpmp = _api2wire_bool(apiObj.networkNatpmp);
-    wireObj.network__enable_local_peer_scope =
-        _api2wire_bool(apiObj.networkEnableLocalPeerScope);
-    wireObj.network__restricted_nat_retries =
-        _api2wire_u32(apiObj.networkRestrictedNatRetries);
-    wireObj.network__rpc__concurrency =
-        _api2wire_u32(apiObj.networkRpcConcurrency);
-    wireObj.network__rpc__queue_size =
-        _api2wire_u32(apiObj.networkRpcQueueSize);
-    wireObj.network__rpc__max_timestamp_behind_ms =
-        _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampBehindMs);
-    wireObj.network__rpc__max_timestamp_ahead_ms =
-        _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampAheadMs);
-    wireObj.network__rpc__timeout_ms =
-        _api2wire_u32(apiObj.networkRpcTimeoutMs);
-    wireObj.network__rpc__max_route_hop_count =
-        _api2wire_u8(apiObj.networkRpcMaxRouteHopCount);
-    wireObj.network__dht__resolve_node_timeout_ms =
-        _api2wire_opt_box_autoadd_u32(apiObj.networkDhtResolveNodeTimeoutMs);
-    wireObj.network__dht__resolve_node_count =
-        _api2wire_u32(apiObj.networkDhtResolveNodeCount);
-    wireObj.network__dht__resolve_node_fanout =
-        _api2wire_u32(apiObj.networkDhtResolveNodeFanout);
-    wireObj.network__dht__max_find_node_count =
-        _api2wire_u32(apiObj.networkDhtMaxFindNodeCount);
-    wireObj.network__dht__get_value_timeout_ms =
-        _api2wire_opt_box_autoadd_u32(apiObj.networkDhtGetValueTimeoutMs);
-    wireObj.network__dht__get_value_count =
-        _api2wire_u32(apiObj.networkDhtGetValueCount);
-    wireObj.network__dht__get_value_fanout =
-        _api2wire_u32(apiObj.networkDhtGetValueFanout);
-    wireObj.network__dht__set_value_timeout_ms =
-        _api2wire_opt_box_autoadd_u32(apiObj.networkDhtSetValueTimeoutMs);
-    wireObj.network__dht__set_value_count =
-        _api2wire_u32(apiObj.networkDhtSetValueCount);
-    wireObj.network__dht__set_value_fanout =
-        _api2wire_u32(apiObj.networkDhtSetValueFanout);
-    wireObj.network__dht__min_peer_count =
-        _api2wire_u32(apiObj.networkDhtMinPeerCount);
-    wireObj.network__dht__min_peer_refresh_time_ms =
-        _api2wire_u32(apiObj.networkDhtMinPeerRefreshTimeMs);
-    wireObj.network__dht__validate_dial_info_receipt_time_ms =
-        _api2wire_u32(apiObj.networkDhtValidateDialInfoReceiptTimeMs);
-    wireObj.network__protocol__udp__enabled =
-        _api2wire_bool(apiObj.networkProtocolUdpEnabled);
-    wireObj.network__protocol__udp__socket_pool_size =
-        _api2wire_u32(apiObj.networkProtocolUdpSocketPoolSize);
-    wireObj.network__protocol__udp__listen_address =
-        _api2wire_String(apiObj.networkProtocolUdpListenAddress);
-    wireObj.network__protocol__udp__public_address =
-        _api2wire_opt_String(apiObj.networkProtocolUdpPublicAddress);
-    wireObj.network__protocol__tcp__connect =
-        _api2wire_bool(apiObj.networkProtocolTcpConnect);
-    wireObj.network__protocol__tcp__listen =
-        _api2wire_bool(apiObj.networkProtocolTcpListen);
-    wireObj.network__protocol__tcp__max_connections =
-        _api2wire_u32(apiObj.networkProtocolTcpMaxConnections);
-    wireObj.network__protocol__tcp__listen_address =
-        _api2wire_String(apiObj.networkProtocolTcpListenAddress);
-    wireObj.network__protocol__tcp__public_address =
-        _api2wire_opt_String(apiObj.networkProtocolTcpPublicAddress);
-    wireObj.network__protocol__ws__connect =
-        _api2wire_bool(apiObj.networkProtocolWsConnect);
-    wireObj.network__protocol__ws__listen =
-        _api2wire_bool(apiObj.networkProtocolWsListen);
-    wireObj.network__protocol__ws__max_connections =
-        _api2wire_u32(apiObj.networkProtocolWsMaxConnections);
-    wireObj.network__protocol__ws__listen_address =
-        _api2wire_String(apiObj.networkProtocolWsListenAddress);
-    wireObj.network__protocol__ws__path =
-        _api2wire_String(apiObj.networkProtocolWsPath);
-    wireObj.network__protocol__ws__url =
-        _api2wire_opt_String(apiObj.networkProtocolWsUrl);
-    wireObj.network__protocol__wss__connect =
-        _api2wire_bool(apiObj.networkProtocolWssConnect);
-    wireObj.network__protocol__wss__max_connections =
-        _api2wire_u32(apiObj.networkProtocolWssMaxConnections);
-    wireObj.network__leases__max_server_signal_leases =
-        _api2wire_u32(apiObj.networkLeasesMaxServerSignalLeases);
-    wireObj.network__leases__max_server_relay_leases =
-        _api2wire_u32(apiObj.networkLeasesMaxServerRelayLeases);
-    wireObj.network__leases__max_client_signal_leases =
-        _api2wire_u32(apiObj.networkLeasesMaxClientSignalLeases);
-    wireObj.network__leases__max_client_relay_leases =
-        _api2wire_u32(apiObj.networkLeasesMaxClientRelayLeases);
+wireObj.network__enable_local_peer_scope = _api2wire_bool(apiObj.networkEnableLocalPeerScope);
+wireObj.network__restricted_nat_retries = _api2wire_u32(apiObj.networkRestrictedNatRetries);
+wireObj.network__rpc__concurrency = _api2wire_u32(apiObj.networkRpcConcurrency);
+wireObj.network__rpc__queue_size = _api2wire_u32(apiObj.networkRpcQueueSize);
+wireObj.network__rpc__max_timestamp_behind_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampBehindMs);
+wireObj.network__rpc__max_timestamp_ahead_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampAheadMs);
+wireObj.network__rpc__timeout_ms = _api2wire_u32(apiObj.networkRpcTimeoutMs);
+wireObj.network__rpc__max_route_hop_count = _api2wire_u8(apiObj.networkRpcMaxRouteHopCount);
+wireObj.network__dht__resolve_node_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtResolveNodeTimeoutMs);
+wireObj.network__dht__resolve_node_count = _api2wire_u32(apiObj.networkDhtResolveNodeCount);
+wireObj.network__dht__resolve_node_fanout = _api2wire_u32(apiObj.networkDhtResolveNodeFanout);
+wireObj.network__dht__max_find_node_count = _api2wire_u32(apiObj.networkDhtMaxFindNodeCount);
+wireObj.network__dht__get_value_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtGetValueTimeoutMs);
+wireObj.network__dht__get_value_count = _api2wire_u32(apiObj.networkDhtGetValueCount);
+wireObj.network__dht__get_value_fanout = _api2wire_u32(apiObj.networkDhtGetValueFanout);
+wireObj.network__dht__set_value_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtSetValueTimeoutMs);
+wireObj.network__dht__set_value_count = _api2wire_u32(apiObj.networkDhtSetValueCount);
+wireObj.network__dht__set_value_fanout = _api2wire_u32(apiObj.networkDhtSetValueFanout);
+wireObj.network__dht__min_peer_count = _api2wire_u32(apiObj.networkDhtMinPeerCount);
+wireObj.network__dht__min_peer_refresh_time_ms = _api2wire_u32(apiObj.networkDhtMinPeerRefreshTimeMs);
+wireObj.network__dht__validate_dial_info_receipt_time_ms = _api2wire_u32(apiObj.networkDhtValidateDialInfoReceiptTimeMs);
+wireObj.network__protocol__udp__enabled = _api2wire_bool(apiObj.networkProtocolUdpEnabled);
+wireObj.network__protocol__udp__socket_pool_size = _api2wire_u32(apiObj.networkProtocolUdpSocketPoolSize);
+wireObj.network__protocol__udp__listen_address = _api2wire_String(apiObj.networkProtocolUdpListenAddress);
+wireObj.network__protocol__udp__public_address = _api2wire_opt_String(apiObj.networkProtocolUdpPublicAddress);
+wireObj.network__protocol__tcp__connect = _api2wire_bool(apiObj.networkProtocolTcpConnect);
+wireObj.network__protocol__tcp__listen = _api2wire_bool(apiObj.networkProtocolTcpListen);
+wireObj.network__protocol__tcp__max_connections = _api2wire_u32(apiObj.networkProtocolTcpMaxConnections);
+wireObj.network__protocol__tcp__listen_address = _api2wire_String(apiObj.networkProtocolTcpListenAddress);
+wireObj.network__protocol__tcp__public_address = _api2wire_opt_String(apiObj.networkProtocolTcpPublicAddress);
+wireObj.network__protocol__ws__connect = _api2wire_bool(apiObj.networkProtocolWsConnect);
+wireObj.network__protocol__ws__listen = _api2wire_bool(apiObj.networkProtocolWsListen);
+wireObj.network__protocol__ws__max_connections = _api2wire_u32(apiObj.networkProtocolWsMaxConnections);
+wireObj.network__protocol__ws__listen_address = _api2wire_String(apiObj.networkProtocolWsListenAddress);
+wireObj.network__protocol__ws__path = _api2wire_String(apiObj.networkProtocolWsPath);
+wireObj.network__protocol__ws__url = _api2wire_opt_String(apiObj.networkProtocolWsUrl);
+wireObj.network__protocol__wss__connect = _api2wire_bool(apiObj.networkProtocolWssConnect);
+wireObj.network__protocol__wss__max_connections = _api2wire_u32(apiObj.networkProtocolWssMaxConnections);
+wireObj.network__leases__max_server_signal_leases = _api2wire_u32(apiObj.networkLeasesMaxServerSignalLeases);
+wireObj.network__leases__max_server_relay_leases = _api2wire_u32(apiObj.networkLeasesMaxServerRelayLeases);
+wireObj.network__leases__max_client_signal_leases = _api2wire_u32(apiObj.networkLeasesMaxClientSignalLeases);
+wireObj.network__leases__max_client_relay_leases = _api2wire_u32(apiObj.networkLeasesMaxClientRelayLeases);
         }
         }
 
@@ -463,57 +373,62 @@ String _wire2api_String(dynamic raw) {
             return raw as String;
         }
         
+
 AttachmentState _wire2api_attachment_state(dynamic raw) {
             return AttachmentState.values[raw];
         }
         
+
 int _wire2api_u32(dynamic raw) {
             return raw as int;
         }
         
+
 int _wire2api_u8(dynamic raw) {
             return raw as int;
         }
         
+
 Uint8List _wire2api_uint_8_list(dynamic raw) {
             return raw as Uint8List;
         }
         
+
 void _wire2api_unit(dynamic raw) {
             return;
         }
         
+
+VeilidLogLevel _wire2api_veilid_log_level(dynamic raw) {
+            return VeilidLogLevel.values[raw];
+        }
+        
+
 VeilidState _wire2api_veilid_state(dynamic raw) {
             final arr = raw as List<dynamic>;
-  if (arr.length != 1)
-    throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
-  return VeilidState(
-    attachment: _wire2api_attachment_state(arr[0]),
-  );
+                if (arr.length != 1) throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
+                return VeilidState(attachment: _wire2api_attachment_state(arr[0]),);
         }
         
+
 VeilidUpdate _wire2api_veilid_update(dynamic raw) {
             switch (raw[0]) {
-    case 0:
-      return Attachment(
-        _wire2api_attachment_state(raw[1]),
-      );
-    default:
-      throw Exception("unreachable");
+                    case 0: return Log(_wire2api_veilid_log_level(raw[1]),_wire2api_String(raw[2]),);
+case 1: return Attachment(_wire2api_attachment_state(raw[1]),);
+                    default: throw Exception("unreachable");
                 }
         }
         
+
 VeilidVersion _wire2api_veilid_version(dynamic raw) {
             final arr = raw as List<dynamic>;
-  if (arr.length != 3)
-    throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
-  return VeilidVersion(
-    major: _wire2api_u32(arr[0]),
+                if (arr.length != 3) throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
+                return VeilidVersion(major: _wire2api_u32(arr[0]),
 minor: _wire2api_u32(arr[1]),
-    patch: _wire2api_u32(arr[2]),
-  );
+patch: _wire2api_u32(arr[2]),);
         }
         
+        
 // ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names
 
 // AUTO GENERATED FILE, DO NOT EDIT.
@@ -886,6 +801,8 @@ class wire_VeilidConfig extends ffi.Struct {
   external int network__leases__max_client_relay_leases;
 }
 
+
+
 typedef DartPostCObjectFnType = ffi.Pointer<
     ffi.NativeFunction<ffi.Uint8 Function(DartPort, ffi.Pointer<ffi.Void>)>>;
 typedef DartPort = ffi.Int64;

veilid-flutter/rust/src/api.rs

@@ -427,14 +427,36 @@ impl AttachmentState {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum VeilidLogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+impl VeilidLogLevel {
+    fn from_core(level: veilid_core::VeilidLogLevel) -> Self {
+        match level {
+            veilid_core::VeilidLogLevel::Error => VeilidLogLevel::Error,
+            veilid_core::VeilidLogLevel::Warn => VeilidLogLevel::Warn,
+            veilid_core::VeilidLogLevel::Info => VeilidLogLevel::Info,
+            veilid_core::VeilidLogLevel::Debug => VeilidLogLevel::Debug,
+            veilid_core::VeilidLogLevel::Trace => VeilidLogLevel::Trace,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum VeilidUpdate {
+    Log(VeilidLogLevel, String),
     Attachment(AttachmentState),
 }
 
 impl VeilidUpdate {
     fn from_core(veilid_update: veilid_core::VeilidUpdate) -> Self {
         match veilid_update {
+            veilid_core::VeilidUpdate::Log(ll, s) => Self::Log(VeilidLogLevel::from_core(ll), s),
             veilid_core::VeilidUpdate::Attachment(attachment) => {
                 Self::Attachment(AttachmentState::from_core(attachment))
             }

veilid-flutter/rust/src/bridge_generated.rs

@@ -491,6 +491,19 @@ impl support::IntoDart for AttachmentState {
     }
 }
 
+impl support::IntoDart for VeilidLogLevel {
+    fn into_dart(self) -> support::DartCObject {
+        match self {
+            Self::Error => 0,
+            Self::Warn => 1,
+            Self::Info => 2,
+            Self::Debug => 3,
+            Self::Trace => 4,
+        }
+        .into_dart()
+    }
+}
+
 impl support::IntoDart for VeilidState {
     fn into_dart(self) -> support::DartCObject {
         vec![self.attachment.into_dart()].into_dart()
@@ -501,7 +514,10 @@ impl support::IntoDartExceptPrimitive for VeilidState {}
 impl support::IntoDart for VeilidUpdate {
     fn into_dart(self) -> support::DartCObject {
         match self {
-            Self::Attachment(field0) => vec![0.into_dart(), field0.into_dart()],
+            Self::Log(field0, field1) => {
+                vec![0.into_dart(), field0.into_dart(), field1.into_dart()]
+            }
+            Self::Attachment(field0) => vec![1.into_dart(), field0.into_dart()],
         }
         .into_dart()
     }

veilid-flutter/rust/src/lib.rs

@@ -3,35 +3,16 @@ mod bridge_generated;
 
 use cfg_if::*;
 
-xxx make this work
-
-#[cfg(all(target_os = "android", feature = "android_tests"))]
+#[cfg(target_os = "android")]
 use jni::{objects::JClass, objects::JObject, JNIEnv};
 
-#[cfg(all(target_os = "android", feature = "android_tests"))]
+#[cfg(target_os = "android")]
 #[no_mangle]
 #[allow(non_snake_case)]
-pub extern "system" fn Java_com_veilid_veilidcore_veilidcore_1android_1tests_MainActivity_run_1tests(
+pub extern "system" fn Java_com_veilid_veilid_VeilidPlugin_init_1android(
     env: JNIEnv,
     _class: JClass,
     ctx: JObject,
 ) {
-    crate::intf::utils::android::veilid_core_setup_android(env, ctx, "veilid_core", Level::Trace);
-}
-
-#[cfg(target_os = "ios")]
-#[no_mangle]
-pub extern "C" fn run_veilid_core_tests(app_name: c_str) {
-    let log_path: std::path::PathBuf = [
-        std::env::var("HOME").unwrap().as_str(),
-        "Documents",
-        "veilid-core.log",
-    ]
-    .iter()
-    .collect();
-    crate::intf::utils::setup::veilid_core_setup(
-        "veilid-core",
-        Some(Level::Trace),
-        Some((Level::Trace, log_path.as_path())),
-    );
+    crate::intf::utils::android::veilid_core_setup_android_no_log(env, ctx);
 }

veilid-server/src/client_api.rs

@@ -36,6 +36,9 @@ fn convert_update(
     rpc_update: crate::veilid_client_capnp::veilid_update::Builder,
 ) {
     match update {
+        veilid_core::VeilidUpdate::Log(_ll, _s) => {
+            panic!("Should not be logging to api in server!");
+        }
         veilid_core::VeilidUpdate::Attachment(state) => {
             let mut att = rpc_update.init_attachment();
             att.set_state(convert_attachment_state(state));
@@ -358,6 +361,7 @@ impl ClientApi {
     }
 
     pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) {
+        // Pass other updates to clients
         self.send_request_to_all_clients(|_id, registration| {
             let mut request = registration.client.update_request();
             let rpc_veilid_update = request.get().init_veilid_update();

veilid-server/src/settings.rs

@@ -751,6 +751,7 @@ impl Settings {
                 } else {
                     format!("subnode{}", inner.testing.subnode_index)
                 })),
+                "log_to_api" => Ok(Box::new(false)),
                 "capabilities.protocol_udp" => Ok(Box::new(true)),
                 "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
                 "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),