fix(flutter): apply runtime capability changes

Author: Chinmay-KB

sdks/flutter/packages/tugboat/lib/src/lifecycle.dart

@@ -47,7 +47,6 @@ class TugboatLifecycleNotifier extends ChangeNotifier {
 
   void deactivate() {
     if (_state == TugboatLifecycleState.dormant &&
-        _captureOverride == false &&
         _activationRequestId == null) {
       return;
     }
@@ -91,6 +90,16 @@ class TugboatLifecycleNotifier extends ChangeNotifier {
     notifyListeners();
   }
 
+  /// Advances the session epoch while the gate rebuilds for changed grants.
+  ///
+  /// The gate is already rebuilding, so [markActive] sends the next lifecycle
+  /// notification after the replacement session starts.
+  int beginCapabilityRemount() {
+    _requestEpoch += 1;
+    _state = TugboatLifecycleState.starting;
+    return _requestEpoch;
+  }
+
   /// Called by the gate when capture machinery is fully up.
   void markActive(int epoch) {
     if (epoch != _requestEpoch) return;

sdks/flutter/packages/tugboat/lib/src/replay_config.dart

@@ -47,7 +47,7 @@ TugboatViewportSemanticPolicy resolveViewportSemanticPolicy({
     engineEnabled: true,
     emitEvents: shouldEmitEvents,
     debugLogs: debugLogs,
-    holdPersistentSemanticsHandle: emitEvents,
+    holdPersistentSemanticsHandle: shouldEmitEvents,
   );
 }
 

sdks/flutter/packages/tugboat/lib/src/tugboat.dart

@@ -367,9 +367,21 @@ class _TugboatActivationGateState extends State<_TugboatActivationGate> {
     super.didUpdateWidget(oldWidget);
     if (oldWidget.config.enabled != widget.config.enabled) {
       _syncCaptureFlag();
+    } else if (_captureMounted &&
+        _capabilitiesChanged(oldWidget.config, widget.config)) {
+      _mountedEpoch = TugboatReplay._lifecycle.beginCapabilityRemount();
     }
   }
 
+  bool _capabilitiesChanged(
+    TugboatReplayConfig previous,
+    TugboatReplayConfig current,
+  ) =>
+      previous.emitSceneInventory != current.emitSceneInventory ||
+      previous.emitViewportSemanticMap != current.emitViewportSemanticMap ||
+      previous.emitCaptureDiagnostics != current.emitCaptureDiagnostics ||
+      previous.acceptActionContext != current.acceptActionContext;
+
   @override
   void dispose() {
     TugboatReplay._lifecycle.removeListener(_listener);

sdks/flutter/packages/tugboat/test/tugboat_replay_test.dart

@@ -1399,6 +1399,15 @@ void main() {
     expect(TugboatReplay.isActivated, isFalse);
   });
 
+  test('deactivate is a no-op from the initial dormant state', () {
+    addTearDown(TugboatReplay.resetForTest);
+    TugboatReplay.resetForTest();
+
+    TugboatReplay.deactivate();
+
+    expect(TugboatReplay.lifecycleState, TugboatLifecycleState.dormant);
+  });
+
   testWidgets('enabled config reaches the active lifecycle state', (
     tester,
   ) async {
@@ -1417,6 +1426,44 @@ void main() {
     expect(TugboatReplay.lifecycleState, TugboatLifecycleState.active);
   });
 
+  testWidgets('capability changes remount the active capture session', (
+    tester,
+  ) async {
+    addTearDown(TugboatReplay.resetForTest);
+    final inventoryGrant = ValueNotifier<bool>(false);
+    addTearDown(inventoryGrant.dispose);
+
+    await tester.pumpWidget(
+      ValueListenableBuilder<bool>(
+        valueListenable: inventoryGrant,
+        builder: (context, granted, _) => MaterialApp(
+          builder: (context, child) => TugboatReplay.wrapApp(
+            config: _testConfig.copyWith(emitSceneInventory: granted),
+            child: child!,
+          ),
+          home: const Scaffold(body: Text('Capability grant')),
+        ),
+      ),
+    );
+    await _waitForCaptures(tester);
+    final initialController = TugboatReplay.controller!;
+    expect(initialController.config.emitSceneInventory, isFalse);
+
+    inventoryGrant.value = true;
+    await _waitForCaptures(tester);
+    final grantedController = TugboatReplay.controller!;
+    expect(grantedController, isNot(same(initialController)));
+    expect(grantedController.config.emitSceneInventory, isTrue);
+    expect(TugboatReplay.lifecycleState, TugboatLifecycleState.active);
+
+    inventoryGrant.value = false;
+    await _waitForCaptures(tester);
+    final revokedController = TugboatReplay.controller!;
+    expect(revokedController, isNot(same(grantedController)));
+    expect(revokedController.config.emitSceneInventory, isFalse);
+    expect(TugboatReplay.lifecycleState, TugboatLifecycleState.active);
+  });
+
   testWidgets('disabled config stays inert until activated without rebuild', (
     tester,
   ) async {

sdks/flutter/packages/tugboat/test/viewport_semantic_policy_test.dart

@@ -30,6 +30,7 @@ void main() {
     );
     expect(tapOnly.engineEnabled, isTrue);
     expect(tapOnly.emitEvents, isFalse);
+    expect(tapOnly.holdPersistentSemanticsHandle, isFalse);
 
     final defaultPolicy = const TugboatReplayConfig(
       enabled: true,