Wire Share My Connection toggle in Dart UI (PR 4/4)

Final PR in the four-PR stack. Stacks on lantern #8729 (FFI exports);
combined with radiance #458 / #460 / lantern-cloud #2678-#2681 this
ships a feature-complete Phase 1 of "Share My Connection" for desktop
(macOS + Linux + Windows).

* lantern_generated_bindings.dart: add setPeerProxyEnabled +
  isPeerProxyEnabled. Manually inserted to match the existing pattern
  rather than regenerating the whole file (a local ffigen run from
  the macOS header would drop ~5K lines of Windows-only declarations
  the upstream generator emits).
* LanternCoreService / LanternFFIService / LanternPlatformService /
  LanternService: add setPeerProxyEnabled / isPeerProxyEnabled across
  all four service layers, mirroring the setBlockAdsEnabled pattern.
  FFI path on isFFISupported platforms (Windows + Linux), MethodChannel
  fallback on macOS / mobile.
* RadianceSettingsState: new peerProxy bool field with copyWith and
  equality.
* RadianceSettings notifier: new setPeerProxy method (pessimistic —
  call FFI, log on failure, update state on success — matching
  setBlockAds). _refresh now reads peerProxy alongside the others.
* vpn_setting.dart: SwitchButton tile gated to PlatformUtils.isDesktop
  with i18n strings share_my_connection / share_my_connection_subtitle
  in en.po. Other locales will pick up via the standard translation
  flow.

Lifecycle end-to-end:

  Dart toggle → RadianceSettings.setPeerProxy(bool)
  → LanternService.setPeerProxyEnabled
  → FFI: setPeerProxyEnabled(int) -> *char
  → Core.SetPeerShareEnabled(bool)
  → ipc.Client.PatchSettings({PeerShareEnabledKey: ...})
  → radiance LocalBackend.PatchSettings dispatch
  → peer.Client.Start / Stop
  → UPnP MapPort + register + sing-box samizdat inbound + heartbeat

flutter analyze: clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 2 people

assets/locales/en.po

@@ -551,6 +551,12 @@ msgstr "Block Ads"
 msgid "only_active"
 msgstr "Only active when VPN is connected"
 
+msgid "share_my_connection"
+msgstr "Share My Connection"
+
+msgid "share_my_connection_subtitle"
+msgstr "Let other Lantern users route through your connection to bypass censorship."
+
 msgid "vpn_connected"
 msgstr "Lantern is now connected."
 

lib/core/models/radiance_settings_state.dart

@@ -12,25 +12,29 @@ class RadianceSettingsState {
   final RoutingMode routingMode;
   final bool splitTunneling;
   final bool telemetry;
+  final bool peerProxy;
 
   const RadianceSettingsState({
     this.blockAds = false,
     this.routingMode = RoutingMode.full,
     this.splitTunneling = false,
     this.telemetry = false,
+    this.peerProxy = false,
   });
 
   RadianceSettingsState copyWith({
     bool? blockAds,
     RoutingMode? routingMode,
     bool? splitTunneling,
     bool? telemetry,
+    bool? peerProxy,
   }) {
     return RadianceSettingsState(
       blockAds: blockAds ?? this.blockAds,
       routingMode: routingMode ?? this.routingMode,
       splitTunneling: splitTunneling ?? this.splitTunneling,
       telemetry: telemetry ?? this.telemetry,
+      peerProxy: peerProxy ?? this.peerProxy,
     );
   }
 
@@ -41,9 +45,10 @@ class RadianceSettingsState {
           blockAds == other.blockAds &&
           routingMode == other.routingMode &&
           splitTunneling == other.splitTunneling &&
-          telemetry == other.telemetry;
+          telemetry == other.telemetry &&
+          peerProxy == other.peerProxy;
 
   @override
   int get hashCode =>
-      Object.hash(blockAds, routingMode, splitTunneling, telemetry);
+      Object.hash(blockAds, routingMode, splitTunneling, telemetry, peerProxy);
 }

lib/features/home/provider/radiance_settings_providers.dart

@@ -29,16 +29,19 @@ class RadianceSettings extends _$RadianceSettings {
     final routingF = svc.isSmartRoutingEnabled();
     final telemetryF = svc.isTelemetryEnabled();
     final splitF = PlatformUtils.isIOS ? null : svc.isSplitTunnelingEnabled();
+    final peerProxyF = svc.isPeerProxyEnabled();
 
     final results = await Future.wait([
       blockAdsF,
       routingF,
       telemetryF,
       ?splitF,
+      peerProxyF,
     ]);
     if (!ref.mounted) return;
 
     const defaults = RadianceSettingsState();
+    final peerIdx = splitF == null ? 3 : 4;
     state = RadianceSettingsState(
       blockAds: results[0].fold((_) => defaults.blockAds, (v) => v),
       routingMode: results[1].fold(
@@ -49,6 +52,7 @@ class RadianceSettings extends _$RadianceSettings {
       splitTunneling: splitF == null
           ? defaults.splitTunneling
           : results[3].fold((_) => defaults.splitTunneling, (v) => v),
+      peerProxy: results[peerIdx].fold((_) => defaults.peerProxy, (v) => v),
     );
   }
 
@@ -97,6 +101,16 @@ class RadianceSettings extends _$RadianceSettings {
       (_) => state = state.copyWith(telemetry: consent),
     );
   }
+
+  Future<void> setPeerProxy(bool value) async {
+    final svc = ref.read(lanternServiceProvider);
+    final result = await svc.setPeerProxyEnabled(value);
+    if (!ref.mounted) return;
+    result.fold(
+      (err) => appLogger.error('setPeerProxyEnabled failed: ${err.error}'),
+      (_) => state = state.copyWith(peerProxy: value),
+    );
+  }
 }
 
 /// Fetches whether user logged in via OAuth from radiance.

lib/features/setting/vpn_setting.dart

@@ -35,6 +35,9 @@ class VPNSetting extends HookConsumerWidget {
     final telemetryConsent = ref.watch(
       radianceSettingsProvider.select((s) => s.telemetry),
     );
+    final peerProxy = ref.watch(
+      radianceSettingsProvider.select((s) => s.peerProxy),
+    );
 
     return ListView(
       padding: const EdgeInsets.all(0),
@@ -117,6 +120,36 @@ class VPNSetting extends HookConsumerWidget {
             },
           ),
         ),
+        if (PlatformUtils.isDesktop) ...{
+          SizedBox(height: 16),
+          AppCard(
+            padding: EdgeInsets.zero,
+            child: AppTile(
+              label: 'share_my_connection'.i18n,
+              subtitle: Text(
+                'share_my_connection_subtitle'.i18n,
+                style: textTheme.labelMedium!.copyWith(
+                  color: context.textTertiary,
+                  letterSpacing: 0.0,
+                ),
+              ),
+              icon: AppImagePaths.share,
+              trailing: SwitchButton(
+                value: peerProxy,
+                onChanged: (bool? value) {
+                  ref
+                      .read(radianceSettingsProvider.notifier)
+                      .setPeerProxy(value ?? false);
+                },
+              ),
+              onPressed: () {
+                ref
+                    .read(radianceSettingsProvider.notifier)
+                    .setPeerProxy(!peerProxy);
+              },
+            ),
+          ),
+        },
         SizedBox(height: 16),
         AppCard(
           padding: EdgeInsets.zero,

lib/lantern/lantern_core_service.dart

@@ -79,6 +79,10 @@ abstract class LanternCoreService {
 
   Future<Either<Failure, bool>> isBlockAdsEnabled();
 
+  Future<Either<Failure, Unit>> setPeerProxyEnabled(bool enabled);
+
+  Future<Either<Failure, bool>> isPeerProxyEnabled();
+
   Future<Either<Failure, bool>> isSmartRoutingEnabled();
 
   Future<Either<Failure, bool>> isTelemetryEnabled();

lib/lantern/lantern_ffi_service.dart

@@ -1550,6 +1550,34 @@ class LanternFFIService implements LanternCoreService {
     }
   }
 
+  @override
+  Future<Either<Failure, Unit>> setPeerProxyEnabled(bool enabled) async {
+    try {
+      final result = await runInBackground<String>(() async {
+        return _ffiService
+            .setPeerProxyEnabled(enabled ? 1 : 0)
+            .cast<Utf8>()
+            .toDartString();
+      });
+      checkAPIError(result);
+      return right(unit);
+    } catch (e, st) {
+      appLogger.error('setPeerProxyEnabled error: $e', e, st);
+      return Left(e.toFailure());
+    }
+  }
+
+  @override
+  Future<Either<Failure, bool>> isPeerProxyEnabled() async {
+    try {
+      final res = _ffiService.isPeerProxyEnabled();
+      return right(res != 0);
+    } catch (e, st) {
+      appLogger.error('isPeerProxyEnabled error: $e', e, st);
+      return Left(e.toFailure());
+    }
+  }
+
   @override
   Future<Either<Failure, bool>> isSmartRoutingEnabled() async {
     try {

lib/lantern/lantern_generated_bindings.dart

@@ -6275,6 +6275,26 @@ class LanternBindings {
   late final _isBlockAdsEnabled = _isBlockAdsEnabledPtr
       .asFunction<int Function()>();
 
+  ffi.Pointer<ffi.Char> setPeerProxyEnabled(int enabled) {
+    return _setPeerProxyEnabled(enabled);
+  }
+
+  late final _setPeerProxyEnabledPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int)>>(
+        'setPeerProxyEnabled',
+      );
+  late final _setPeerProxyEnabled = _setPeerProxyEnabledPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(int)>();
+
+  int isPeerProxyEnabled() {
+    return _isPeerProxyEnabled();
+  }
+
+  late final _isPeerProxyEnabledPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function()>>('isPeerProxyEnabled');
+  late final _isPeerProxyEnabled = _isPeerProxyEnabledPtr
+      .asFunction<int Function()>();
+
   ffi.Pointer<ffi.Char> setSmartRoutingEnabled(int enabled) {
     return _setSmartRoutingEnabled(enabled);
   }

lib/lantern/lantern_platform_service.dart

@@ -290,6 +290,30 @@ class LanternPlatformService implements LanternCoreService {
     }
   }
 
+  @override
+  Future<Either<Failure, Unit>> setPeerProxyEnabled(bool enabled) async {
+    try {
+      await _methodChannel.invokeMethod('setPeerProxyEnabled', {
+        'enabled': enabled,
+      });
+      return right(unit);
+    } catch (e, st) {
+      appLogger.error('setPeerProxyEnabled failed', e, st);
+      return Left(e.toFailure());
+    }
+  }
+
+  @override
+  Future<Either<Failure, bool>> isPeerProxyEnabled() async {
+    try {
+      final res = await _methodChannel.invokeMethod<bool>('isPeerProxyEnabled');
+      return right(res ?? false);
+    } catch (e, st) {
+      appLogger.error('isPeerProxyEnabled failed', e, st);
+      return Left(e.toFailure());
+    }
+  }
+
   @override
   Future<Either<Failure, bool>> isSmartRoutingEnabled() async {
     try {

lib/lantern/lantern_service.dart

@@ -794,6 +794,22 @@ class LanternService implements LanternCoreService {
     return _platformService.setBlockAdsEnabled(enabled);
   }
 
+  @override
+  Future<Either<Failure, bool>> isPeerProxyEnabled() {
+    if (PlatformUtils.isFFISupported) {
+      return _ffiService.isPeerProxyEnabled();
+    }
+    return _platformService.isPeerProxyEnabled();
+  }
+
+  @override
+  Future<Either<Failure, Unit>> setPeerProxyEnabled(bool enabled) {
+    if (PlatformUtils.isFFISupported) {
+      return _ffiService.setPeerProxyEnabled(enabled);
+    }
+    return _platformService.setPeerProxyEnabled(enabled);
+  }
+
   @override
   Future<Either<Failure, bool>> isSmartRoutingEnabled() {
     if (PlatformUtils.isFFISupported) {