Add an initialUrl and a javaScriptMode parameters to WebView. (#753)

Adding just these 2 parameters to set up the skeleton for webview
settings and initial parameters.

Settings (like javaScriptMode) are set and updated by rebuilding the
widget.

initialUrl is a covinience parameter for simple use cases, as the
WebView's loadUrl method cannot be modeled nicely as a widget parameter
(e.g when the widget is rebuilt with the same url value there is no nice
way to tell if you should load that url again or not).
These kind of "edge triggers" fit in the WevView's controller.
initialUrl is completely ignored when the widget is rebuilt.

Author: amirh

packages/webview_flutter/android/src/main/java/io/flutter/plugins/webviewflutter/FlutterWebView.java

@@ -10,13 +10,20 @@
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
 import io.flutter.plugin.platform.PlatformView;
+import java.util.Map;
 
 public class FlutterWebView implements PlatformView, MethodCallHandler {
   private final WebView webView;
   private final MethodChannel methodChannel;
 
-  FlutterWebView(Context context, BinaryMessenger messenger, int id) {
+  @SuppressWarnings("unchecked")
+  FlutterWebView(Context context, BinaryMessenger messenger, int id, Map<String, Object> params) {
     webView = new WebView(context);
+    if (params.containsKey("initialUrl")) {
+      String url = (String) params.get("initialUrl");
+      webView.loadUrl(url);
+    }
+    applySettings((Map<String, Object>) params.get("settings"));
     methodChannel = new MethodChannel(messenger, "plugins.flutter.io/webview_" + id);
     methodChannel.setMethodCallHandler(this);
   }
@@ -32,6 +39,9 @@ public void onMethodCall(MethodCall methodCall, Result result) {
       case "loadUrl":
         loadUrl(methodCall, result);
         break;
+      case "updateSettings":
+        updateSettings(methodCall, result);
+        break;
       default:
         result.notImplemented();
     }
@@ -43,6 +53,37 @@ private void loadUrl(MethodCall methodCall, Result result) {
     result.success(null);
   }
 
+  @SuppressWarnings("unchecked")
+  private void updateSettings(MethodCall methodCall, Result result) {
+    applySettings((Map<String, Object>) methodCall.arguments);
+    result.success(null);
+  }
+
+  private void applySettings(Map<String, Object> settings) {
+    for (String key : settings.keySet()) {
+      switch (key) {
+        case "jsMode":
+          updateJsMode((Integer) settings.get(key));
+          break;
+        default:
+          throw new IllegalArgumentException("Unknown WebView setting: " + key);
+      }
+    }
+  }
+
+  private void updateJsMode(int mode) {
+    switch (mode) {
+      case 0: // disabled
+        webView.getSettings().setJavaScriptEnabled(false);
+        break;
+      case 1: //unrestricted
+        webView.getSettings().setJavaScriptEnabled(true);
+        break;
+      default:
+        throw new IllegalArgumentException("Trying to set unknown Javascript mode: " + mode);
+    }
+  }
+
   @Override
   public void dispose() {}
 }

packages/webview_flutter/android/src/main/java/io/flutter/plugins/webviewflutter/WebViewFactory.java

@@ -5,6 +5,7 @@
 import io.flutter.plugin.common.StandardMessageCodec;
 import io.flutter.plugin.platform.PlatformView;
 import io.flutter.plugin.platform.PlatformViewFactory;
+import java.util.Map;
 
 public class WebViewFactory extends PlatformViewFactory {
   private final BinaryMessenger messenger;
@@ -14,8 +15,10 @@ public WebViewFactory(BinaryMessenger messenger) {
     this.messenger = messenger;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public PlatformView create(Context context, int id, Object args) {
-    return new FlutterWebView(context, messenger, id);
+    Map<String, Object> params = (Map<String, Object>) args;
+    return new FlutterWebView(context, messenger, id, params);
   }
 }

packages/webview_flutter/example/lib/main.dart

@@ -16,15 +16,12 @@ class WebViewExample extends StatelessWidget {
         // This drop down menu demonstrates that Flutter widgets can be shown over the web view.
         actions: <Widget>[const SampleMenu()],
       ),
-      body: WebView(
-        onWebViewCreated: _onWebViewCreated,
+      body: const WebView(
+        initialUrl: 'https://youtube.com',
+        javaScriptMode: JavaScriptMode.unrestricted,
       ),
     );
   }
-
-  void _onWebViewCreated(WebViewController controller) {
-    controller.loadUrl('https://flutter.io');
-  }
 }
 
 class SampleMenu extends StatelessWidget {

packages/webview_flutter/lib/webview_flutter.dart

@@ -11,19 +11,30 @@ import 'package:flutter/widgets.dart';
 
 typedef void WebViewCreatedCallback(WebViewController controller);
 
+enum JavaScriptMode {
+  /// JavaScript execution is disabled.
+  disabled,
+
+  /// JavaScript execution is not restricted.
+  unrestricted,
+}
+
 /// A web view widget for showing html content.
 class WebView extends StatefulWidget {
   /// Creates a new web view.
   ///
   /// The web view can be controlled using a `WebViewController` that is passed to the
   /// `onWebViewCreated` callback once the web view is created.
   ///
-  /// The `gestureRecognizers` parameter must not be null;
+  /// The `gestureRecognizers` and `javaScriptMode` parameters must not be null.
   const WebView({
     Key key,
     this.onWebViewCreated,
+    this.initialUrl,
+    this.javaScriptMode = JavaScriptMode.disabled,
     this.gestureRecognizers = const <OneSequenceGestureRecognizer>[],
   })  : assert(gestureRecognizers != null),
+        assert(javaScriptMode != null),
         super(key: key);
 
   /// If not null invoked once the web view is created.
@@ -40,11 +51,22 @@ class WebView extends StatefulWidget {
   /// were not claimed by any other gesture recognizer.
   final List<OneSequenceGestureRecognizer> gestureRecognizers;
 
+  /// The initial URL to load.
+  final String initialUrl;
+
+  /// Whether JavaScript execution is enabled.
+  final JavaScriptMode javaScriptMode;
+
   @override
   State<StatefulWidget> createState() => _WebViewState();
 }
 
 class _WebViewState extends State<WebView> {
+  final Completer<WebViewController> _controller =
+      new Completer<WebViewController>();
+
+  _WebSettings _settings;
+
   @override
   Widget build(BuildContext context) {
     if (defaultTargetPlatform == TargetPlatform.android) {
@@ -63,18 +85,93 @@ class _WebViewState extends State<WebView> {
           // we explicitly set it here so that the widget doesn't require an ambient
           // directionality.
           layoutDirection: TextDirection.rtl,
+          creationParams: _CreationParams.fromWidget(widget).toMap(),
+          creationParamsCodec: const StandardMessageCodec(),
         ),
       );
     }
     return Text(
         '$defaultTargetPlatform is not yet supported by the webview_flutter plugin');
   }
 
-  void _onPlatformViewCreated(int id) {
-    if (widget.onWebViewCreated == null) {
+  @override
+  void initState() {
+    super.initState();
+    _settings = _WebSettings.fromWidget(widget);
+  }
+
+  @override
+  void didUpdateWidget(WebView oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    final _WebSettings newSettings = _WebSettings.fromWidget(widget);
+    final Map<String, dynamic> settingsUpdate =
+        _settings.updatesMap(newSettings);
+    _updateSettings(settingsUpdate);
+    _settings = newSettings;
+  }
+
+  Future<void> _updateSettings(Map<String, dynamic> update) async {
+    if (update == null) {
       return;
     }
-    widget.onWebViewCreated(new WebViewController._(id));
+    final WebViewController controller = await _controller.future;
+    controller._updateSettings(update);
+  }
+
+  void _onPlatformViewCreated(int id) {
+    final WebViewController controller = new WebViewController._(id);
+    _controller.complete(controller);
+    if (widget.onWebViewCreated != null) {
+      widget.onWebViewCreated(controller);
+    }
+  }
+}
+
+class _CreationParams {
+  _CreationParams({this.initialUrl, this.settings});
+
+  static _CreationParams fromWidget(WebView widget) {
+    return new _CreationParams(
+      initialUrl: widget.initialUrl,
+      settings: _WebSettings.fromWidget(widget),
+    );
+  }
+
+  final String initialUrl;
+  final _WebSettings settings;
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{
+      'initialUrl': initialUrl,
+      'settings': settings.toMap(),
+    };
+  }
+}
+
+class _WebSettings {
+  _WebSettings({
+    this.javaScriptMode,
+  });
+
+  static _WebSettings fromWidget(WebView widget) {
+    return new _WebSettings(javaScriptMode: widget.javaScriptMode);
+  }
+
+  final JavaScriptMode javaScriptMode;
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{
+      'jsMode': javaScriptMode.index,
+    };
+  }
+
+  Map<String, dynamic> updatesMap(_WebSettings newSettings) {
+    if (javaScriptMode == newSettings.javaScriptMode) {
+      return null;
+    }
+    return <String, dynamic>{
+      'jsMode': newSettings.javaScriptMode.index,
+    };
   }
 }
 
@@ -98,6 +195,10 @@ class WebViewController {
     _validateUrlString(url);
     return _channel.invokeMethod('loadUrl', url);
   }
+
+  Future<void> _updateSettings(Map<String, dynamic> update) async {
+    return _channel.invokeMethod('updateSettings', update);
+  }
 }
 
 // Throws an ArgumentError if url is not a valid url string.