Otzaria · Y-PLONI · Aug 27, 2026 · Aug 27, 2026 · Aug 27, 2026 · Aug 27, 2026
diff --git a/flutter_inappwebview/CHANGELOG.md b/flutter_inappwebview/CHANGELOG.md
@@ -1,5 +1,8 @@
 ## 6.2.0-beta.3
 
+- Added Android `InAppWebViewController.setBackgroundColor`.
+- Added `WebAuthenticationSession.additionalHeaderFields` on iOS 17.4+ and
+  macOS 14.4+.
 - Added Linux support
 - Updated dependencies to the latest versions for all platform implementations:
   - `flutter_inappwebview_platform_interface`: `^1.4.0-beta.2` -> `^1.4.0-beta.3`

diff --git a/flutter_inappwebview/example/integration_test/in_app_webview/intercept_ajax_request.dart b/flutter_inappwebview/example/integration_test/in_app_webview/intercept_ajax_request.dart
@@ -391,5 +391,77 @@ void interceptAjaxRequest() {
         true,
       );
     });
+
+    skippableTestWidgets('receive blob response', (WidgetTester tester) async {
+      final readyStateResponse = Completer<List<int>>();
+      final progressResponse = Completer<List<int>>();
+      List<int> responseBytes(dynamic response) {
+        if (response is List) return List<int>.from(response);
+        final entries = (response as Map).entries.toList()
+          ..sort(
+            (a, b) => int.parse(
+              a.key.toString(),
+            ).compareTo(int.parse(b.key.toString())),
+          );
+        return List<int>.from(entries.map((entry) => entry.value));
+      }
+
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: InAppWebView(
+            key: GlobalKey(),
+            initialData: InAppWebViewInitialData(
+              data: """
+<!doctype html>
+<html lang="en">
+  <body>
+    <script>
+      window.addEventListener('flutterInAppWebViewPlatformReady', function() {
+        const blob = new Blob([new Uint8Array([0, 1, 255])]);
+        const blobUrl = URL.createObjectURL(blob);
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', blobUrl);
+        xhr.responseType = 'blob';
+        xhr.addEventListener('loadend', function() {
+          URL.revokeObjectURL(blobUrl);
+        });
+        xhr.send();
+      });
+    </script>
+  </body>
+</html>
+""",
+            ),
+            shouldInterceptAjaxRequest: (controller, request) async => request,
+            onAjaxReadyStateChange: (controller, request) async {
+              if (request.readyState == AjaxRequestReadyState.DONE &&
+                  request.response != null &&
+                  !readyStateResponse.isCompleted) {
+                readyStateResponse.complete(responseBytes(request.response));
+              }
+              return AjaxRequestAction.PROCEED;
+            },
+            onAjaxProgress: (controller, request) async {
+              if (request.event?.type == AjaxRequestEventType.LOAD &&
+                  request.response != null &&
+                  !progressResponse.isCompleted) {
+                progressResponse.complete(responseBytes(request.response));
+              }
+              return AjaxRequestAction.PROCEED;
+            },
+          ),
+        ),
+      );
+
+      expect(
+        await readyStateResponse.future.timeout(const Duration(seconds: 10)),
+        [0, 1, 255],
+      );
+      expect(
+        await progressResponse.future.timeout(const Duration(seconds: 10)),
+        [0, 1, 255],
+      );
+    });
   }, skip: shouldSkip);
 }
diff --git a/flutter_inappwebview/example/integration_test/in_app_webview/javascript_code_evaluation.dart b/flutter_inappwebview/example/integration_test/in_app_webview/javascript_code_evaluation.dart
@@ -96,6 +96,65 @@ void javascriptCodeEvaluation() {
       expect(result, 49);
     }, skip: shouldSkipTest2);
 
+    final shouldSkipPrintBoundaryTest =
+        kIsWeb ||
+        (!Platform.isIOS && !Platform.isMacOS) ||
+        !InAppWebViewController.isMethodSupported(
+          PlatformInAppWebViewControllerMethod.evaluateJavascript,
+        );
+
+    skippableTestWidgets(
+      'content world IIFE does not invoke print',
+      (WidgetTester tester) async {
+        final controllerCompleter = Completer<InAppWebViewController>();
+        final firstLoad = Completer<void>();
+        final secondLoad = Completer<void>();
+        var printRequests = 0;
+
+        await tester.pumpWidget(
+          Directionality(
+            textDirection: TextDirection.ltr,
+            child: InAppWebView(
+              key: GlobalKey(),
+              initialUrlRequest: URLRequest(url: TEST_URL_ABOUT_BLANK),
+              onWebViewCreated: controllerCompleter.complete,
+              onLoadStop: (controller, url) {
+                if (!firstLoad.isCompleted) {
+                  firstLoad.complete();
+                } else if (!secondLoad.isCompleted) {
+                  secondLoad.complete();
+                }
+              },
+              onPrintRequest: (controller, url, printJob) async {
+                printRequests++;
+                return false;
+              },
+            ),
+          ),
+        );
+
+        final controller = await controllerCompleter.future;
+        await firstLoad.future;
+        final contentWorld = ContentWorld.world(name: 'print-boundary-world');
+
+        Future<void> expectIifeEvaluation() async {
+          final result = await controller.evaluateJavascript(
+            source: "(function () { return 'content-world-ok'; })();",
+            contentWorld: contentWorld,
+          );
+          expect(result, 'content-world-ok');
+          await tester.pump();
+          expect(printRequests, 0);
+        }
+
+        await expectIifeEvaluation();
+        await controller.reload();
+        await secondLoad.future;
+        await expectIifeEvaluation();
+      },
+      skip: shouldSkipPrintBoundaryTest,
+    );
+
     final shouldSkipTest3 = !InAppWebViewController.isMethodSupported(
       PlatformInAppWebViewControllerMethod.callAsyncJavaScript,
     );

diff --git a/flutter_inappwebview/example/integration_test/in_app_webview/webview_windows.dart b/flutter_inappwebview/example/integration_test/in_app_webview/webview_windows.dart
@@ -87,7 +87,7 @@ void webViewWindows() {
 
       var windowId = await onCreateWindowCompleter.future;
 
-      final Completer windowControllerCompleter =
+      final Completer<InAppWebViewController> windowControllerCompleter =
           Completer<InAppWebViewController>();
       final Completer<String> windowPageLoaded = Completer<String>();
       final Completer<void> onCloseWindowCompleter = Completer<void>();
@@ -105,7 +105,6 @@ void webViewWindows() {
             onLoadStop: (controller, url) async {
               if (url!.scheme != "about" && !windowPageLoaded.isCompleted) {
                 windowPageLoaded.complete(url.toString());
-                await controller.evaluateJavascript(source: "window.close();");
               }
             },
             onCloseWindow: (controller) {
@@ -118,8 +117,144 @@ void webViewWindows() {
       await tester.pump();
 
       final String windowUrlLoaded = await windowPageLoaded.future;
+      final windowController = await windowControllerCompleter.future;
 
       expect(windowUrlLoaded, TEST_URL_EXAMPLE.toString());
+
+      if (Platform.isIOS) {
+        final popupWorld = ContentWorld.world(name: 'popup-evaluation');
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'window.popupPageValue = 7; window.popupPageValue;',
+          ),
+          7,
+        );
+
+        final namedWorldValue = await windowController.evaluateJavascript(
+          source: 'window.popupPageValue = 49; window.popupPageValue;',
+          contentWorld: popupWorld,
+        );
+        // iOS 18+ preserves the named world; iOS 14-17 fails closed because
+        // WebKit can crash when that overload is used by a popup WebView.
+        expect(namedWorldValue, anyOf(isNull, 49));
+
+        // A named-world request must never fall back to the page world.
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'window.popupPageValue;',
+          ),
+          7,
+        );
+
+        final persistedNamedWorldValue = await windowController
+            .evaluateJavascript(
+              source: 'window.popupPageValue;',
+              contentWorld: popupWorld,
+            );
+        if (namedWorldValue == null) {
+          expect(persistedNamedWorldValue, isNull);
+        } else {
+          expect(persistedNamedWorldValue, 49);
+          expect(
+            await windowController.evaluateJavascript(
+              source: 'typeof window.popupOnlyValue;',
+            ),
+            'undefined',
+          );
+          expect(
+            await windowController.evaluateJavascript(
+              source: 'window.popupOnlyValue = 11;',
+              contentWorld: popupWorld,
+            ),
+            11,
+          );
+          expect(
+            await windowController.evaluateJavascript(
+              source: 'typeof window.popupOnlyValue;',
+            ),
+            'undefined',
+          );
+        }
+
+        final asyncPageWorldResult = await windowController.callAsyncJavaScript(
+          functionBody:
+              'await Promise.resolve(); '
+              'window.popupPageAsyncValue = n + 2; '
+              'return window.popupPageAsyncValue;',
+          arguments: {'n': 40},
+        );
+        expect(asyncPageWorldResult, isNotNull);
+        expect(asyncPageWorldResult!.value, 42);
+        expect(asyncPageWorldResult.error, isNull);
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'window.popupPageAsyncValue;',
+          ),
+          42,
+        );
+        final explicitPageWorldResult = await windowController
+            .callAsyncJavaScript(
+              functionBody: 'return n + 3;',
+              arguments: {'n': 39},
+              contentWorld: ContentWorld.PAGE,
+            );
+        expect(explicitPageWorldResult, isNotNull);
+        expect(explicitPageWorldResult!.value, 42);
+        expect(explicitPageWorldResult.error, isNull);
+
+        final asyncPageWorldError = await windowController.callAsyncJavaScript(
+          functionBody: "throw new Error('popup-page-async-error');",
+        );
+        expect(asyncPageWorldError, isNotNull);
+        expect(asyncPageWorldError!.value, isNull);
+        expect(asyncPageWorldError.error, contains('popup-page-async-error'));
+
+        final asyncNamedWorldResult = await windowController
+            .callAsyncJavaScript(
+              functionBody:
+                  'window.popupAsyncOnlyValue = 23; '
+                  'return window.popupAsyncOnlyValue;',
+              contentWorld: popupWorld,
+            );
+        expect(asyncNamedWorldResult, isNotNull);
+        if (namedWorldValue == null) {
+          expect(asyncNamedWorldResult!.value, isNull);
+          expect(asyncNamedWorldResult.error, isNotNull);
+        } else {
+          expect(asyncNamedWorldResult!.value, 23);
+          expect(asyncNamedWorldResult.error, isNull);
+        }
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'typeof window.popupAsyncOnlyValue;',
+          ),
+          'undefined',
+        );
+
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'null;',
+            contentWorld: popupWorld,
+          ),
+          isNull,
+        );
+        expect(
+          await windowController.evaluateJavascript(
+            source: 'undefined;',
+            contentWorld: popupWorld,
+          ),
+          isNull,
+        );
+        expect(
+          await windowController.evaluateJavascript(
+            source: "throw new Error('popup-eval-error');",
+            contentWorld: popupWorld,
+          ),
+          isNull,
+        );
+      }
+
+      await windowController.evaluateJavascript(source: 'window.close();');
       await expectLater(onCloseWindowCompleter.future, completes);
     }, skip: shouldSkipTest2);
 

diff --git a/flutter_inappwebview/lib/src/in_app_webview/in_app_webview_controller.dart b/flutter_inappwebview/lib/src/in_app_webview/in_app_webview_controller.dart
@@ -154,6 +154,12 @@ class InAppWebViewController {
   ///{@macro flutter_inappwebview_platform_interface.PlatformInAppWebViewController.reload.supported_platforms}
   Future<void> reload() => platform.reload();
 
+  ///{@macro flutter_inappwebview_platform_interface.PlatformInAppWebViewController.setBackgroundColor}
+  ///
+  ///{@macro flutter_inappwebview_platform_interface.PlatformInAppWebViewController.setBackgroundColor.supported_platforms}
+  Future<void> setBackgroundColor(Color color) =>
+      platform.setBackgroundColor(color);
+
   ///{@macro flutter_inappwebview_platform_interface.PlatformInAppWebViewController.goBack}
   ///
   ///{@macro flutter_inappwebview_platform_interface.PlatformInAppWebViewController.goBack.supported_platforms}

diff --git a/flutter_inappwebview/lib/src/web_authentication_session/web_authenticate_session.dart b/flutter_inappwebview/lib/src/web_authentication_session/web_authenticate_session.dart
@@ -44,6 +44,12 @@ class WebAuthenticationSession {
   ///{@macro flutter_inappwebview_platform_interface.PlatformWebAuthenticationSession.callbackURLScheme.supported_platforms}
   String? get callbackURLScheme => platform.callbackURLScheme;
 
+  ///{@macro flutter_inappwebview_platform_interface.PlatformWebAuthenticationSession.additionalHeaderFields}
+  ///
+  ///{@macro flutter_inappwebview_platform_interface.PlatformWebAuthenticationSession.additionalHeaderFields.supported_platforms}
+  Map<String, String>? get additionalHeaderFields =>
+      platform.additionalHeaderFields;
+
   ///{@macro flutter_inappwebview_platform_interface.PlatformWebAuthenticationSession.initialSettings}
   ///
   ///{@macro flutter_inappwebview_platform_interface.PlatformWebAuthenticationSession.initialSettings.supported_platforms}
@@ -62,13 +68,15 @@ class WebAuthenticationSession {
   static Future<WebAuthenticationSession> create({
     required WebUri url,
     String? callbackURLScheme,
+    Map<String, String>? additionalHeaderFields,
     WebAuthenticationSessionCompletionHandler onComplete,
     WebAuthenticationSessionSettings? initialSettings,
   }) async {
     return WebAuthenticationSession.fromPlatform(
       platform: await PlatformWebAuthenticationSession.static().create(
         url: url,
         callbackURLScheme: callbackURLScheme,
+        additionalHeaderFields: additionalHeaderFields,
         onComplete: onComplete,
         initialSettings: initialSettings,
       ),

diff --git a/flutter_inappwebview_android/CHANGELOG.md b/flutter_inappwebview_android/CHANGELOG.md
@@ -1,5 +1,17 @@
 ## 1.2.0-beta.3
 
+- Added `InAppWebViewController.setBackgroundColor`, retaining the selected
+  native color across `transparentBackground` toggles.
+- Added audio capture to Android file choosers, with file-selection fallback
+  when no recorder is installed.
+- Avoided the deprecated status-bar color call when Android 15 edge-to-edge is
+  enforced, while preserving legacy target-SDK behavior.
+- Reduced Java deprecation warnings while preserving synchronous session-cookie
+  clearing [#2641](https://github.com/pichillilorenzo/flutter_inappwebview/issues/2641).
+- Fixed nullable Android context-menu action titles.
+- Restricted captured-media FileProvider access to the app-scoped `Captures`
+  directory.
+- Rejected unsafe `file://` URIs returned by Android file pickers.
 - Updated flutter_inappwebview_platform_interface version to ^1.4.0-beta.3
 - Updated native dependencies:
   - implementation from `'androidx.webkit:webkit:1.12.0'` to `'androidx.webkit:webkit:1.14.0'`

diff --git a/flutter_inappwebview_android/android/build.gradle b/flutter_inappwebview_android/android/build.gradle
@@ -58,5 +58,6 @@ android {
         implementation 'androidx.browser:browser:1.9.0'
         implementation 'androidx.appcompat:appcompat:1.7.1'
         implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.2.0'
+        testImplementation 'junit:junit:4.13.2'
     }
 }