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

assets/locales/en.po

@@ -488,6 +488,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,23 @@ class RadianceSettings extends _$RadianceSettings {
     final routingF = svc.isSmartRoutingEnabled();
     final telemetryF = svc.isTelemetryEnabled();
     final splitF = PlatformUtils.isIOS ? null : svc.isSplitTunnelingEnabled();
+    // Peer-proxy probe runs only on platforms with native handlers
+    // (Windows + Linux via FFI, macOS via MethodChannel — i.e. all desktop).
+    // On iOS / Android the call would fail with MissingPluginException on
+    // every settings init.
+    final peerF = PlatformUtils.isDesktop ? svc.isPeerProxyEnabled() : null;
 
     final results = await Future.wait([
       blockAdsF,
       routingF,
       telemetryF,
       ?splitF,
+      ?peerF,
     ]);
     if (!ref.mounted) return;
 
     const defaults = RadianceSettingsState();
+    final peerIdx = 3 + (splitF == null ? 0 : 1);
     state = RadianceSettingsState(
       blockAds: results[0].fold((_) => defaults.blockAds, (v) => v),
       routingMode: results[1].fold(
@@ -49,6 +56,9 @@ class RadianceSettings extends _$RadianceSettings {
       splitTunneling: splitF == null
           ? defaults.splitTunneling
           : results[3].fold((_) => defaults.splitTunneling, (v) => v),
+      peerProxy: peerF == null
+          ? defaults.peerProxy
+          : results[peerIdx].fold((_) => defaults.peerProxy, (v) => v),
     );
   }
 
@@ -97,6 +107,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

@@ -76,6 +76,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

@@ -1508,6 +1508,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

@@ -6253,6 +6253,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

@@ -288,6 +288,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

@@ -773,6 +773,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) {

macos/Runner/Handlers/MethodHandler.swift

@@ -245,6 +245,16 @@ class MethodHandler {
         let enabled = data?["enabled"] as? Bool ?? false
         self.setBlockAdsEnabled(result: result, enabled: enabled)
 
+      case "isPeerProxyEnabled":
+        Task {
+          await MainActor.run { result(MobileIsPeerShareEnabled()) }
+        }
+
+      case "setPeerProxyEnabled":
+        let data = call.arguments as? [String: Any]
+        let enabled = data?["enabled"] as? Bool ?? false
+        self.setPeerProxyEnabled(result: result, enabled: enabled)
+
       case "updateTelemetryEvents":
         guard let consent: Bool = self.decodeValue(from: call.arguments, result: result) else {
           return
@@ -1131,6 +1141,20 @@ class MethodHandler {
     }
   }
 
+  func setPeerProxyEnabled(result: @escaping FlutterResult, enabled: Bool) {
+    Task {
+      var error: NSError?
+      MobileSetPeerShareEnabled(enabled, &error)
+      if let error {
+        await self.handleFlutterError(error, result: result, code: "SET_PEER_PROXY_ERROR")
+        return
+      }
+      await MainActor.run {
+        result("ok")
+      }
+    }
+  }
+
   func updateTelemetryEvents(consent: Bool, result: @escaping FlutterResult) {
     Task {
       var error: NSError?