Resolved PR comments

Author: agavrilko

packages/webview_flutter/webview_flutter/CHANGELOG.md

@@ -1,6 +1,5 @@
 ## 4.14.0
 
-* Deprecates `WebViewController.loadFile(String)` in favor of `WebViewController.loadFileWithParams(LoadFileParams)`.
 * Introduces `AndroidLoadFileParams` and `WebKitLoadFileParams` to support platform-specific parameters when loading local HTML files on Android and iOS/macOS.
 
 ## 4.13.0

packages/webview_flutter/webview_flutter/lib/src/webview_controller.dart

@@ -131,25 +131,10 @@ class WebViewController {
   /// `/Users/username/Documents/www/index.html`.
   ///
   /// Throws a `PlatformException` if the [absoluteFilePath] does not exist.
-  @Deprecated('Use loadFileWithParams(LocalFileParams params) instead. '
-      'This method will be removed in a future release.')
   Future<void> loadFile(String absoluteFilePath) {
     return platform.loadFile(absoluteFilePath);
   }
 
-  /// Loads a local HTML file using the provided [params].
-  ///
-  /// The [params] object should contain the absolute path to the
-  /// file as it is stored on the device. For example:
-  /// `/Users/username/Documents/www/index.html`.
-  /// In addition, it may include platform-specific fields,
-  /// such as headers (on Android) or resource paths (on iOS/macOS).
-  ///
-  /// Throws a `PlatformException` if the [absoluteFilePath] does not exist.
-  Future<void> loadFileWithParams(LoadFileParams params) {
-    return platform.loadFileWithParams(params);
-  }
-
   /// Loads the Flutter asset specified in the pubspec.yaml file.
   ///
   /// Throws a `PlatformException` if [key] is not part of the specified assets

packages/webview_flutter/webview_flutter/test/webview_controller_test.dart

@@ -27,22 +27,6 @@ void main() {
     verify(mockPlatformWebViewController.loadFile('file/path'));
   });
 
-  test('loadFileWithParams', () async {
-    final MockPlatformWebViewController mockPlatformWebViewController =
-        MockPlatformWebViewController();
-
-    final WebViewController webViewController = WebViewController.fromPlatform(
-      mockPlatformWebViewController,
-    );
-
-    await webViewController.loadFileWithParams(
-      const LoadFileParams(absoluteFilePath: 'file/path'),
-    );
-    verify(mockPlatformWebViewController.loadFileWithParams(
-      const LoadFileParams(absoluteFilePath: 'file/path'),
-    ));
-  });
-
   test('loadFlutterAsset', () async {
     final MockPlatformWebViewController mockPlatformWebViewController =
         MockPlatformWebViewController();

packages/webview_flutter/webview_flutter/test/webview_controller_test.mocks.dart

@@ -78,14 +78,6 @@ class MockPlatformWebViewController extends _i1.Mock
         returnValueForMissingStub: _i5.Future<void>.value(),
       ) as _i5.Future<void>);
 
-  @override
-  _i5.Future<void> loadFileWithParams(_i2.LoadFileParams? params) =>
-      (super.noSuchMethod(
-        Invocation.method(#loadFileWithParams, [params]),
-        returnValue: _i5.Future<void>.value(),
-        returnValueForMissingStub: _i5.Future<void>.value(),
-      ) as _i5.Future<void>);
-
   @override
   _i5.Future<void> loadFlutterAsset(String? key) => (super.noSuchMethod(
         Invocation.method(#loadFlutterAsset, [key]),

packages/webview_flutter/webview_flutter/test/webview_widget_test.mocks.dart

@@ -91,14 +91,6 @@ class MockPlatformWebViewController extends _i1.Mock
         returnValueForMissingStub: _i7.Future<void>.value(),
       ) as _i7.Future<void>);
 
-  @override
-  _i7.Future<void> loadFileWithParams(_i2.LoadFileParams? params) =>
-      (super.noSuchMethod(
-        Invocation.method(#loadFileWithParams, [params]),
-        returnValue: _i7.Future<void>.value(),
-        returnValueForMissingStub: _i7.Future<void>.value(),
-      ) as _i7.Future<void>);
-
   @override
   _i7.Future<void> loadFlutterAsset(String? key) => (super.noSuchMethod(
         Invocation.method(#loadFlutterAsset, [key]),

packages/webview_flutter/webview_flutter_android/CHANGELOG.md

@@ -1,5 +1,6 @@
 ## 4.8.0
 
+* Adds support for `PlatformWebViewController.loadFileWithParams`.
 * Introduces `AndroidLoadFileParams`, a platform-specific extension of `LoadFileParams` for Android that adds support for `headers`.
 
 ## 4.7.0

packages/webview_flutter/webview_flutter_android/lib/src/android_webview_controller.dart

@@ -23,12 +23,9 @@ import 'weak_reference_utils.dart';
 @immutable
 class AndroidLoadFileParams extends LoadFileParams {
   /// Constructs a [AndroidLoadFileParams], the subclass of a [LoadFileParams].
-  ///
-  /// Optionally, [headers] map may be included, which contains key-value pairs
-  /// that will be passed as additional HTTP headers when loading the file.
   AndroidLoadFileParams({
     required String absoluteFilePath,
-    this.headers = _defaultHeaders,
+    this.headers = const <String, String>{},
   }) : super(
           absoluteFilePath: absoluteFilePath.startsWith('file://')
               ? absoluteFilePath
@@ -38,22 +35,18 @@ class AndroidLoadFileParams extends LoadFileParams {
   /// Constructs a [AndroidLoadFileParams] using a [LoadFileParams].
   factory AndroidLoadFileParams.fromLoadFileParams(
     LoadFileParams params, {
-    Map<String, String> headers = _defaultHeaders,
+    Map<String, String> headers = const <String, String>{},
   }) {
     return AndroidLoadFileParams(
       absoluteFilePath: params.absoluteFilePath,
       headers: headers,
     );
   }
 
-  /// Default empty headers used when no custom headers are provided.
-  ///
-  /// This constant ensures that the [headers] parameter is never `null`,
-  /// simplifying internal logic and avoiding the need for null checks.
-  static const Map<String, String> _defaultHeaders = <String, String>{};
-
   /// Additional HTTP headers to be included when loading the local file.
   ///
+  /// If not provided at initialization time, doesn't add any addition headers.
+  ///
   /// On Android, WebView supports adding headers when loading local or remote
   /// content. This can be useful for scenarios like authentication,
   /// content-type overrides, or custom request context.
@@ -425,18 +418,31 @@ class AndroidWebViewController extends PlatformWebViewController {
       _webView.pigeon_instanceManager.getIdentifier(_webView)!;
 
   @override
-  Future<void> loadFileWithParams(LoadFileParams params) {
+  Future<void> loadFile(
+    String absoluteFilePath,
+  ) {
+    return loadFileWithParams(
+      AndroidLoadFileParams(
+        absoluteFilePath: absoluteFilePath,
+      ),
+    );
+  }
+
+  @override
+  Future<void> loadFileWithParams(
+    LoadFileParams params,
+  ) async {
     switch (params) {
       case final AndroidLoadFileParams params:
-        _webView.settings.setAllowFileAccess(true);
-        return _webView.loadUrl(
-          params.absoluteFilePath,
-          params.headers,
-        );
+        await Future.wait(<Future<void>>[
+          _webView.settings.setAllowFileAccess(true),
+          _webView.loadUrl(params.absoluteFilePath, params.headers),
+        ]);
 
       default:
-        return loadFileWithParams(
-            AndroidLoadFileParams.fromLoadFileParams(params));
+        await loadFileWithParams(
+          AndroidLoadFileParams.fromLoadFileParams(params),
+        );
     }
   }
 

packages/webview_flutter/webview_flutter_android/test/android_webview_controller_test.dart

@@ -292,6 +292,60 @@ void main() {
       verify(mockWebSettings.setUseWideViewPort(false)).called(1);
     });
 
+    group('loadFile', () {
+      test('Without file prefix', () async {
+        final MockWebView mockWebView = MockWebView();
+        final MockWebSettings mockWebSettings = MockWebSettings();
+        final AndroidWebViewController controller = createControllerWithMocks(
+          mockWebView: mockWebView,
+          mockSettings: mockWebSettings,
+        );
+
+        await controller.loadFile('/path/to/file.html');
+
+        verify(mockWebSettings.setAllowFileAccess(true)).called(1);
+        verify(mockWebView.loadUrl(
+          'file:///path/to/file.html',
+          <String, String>{},
+        )).called(1);
+      });
+
+      test('Without file prefix and characters to be escaped', () async {
+        final MockWebView mockWebView = MockWebView();
+        final MockWebSettings mockWebSettings = MockWebSettings();
+        final AndroidWebViewController controller = createControllerWithMocks(
+          mockWebView: mockWebView,
+          mockSettings: mockWebSettings,
+        );
+
+        await controller.loadFile('/path/to/?_<_>_.html');
+
+        verify(mockWebSettings.setAllowFileAccess(true)).called(1);
+        verify(mockWebView.loadUrl(
+          'file:///path/to/%3F_%3C_%3E_.html',
+          <String, String>{},
+        )).called(1);
+      });
+
+      test('With file prefix', () async {
+        final MockWebView mockWebView = MockWebView();
+        final MockWebSettings mockWebSettings = MockWebSettings();
+        final AndroidWebViewController controller = createControllerWithMocks(
+          mockWebView: mockWebView,
+        );
+
+        when(mockWebView.settings).thenReturn(mockWebSettings);
+
+        await controller.loadFile('file:///path/to/file.html');
+
+        verify(mockWebSettings.setAllowFileAccess(true)).called(1);
+        verify(mockWebView.loadUrl(
+          'file:///path/to/file.html',
+          <String, String>{},
+        )).called(1);
+      });
+    });
+
     group('loadFileWithParams', () {
       group('Using LoadFileParams model', () {
         test('Without file prefix', () async {

packages/webview_flutter/webview_flutter_platform_interface/CHANGELOG.md

@@ -1,8 +1,6 @@
 ## 2.14.0
 
-* Updates minimum supported SDK version to Flutter 3.27/Dart 3.6.
 * Adds `PlatformWebViewController.loadFileWithParams(LoadFileParams)` to support loading local HTML files with platform-specific parameters.
-* Deprecates `PlatformWebViewController.loadFile(String)` in favour of `PlatformWebViewController.loadFileWithParams(LoadFileParams)`.
 
 ## 2.13.1
 

packages/webview_flutter/webview_flutter_platform_interface/lib/src/platform_webview_controller.dart

@@ -54,13 +54,11 @@ abstract class PlatformWebViewController extends PlatformInterface {
   /// `/Users/username/Documents/www/index.html`.
   ///
   /// Throws an ArgumentError if the [absoluteFilePath] does not exist.
-  @Deprecated('Use loadFileWithParams(LocalFileParams params) instead. '
-      'This method will be removed in a future release.')
   Future<void> loadFile(
     String absoluteFilePath,
   ) {
-    return loadFileWithParams(
-        LoadFileParams(absoluteFilePath: absoluteFilePath));
+    throw UnimplementedError(
+        'loadFile is not implemented on the current platform');
   }
 
   /// Loads a local HTML file using the provided [params].
@@ -71,9 +69,6 @@ abstract class PlatformWebViewController extends PlatformInterface {
   ///
   /// Platform-specific implementations may extend [LocalFileParams] to support
   /// additional parameters, such as iOS/macOS-specific read access options.
-  ///
-  /// Throws an [ArgumentError] if the file specified in
-  /// [params.absoluteFilePath] does not exist.
   Future<void> loadFileWithParams(
     LoadFileParams params,
   ) {

packages/webview_flutter/webview_flutter_platform_interface/lib/src/types/load_file_params.dart

@@ -9,25 +9,23 @@ import 'package:flutter/material.dart';
 /// Platform-specific implementations can add additional fields by extending
 /// this class.
 ///
-/// {@tool sample}
-/// This example demonstrates how to extend [LocalFileParams] to provide
+/// This example demonstrates how to extend [LoadFileParams] to provide
 /// additional platform-specific parameters.
 ///
-/// When extending [LocalFileParams], additional parameters should always accept
+/// When extending [LoadFileParams], additional parameters should always accept
 /// `null` or have a default value to prevent breaking changes.
 ///
 /// ```dart
 /// class WebKitLoadFileParams extends LoadFileParams {
 ///   const WebKitLoadFileParams({
 ///     required super.absoluteFilePath,
-///     required String readAccessPath,
+///     required this.readAccessPath,
 ///   });
 ///
 ///   /// The directory to which the WebView is granted read access.
 ///   final String readAccessPath;
 /// }
 /// ```
-/// {@end-tool}
 @immutable
 class LoadFileParams {
   /// Used by the platform implementation to load local HTML page.

packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md

@@ -1,6 +1,7 @@
 ## 3.23.0
 
 * Updates minimum supported SDK version to Flutter 3.27/Dart 3.6.
+* Adds support for `PlatformWebViewController.loadFileWithParams`.
 * Introduces `WebKitLoadFileParams`, a platform-specific extension of `LoadFileParams` for iOS and macOS that adds support for `readAccessPath`.
 
 ## 3.22.0
@@ -26,7 +27,7 @@
 ## 3.18.6
 
 * Fixes `PlatformException` when calling `loadFlutterAsset` on macOS.
-* Updates native wrapper with methods handling `SecTust` and `SecCertificate`.
+* Updates native wrapper with methods handling `SecTust` and `SecCertificate`. 
 
 ## 3.18.5
 

packages/webview_flutter/webview_flutter_wkwebview/lib/src/webkit_webview_controller.dart

@@ -43,10 +43,6 @@ enum PlaybackMediaTypes {
 @immutable
 class WebKitLoadFileParams extends LoadFileParams {
   /// Constructs a [WebKitLoadFileParams], the subclass of a [LoadFileParams].
-  ///
-  /// The optional [readAccessPath] defines the directory that the WebView is
-  /// allowed to read from. If not provided, it defaults to the parent directory
-  /// of [absoluteFilePath].
   WebKitLoadFileParams({
     required super.absoluteFilePath,
     String? readAccessPath,
@@ -66,6 +62,9 @@ class WebKitLoadFileParams extends LoadFileParams {
 
   /// The directory to which the WebView is granted read access.
   ///
+  /// If not provided at initialization time, it defaults to
+  /// the parent directory of [absoluteFilePath].
+  ///
   /// On iOS/macOS, this is required by WebKit to define the scope of readable
   /// files when loading a local HTML file. It must include the location of
   /// any resources (e.g., images, scripts) referenced by the HTML.
@@ -438,7 +437,16 @@ class WebKitWebViewController extends PlatformWebViewController {
   }
 
   @override
-  Future<void> loadFileWithParams(LoadFileParams params) {
+  Future<void> loadFile(String absoluteFilePath) {
+    return loadFileWithParams(
+      WebKitLoadFileParams(absoluteFilePath: absoluteFilePath),
+    );
+  }
+
+  @override
+  Future<void> loadFileWithParams(
+      LoadFileParams params,
+  ) {
     switch (params) {
       case final WebKitLoadFileParams params:
         return _webView.loadFileUrl(
@@ -448,7 +456,8 @@ class WebKitWebViewController extends PlatformWebViewController {
 
       default:
         return loadFileWithParams(
-            WebKitLoadFileParams.fromLoadFileParams(params));
+          WebKitLoadFileParams.fromLoadFileParams(params),
+        );
     }
   }
 

packages/webview_flutter/webview_flutter_wkwebview/test/webkit_webview_controller_test.dart

@@ -330,6 +330,17 @@ void main() {
       });
     });
 
+    test('loadFile', () async {
+      final MockUIViewWKWebView mockWebView = MockUIViewWKWebView();
+
+      final WebKitWebViewController controller = createControllerWithMocks(
+        createMockWebView: (_, {dynamic observeValue}) => mockWebView,
+      );
+
+      await controller.loadFile('/path/to/file.html');
+      verify(mockWebView.loadFileUrl('/path/to/file.html', '/path/to'));
+    });
+
     group('loadFileWithParams', () {
       test('Using LoadFileParams model', () async {
         final MockUIViewWKWebView mockWebView = MockUIViewWKWebView();