cronapp-cordova-plugin-ionic-webview 4.4.0-RC7

package/README.md

@@ -0,0 +1,184 @@
+<!--
+# license: Licensed to the Apache Software Foundation (ASF) under one
+#         or more contributor license agreements.  See the NOTICE file
+#         distributed with this work for additional information
+#         regarding copyright ownership.  The ASF licenses this file
+#         to you under the Apache License, Version 2.0 (the
+#         "License"); you may not use this file except in compliance
+#         with the License.  You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#         Unless required by applicable law or agreed to in writing,
+#         software distributed under the License is distributed on an
+#         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#         KIND, either express or implied.  See the License for the
+#         specific language governing permissions and limitations
+#         under the License.
+-->
+
+<!-- TODO: remove beta in README.md and CONTRIBUTING.md -->
+
+[//]: # (Updated by magellandevs: 22/05/2026)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&identifier=104773211)](https://dependabot.com)
+[![npm](https://img.shields.io/npm/v/cronapp-cordova-plugin-ionic-webview.svg)](https://www.npmjs.com/package/cronapp-cordova-plugin-ionic-webview)
+
+# Ionic Web View for Cordova
+
+A Web View plugin for Cordova, focused on providing the highest performance experience for Ionic apps (but can be used with any Cordova app).
+
+This plugin uses WKWebView on iOS and the latest evergreen webview on Android. Additionally, this plugin makes it easy to use HTML5 style routing that web developers expect for building single-page apps.
+
+Note: This repo and its documentation are for `cronapp-cordova-plugin-ionic-webview` @ `5.x`, which uses the new features that may not work with all apps. See [Requirements](#plugin-requirements) and [Migrating to 5.x](#migrating-to-5x).
+
+2.x documentation can be found [here](https://github.com/ionic-team/cronapp-cordova-plugin-ionic-webview/blob/2.x/README.md).
+
+:book: **Documentation**: [https://beta.ionicframework.com/docs/building/webview][ionic-webview-docs]
+
+:mega: **Support/Questions?** Please see our [Support Page][ionic-support] for general support questions. The issues on GitHub should be reserved for bug reports and feature requests.
+
+:sparkling_heart: **Want to contribute?** Please see [CONTRIBUTING.md](https://github.com/ionic-team/cronapp-cordova-plugin-ionic-webview/blob/master/CONTRIBUTING.md).
+
+## Configuration
+
+This plugin has several configuration options that can be set in `config.xml`.
+
+### Android and iOS Preferences
+
+Preferences available for both iOS and Android
+
+#### Hostname
+
+`<preference name="Hostname" value="app" />`
+
+Default value is `localhost`.
+
+Example `ionic://app` on iOS, `http://app` on Android.
+
+If you change it, you'll need to add a new `allow-navigation` entry in the `config.xml` for the configured url (i.e `<allow-navigation href="http://app/*"/>` if `Hostname` is set to `app`).
+This is only needed for the Android url when using `http://`, `https://` or a custom scheme. All `ionic://` urls are whitelisted by the plugin.
+
+### Android Preferences
+
+Preferences only available Android platform
+
+#### Scheme
+
+```xml
+<preference name="Scheme" value="https" />
+```
+
+Default value is `http`
+
+Configures the Scheme the app uses to load the content.
+
+#### ResolveServiceWorkerRequests
+
+```xml
+<preference name="ResolveServiceWorkerRequests" value="true" />
+```
+
+Default value is `false`
+
+Enable to resolve requests made by Service Workers through the local server.
+
+#### MixedContentMode
+
+```xml
+<preference name="MixedContentMode" value="2" />
+```
+
+Configures the WebView's behavior when an origin attempts to load a resource from a different origin.
+
+Default value is `0` (`MIXED_CONTENT_ALWAYS_ALLOW`), which allows loading resources from other origins.
+
+Other possible values are `1` (`MIXED_CONTENT_NEVER_ALLOW`) and `2` (`MIXED_CONTENT_COMPATIBILITY_MODE`)
+
+
+[Android documentation](https://developer.android.com/reference/android/webkit/WebSettings.html#setMixedContentMode(int))
+
+
+### iOS Preferences
+
+Preferences only available for iOS platform
+
+#### iosScheme
+
+```xml
+<preference name="iosScheme" value="httpsionic" />
+```
+
+Default value is `ionic`
+
+Configures the Scheme the app uses to load the content.
+
+Values like `http`, `https` or `file` are not valid and will use default value instead.
+
+If you change it, you'll need to add a new `allow-navigation` entry in the `config.xml` for the configured scheme (i.e `<allow-navigation href="httpsionic://*"/>` if `iosScheme` is set to `httpsionic`).
+
+#### WKSuspendInBackground
+
+ ```xml
+<preference name="WKSuspendInBackground" value="false" />
+```
+
+Default value is `true` (suspend).
+
+Set to false to stop WKWebView suspending in background too eagerly.
+
+#### KeyboardAppearanceDark
+
+```xml
+<preference name="KeyboardAppearanceDark" value="false" />
+```
+
+Whether to use a dark styled keyboard on iOS
+
+#### ScrollEnabled
+
+```xml
+<preference name="ScrollEnabled" value="true" />
+```
+
+Ionic apps work better if the WKWebView is not scrollable, so the scroll is disabled by default, but can be enabled with this preference. This only affects the main ScrollView of the WKWebView, so only affects the body, not other scrollable components.
+
+## Plugin Requirements
+
+* **Cordova CLI**: 7.1.0+
+* **iOS**: iOS 11+ and `cordova-ios` 4+
+* **Android**: Android 5+ and `cordova-android` 6.4+
+
+## Migrating to 5.x
+
+1. Remove and re-add the Web View plugin:
+
+    ```
+    cordova plugin rm cronapp-cordova-plugin-ionic-webview
+    cordova plugin add cronapp-cordova-plugin-ionic-webview@latest
+    ```
+
+1. If using `cordova-android` < 9, make sure you have `<preference name="android-minSdkVersion" value="21" />` in the config.xml as this version of the plugin only supports Android 5+ (SDK 21+). If using `cordova-android` >= 9 is not neccessary as `cordova-android` 9 only supports Android 5.1+ (SDK 22+)
+
+1. Since version 2, apps are served from HTTP on Android by default.
+
+    * The default origin for requests from the Android WebView is `http://localhost`. If `Hostname` and `Scheme` preferences are set, then origin will be `schemeValue://HostnameValue`.
+
+1. Since version 3, apps are served from `ionic://` scheme on iOS by default.
+
+    * The default origin for requests from the iOS WebView is `ionic://localhost`. If `Hostname` and `iosScheme` preferences are set, then origin will be `iosSchemeValue://HostnameValue`.
+
+1. The WebView is not able to display images, videos or other files from file or content protocols or if it doesn't have protocol at all. For those cases use `window.Ionic.WebView.convertFileSrc()` to get the proper url.
+
+1. Replace any usages of `window.Ionic.normalizeURL()` and `window.wkRewriteURL()` with `window.Ionic.WebView.convertFileSrc()`.
+
+    * For Ionic Angular projects, there is an [Ionic Native wrapper](https://beta.ionicframework.com/docs/native/ionic-webview):
+
+        ```
+        npm install @ionic-native/ionic-webview@latest
+        ```
+
+[ionic-homepage]: https://ionicframework.com
+[ionic-docs]: https://ionicframework.com/docs
+[ionic-webview-docs]: https://beta.ionicframework.com/docs/building/webview
+[ionic-support]: https://ionicframework.com/support

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "cronapp-cordova-plugin-ionic-webview",
+  "version": "4.4.0-RC7",
+  "description": "Ionic Web View Engine Plugin",
+  "scripts": {
+    "sync_plugin_xml": "sync-cordova-xml package.json plugin.xml --output=plugin.xml",
+    "version": "npm run sync_plugin_xml && git add plugin.xml",
+    "cz": "git-cz"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magellandevs/cronapp-cordova-plugin-ionic-webview"
+  },
+  "keywords": [
+    "cordova",
+    "wkwebview"
+  ],
+  "author": "magellandevs",
+  "license": "Apache-2.0",
+  "engines": {
+    "cordovaDependencies": {
+      "2.0.0": {
+        "cordova-android": ">=6.4.0",
+        "cordova-ios": ">=4.0.0-dev"
+      },
+      "3.1.0": {
+        "cordova-android": ">=6.4.0",
+        "cordova-ios": ">=4.0.0-dev",
+        "cordova": ">=7.1.0"
+      }
+    }
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^3.0.0",
+    "@semantic-release/exec": "^3.3.0",
+    "@semantic-release/git": "^7.0.4",
+    "@semantic-release/github": "^5.0.6",
+    "@semantic-release/npm": "^5.0.4",
+    "commitizen": "^4.0.3",
+    "cz-conventional-changelog": "^3.0.2",
+    "semantic-release": "^15.9.17",
+    "sync-cordova-xml": "^0.4.0"
+  },
+  "release": {
+    "branch": "stable",
+    "verifyConditions": [
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/git",
+      "@semantic-release/github"
+    ],
+    "prepare": [
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/exec",
+      "@semantic-release/git"
+    ],
+    "publish": [
+      "@semantic-release/github",
+      "@semantic-release/npm"
+    ],
+    "success": [
+      "@semantic-release/github"
+    ],
+    "failure": [
+      "@semantic-release/github"
+    ],
+    "prepareCmd": "npm run version"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  }
+}

package/plugin.xml

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+--><plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:rim="http://www.blackberry.com/ns/widgets" xmlns:android="http://schemas.android.com/apk/res/android" id="cronapp-cordova-plugin-ionic-webview" version="4.4.0-RC7">
+    <name>cronapp-cordova-plugin-ionic-webview</name>
+    <description>Ionic Web View Engine Plugin</description>
+    <license>Apache-2.0</license>
+    <keywords>cordova,wkwebview</keywords>
+    <repo>https://github.com/magellandevs/cronapp-cordova-plugin-ionic-webview</repo>
+
+	<engines>
+        <engine name="cordova" version="&gt;=7.1.0"/>
+        <engine name="cordova-ios" version="&gt;=4.0.0-dev"/>
+        <engine name="apple-ios" version="&gt;=11.0"/>
+        <engine name="cordova-android" version="&gt;=6.4.0"/>
+	</engines>
+
+  <js-module src="src/www/util.js" name="IonicWebView">
+      <clobbers target="Ionic.WebView"/>
+  </js-module>
+
+  <platform name="android">
+    <config-file target="config.xml" parent="/*">
+      <allow-navigation href="http://localhost/*"/>
+      <allow-navigation href="https://localhost/*"/>
+      <allow-navigation href="ionic://*"/>
+      <preference name="webView" value="com.ionicframework.cordova.webview.IonicWebViewEngine"/>
+      <feature name="IonicWebView">
+          <param name="android-package" value="com.ionicframework.cordova.webview.IonicWebView"/>
+      </feature>
+    </config-file>
+    <source-file src="src/android/com/ionicframework/cordova/webview/IonicWebViewEngine.java" target-dir="src/com/ionicframework/cordova/webview"/>
+    <source-file src="src/android/com/ionicframework/cordova/webview/IonicWebView.java" target-dir="src/com/ionicframework/cordova/webview"/>
+    <source-file src="src/android/com/ionicframework/cordova/webview/AndroidProtocolHandler.java" target-dir="src/com/ionicframework/cordova/webview"/>
+    <source-file src="src/android/com/ionicframework/cordova/webview/UriMatcher.java" target-dir="src/com/ionicframework/cordova/webview"/>
+    <source-file src="src/android/com/ionicframework/cordova/webview/WebViewLocalServer.java" target-dir="src/com/ionicframework/cordova/webview"/>
+  </platform>
+
+  <!-- ios -->
+  <platform name="ios">
+    <js-module src="src/www/ios/ios-wkwebview-exec.js" name="ios-wkwebview-exec">
+      <clobbers target="cordova.exec"/>
+    </js-module>
+
+    <config-file target="config.xml" parent="/*">
+        <allow-navigation href="ionic://*"/>
+        <feature name="IonicWebView">
+            <param name="ios-package" value="CDVWKWebViewEngine"/>
+        </feature>
+        <preference name="CordovaWebViewEngine" value="CDVWKWebViewEngine"/>
+    </config-file>
+
+    <framework src="WebKit.framework" weak="true"/>
+
+    <header-file src="src/ios/CDVWKWebViewEngine.h"/>
+    <source-file src="src/ios/CDVWKWebViewEngine.m"/>
+    <header-file src="src/ios/CDVWKWebViewUIDelegate.h"/>
+    <source-file src="src/ios/CDVWKWebViewUIDelegate.m"/>
+    <header-file src="src/ios/CDVWKProcessPoolFactory.h"/>
+    <source-file src="src/ios/CDVWKProcessPoolFactory.m"/>
+    <header-file src="src/ios/IONAssetHandler.h"/>
+    <source-file src="src/ios/IONAssetHandler.m"/>
+    <asset src="src/ios/wk-plugin.js" target="wk-plugin.js"/>
+  </platform>
+</plugin>

package/src/android/com/ionicframework/cordova/webview/AndroidProtocolHandler.java

@@ -0,0 +1,107 @@
+package com.ionicframework.cordova.webview;
+
+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.net.Uri;
+import android.util.Log;
+import android.util.TypedValue;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+
+public class AndroidProtocolHandler {
+  private static final String TAG = "AndroidProtocolHandler";
+
+  private Context context;
+
+  public AndroidProtocolHandler(Context context) {
+    this.context = context;
+  }
+
+  public InputStream openAsset(String path) throws IOException {
+    return context.getAssets().open(path, AssetManager.ACCESS_STREAMING);
+  }
+
+  public InputStream openResource(Uri uri) {
+    assert uri.getPath() != null;
+    // The path must be of the form ".../asset_type/asset_name.ext".
+    List<String> pathSegments = uri.getPathSegments();
+    String assetType = pathSegments.get(pathSegments.size() - 2);
+    String assetName = pathSegments.get(pathSegments.size() - 1);
+
+    // Drop the file extension.
+    assetName = assetName.split("\\.")[0];
+    try {
+      // Use the application context for resolving the resource package name so that we do
+      // not use the browser's own resources. Note that if 'context' here belongs to the
+      // test suite, it does not have a separate application context. In that case we use
+      // the original context object directly.
+      if (context.getApplicationContext() != null) {
+        context = context.getApplicationContext();
+      }
+      int fieldId = getFieldId(context, assetType, assetName);
+      int valueType = getValueType(context, fieldId);
+      if (valueType == TypedValue.TYPE_STRING) {
+        return context.getResources().openRawResource(fieldId);
+      } else {
+        Log.e(TAG, "Asset not of type string: " + uri);
+        return null;
+      }
+    } catch (ClassNotFoundException e) {
+      Log.e(TAG, "Unable to open resource URL: " + uri, e);
+      return null;
+    } catch (NoSuchFieldException e) {
+      Log.e(TAG, "Unable to open resource URL: " + uri, e);
+      return null;
+    } catch (IllegalAccessException e) {
+      Log.e(TAG, "Unable to open resource URL: " + uri, e);
+      return null;
+    }
+  }
+
+  public InputStream openFile(String filePath) throws IOException  {
+    String realPath = filePath.replace(WebViewLocalServer.fileStart, "");
+    File localFile = new File(realPath);
+    return new FileInputStream(localFile);
+  }
+
+  public InputStream openContentUrl(Uri uri)  throws IOException {
+    Integer port = uri.getPort();
+    String realPath;
+    if (port == -1) {
+      realPath = uri.toString().replace(uri.getScheme() + "://" + uri.getHost() + WebViewLocalServer.contentStart, "content:/");
+    } else {
+      realPath = uri.toString().replace(uri.getScheme() + "://" + uri.getHost() + ":" + port + WebViewLocalServer.contentStart, "content:/");
+    }
+    InputStream stream = null;
+    try {
+      stream = context.getContentResolver().openInputStream(Uri.parse(realPath));
+    } catch (SecurityException e) {
+      Log.e(TAG, "Unable to open content URL: " + uri, e);
+    }
+    return stream;
+  }
+
+  private static int getFieldId(Context context, String assetType, String assetName)
+    throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
+    Class<?> d = context.getClassLoader()
+      .loadClass(context.getPackageName() + ".R$" + assetType);
+    java.lang.reflect.Field field = d.getField(assetName);
+    int id = field.getInt(null);
+    return id;
+  }
+
+  private static int getValueType(Context context, int fieldId) {
+    TypedValue value = new TypedValue();
+    context.getResources().getValue(fieldId, value, true);
+    return value.type;
+  }
+}

package/src/android/com/ionicframework/cordova/webview/IonicWebView.java

@@ -0,0 +1,41 @@
+package com.ionicframework.cordova.webview;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+public class IonicWebView extends CordovaPlugin  {
+
+  public static final String WEBVIEW_PREFS_NAME = "WebViewSettings";
+  public static final String CDV_SERVER_PATH = "serverBasePath";
+
+  public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+  
+    if (action.equals("setServerBasePath")) {
+      final String path = args.getString(0);
+      cordova.getActivity().runOnUiThread(new Runnable() {
+        public void run() {
+          ((IonicWebViewEngine)webView.getEngine()).setServerBasePath(path);
+        }
+      });
+      return true;
+    } else if (action.equals("getServerBasePath")) {
+      callbackContext.success(((IonicWebViewEngine)webView.getEngine()).getServerBasePath());
+      return true;
+    } else if (action.equals("persistServerBasePath")) {
+      String path = ((IonicWebViewEngine)webView.getEngine()).getServerBasePath();
+      SharedPreferences prefs = cordova.getActivity().getApplicationContext().getSharedPreferences(WEBVIEW_PREFS_NAME, Activity.MODE_PRIVATE);
+      SharedPreferences.Editor editor = prefs.edit();
+      editor.putString(CDV_SERVER_PATH, path);
+      editor.apply();
+      return true;
+    }
+    return false;
+  }
+
+}
+

package/src/android/com/ionicframework/cordova/webview/IonicWebViewEngine.java

@@ -0,0 +1,172 @@
+package com.ionicframework.cordova.webview;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+import android.webkit.ServiceWorkerController;
+import android.webkit.ServiceWorkerClient;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import org.apache.cordova.ConfigXmlParser;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPreferences;
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.CordovaWebViewEngine;
+import org.apache.cordova.NativeToJsMessageQueue;
+import org.apache.cordova.PluginManager;
+import org.apache.cordova.engine.SystemWebViewClient;
+import org.apache.cordova.engine.SystemWebViewEngine;
+import org.apache.cordova.engine.SystemWebView;
+
+public class IonicWebViewEngine extends SystemWebViewEngine {
+  public static final String TAG = "IonicWebViewEngine";
+
+  private WebViewLocalServer localServer;
+  private String CDV_LOCAL_SERVER;
+  private String scheme;
+  private static final String LAST_BINARY_VERSION_CODE = "lastBinaryVersionCode";
+  private static final String LAST_BINARY_VERSION_NAME = "lastBinaryVersionName";
+
+  /**
+   * Used when created via reflection.
+   */
+  public IonicWebViewEngine(Context context, CordovaPreferences preferences) {
+    super(new SystemWebView(context), preferences);
+    Log.d(TAG, "Ionic Web View Engine Starting Right Up 1...");
+  }
+
+  public IonicWebViewEngine(SystemWebView webView) {
+    super(webView, null);
+    Log.d(TAG, "Ionic Web View Engine Starting Right Up 2...");
+  }
+
+  public IonicWebViewEngine(SystemWebView webView, CordovaPreferences preferences) {
+    super(webView, preferences);
+    Log.d(TAG, "Ionic Web View Engine Starting Right Up 3...");
+  }
+
+  @Override
+  public void init(CordovaWebView parentWebView, CordovaInterface cordova, final CordovaWebViewEngine.Client client,
+                   CordovaResourceApi resourceApi, PluginManager pluginManager,
+                   NativeToJsMessageQueue nativeToJsMessageQueue) {
+    ConfigXmlParser parser = new ConfigXmlParser();
+    parser.parse(cordova.getActivity());
+
+    String hostname = preferences.getString("Hostname", "localhost");
+    scheme = preferences.getString("Scheme", "http");
+    CDV_LOCAL_SERVER = scheme + "://" + hostname;
+
+    localServer = new WebViewLocalServer(cordova.getActivity(), hostname, true, parser, scheme);
+    localServer.hostAssets("www");
+
+    webView.setWebViewClient(new ServerClient(this, parser));
+
+    super.init(parentWebView, cordova, client, resourceApi, pluginManager, nativeToJsMessageQueue);
+    if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+      final WebSettings settings = webView.getSettings();
+      int mode = preferences.getInteger("MixedContentMode", 0);
+      settings.setMixedContentMode(mode);
+    }
+    SharedPreferences prefs = cordova.getActivity().getApplicationContext().getSharedPreferences(IonicWebView.WEBVIEW_PREFS_NAME, Activity.MODE_PRIVATE);
+    String path = prefs.getString(IonicWebView.CDV_SERVER_PATH, null);
+    if (!isDeployDisabled() && !isNewBinary() && path != null && !path.isEmpty()) {
+      setServerBasePath(path);
+    }
+
+    boolean setAsServiceWorkerClient = preferences.getBoolean("ResolveServiceWorkerRequests", false);
+    ServiceWorkerController controller = null;
+
+    if (setAsServiceWorkerClient && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
+        controller = ServiceWorkerController.getInstance();
+        controller.setServiceWorkerClient(new ServiceWorkerClient(){
+            @Override
+            public WebResourceResponse shouldInterceptRequest(WebResourceRequest request) {
+                return localServer.shouldInterceptRequest(request.getUrl(), request);
+            }
+        });
+    }
+  }
+
+  private boolean isNewBinary() {
+    String versionCode = "";
+    String versionName = "";
+    SharedPreferences prefs = cordova.getActivity().getApplicationContext().getSharedPreferences(IonicWebView.WEBVIEW_PREFS_NAME, Activity.MODE_PRIVATE);
+    String lastVersionCode = prefs.getString(LAST_BINARY_VERSION_CODE, null);
+    String lastVersionName = prefs.getString(LAST_BINARY_VERSION_NAME, null);
+
+    try {
+      PackageInfo pInfo = this.cordova.getActivity().getPackageManager().getPackageInfo(this.cordova.getActivity().getPackageName(), 0);
+      versionCode = Integer.toString(pInfo.versionCode);
+      versionName = pInfo.versionName;
+    } catch(Exception ex) {
+      Log.e(TAG, "Unable to get package info", ex);
+    }
+
+    if (!versionCode.equals(lastVersionCode) || !versionName.equals(lastVersionName)) {
+      SharedPreferences.Editor editor = prefs.edit();
+      editor.putString(LAST_BINARY_VERSION_CODE, versionCode);
+      editor.putString(LAST_BINARY_VERSION_NAME, versionName);
+      editor.putString(IonicWebView.CDV_SERVER_PATH, "");
+      editor.apply();
+      return true;
+    }
+    return false;
+  }
+
+  private boolean isDeployDisabled() {
+    return preferences.getBoolean("DisableDeploy", false);
+  }
+  private class ServerClient extends SystemWebViewClient {
+    private ConfigXmlParser parser;
+
+    public ServerClient(SystemWebViewEngine parentEngine, ConfigXmlParser parser) {
+      super(parentEngine);
+      this.parser = parser;
+    }
+
+    @Override
+    public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
+      return localServer.shouldInterceptRequest(request.getUrl(), request);
+    }
+
+    @Override
+    public void onPageStarted(WebView view, String url, Bitmap favicon) {
+      super.onPageStarted(view, url, favicon);
+      String launchUrl = parser.getLaunchUrl();
+      if (!launchUrl.contains(WebViewLocalServer.httpsScheme) && !launchUrl.contains(WebViewLocalServer.httpScheme) && url.equals(launchUrl)) {
+        view.stopLoading();
+        // When using a custom scheme the app won't load if server start url doesn't end in /
+        String startUrl = CDV_LOCAL_SERVER;
+        if (!scheme.equalsIgnoreCase(WebViewLocalServer.httpsScheme) && !scheme.equalsIgnoreCase(WebViewLocalServer.httpScheme)) {
+          startUrl += "/";
+        }
+        view.loadUrl(startUrl);
+      }
+    }
+
+    @Override
+    public void onPageFinished(WebView view, String url) {
+      super.onPageFinished(view, url);
+      view.loadUrl("javascript:(function() { " +
+              "window.WEBVIEW_SERVER_URL = '" + CDV_LOCAL_SERVER + "';" +
+              "})()");
+    }
+  }
+
+  public void setServerBasePath(String path) {
+    localServer.hostFiles(path);
+    webView.loadUrl(CDV_LOCAL_SERVER);
+  }
+
+  public String getServerBasePath() {
+    return this.localServer.getBasePath();
+  }
+}