react-native-webview-bootpay 11.26.20 → 13.6.0

package/android/src/main/java/kr/co/bootpay/webview/BPCWebView.java

@@ -1,42 +1,65 @@
 package kr.co.bootpay.webview;
 
+import androidx.annotation.Nullable;
+
 import android.annotation.SuppressLint;
 import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Rect;
 import android.os.Build;
 import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.Log;
+
+import android.view.ActionMode;
+import android.view.Menu;
+import android.view.MenuItem;
 import android.view.MotionEvent;
+import android.view.View;
 import android.webkit.JavascriptInterface;
+import android.webkit.ValueCallback;
 import android.webkit.WebChromeClient;
 import android.webkit.WebView;
 import android.webkit.WebViewClient;
 
-import androidx.annotation.Nullable;
-
+import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.CatalystInstance;
 import com.facebook.react.bridge.LifecycleEventListener;
-import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.events.ContentSizeChangeEvent;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.facebook.react.views.scroll.OnScrollDispatchHelper;
 import com.facebook.react.views.scroll.ScrollEvent;
 import com.facebook.react.views.scroll.ScrollEventType;
+import kr.co.bootpay.webview.events.TopCustomMenuSelectionEvent;
+import kr.co.bootpay.webview.events.TopLoadingProgressEvent;
+import kr.co.bootpay.webview.events.TopMessageEvent;
+
+import org.json.JSONException;
+import org.json.JSONObject;
 
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
+import java.util.List;
+import java.util.Map;
+
+public class BPCWebView extends WebView implements LifecycleEventListener {
+    protected @Nullable
+    String injectedJS;
+    protected @Nullable
+    String injectedJSBeforeContentLoaded;
+    protected @Nullable
+    BPCWebViewBridge bridge;
 
-import kr.co.bootpay.webview.events.TopMessageEvent;
-/**
- * Subclass of {@link WebView} that implements {@link LifecycleEventListener} interface in order
- * to call {@link WebView#destroy} on activity destroy event and also to clear the client
- */
-class BPCWebView extends WebView implements LifecycleEventListener {
 
   /** bootpay added start ***/
   protected static final String JAVASCRIPT_INTERFACE = "BootpayRNWebView";
@@ -51,321 +74,389 @@ class BPCWebView extends WebView implements LifecycleEventListener {
   }
   /** bootpay added end ***/
 
-  protected @Nullable
-  String injectedJS;
-  protected @Nullable
-  String injectedJSBeforeContentLoaded;
-
-  /**
-   * android.webkit.WebChromeClient fundamentally does not support JS injection into frames other
-   * than the main frame, so these two properties are mostly here just for parity with iOS & macOS.
-   */
-  protected boolean injectedJavaScriptForMainFrameOnly = true;
-  protected boolean injectedJavaScriptBeforeContentLoadedForMainFrameOnly = true;
-
-  protected boolean messagingEnabled = false;
-  protected @Nullable
-  String messagingModuleName;
-  protected @Nullable
-  BPCWebViewClient mBPCWebViewClient;
-  protected @Nullable
-  CatalystInstance mCatalystInstance;
-  protected boolean sendContentSizeChangeEvents = false;
-  private OnScrollDispatchHelper mOnScrollDispatchHelper;
-  protected boolean hasScrollEvent = false;
-  protected boolean nestedScrollEnabled = false;
-  protected ProgressChangedFilter progressChangedFilter;
-
-  /**
-   * WebView must be created with an context of the current activity
-   * <p>
-   * Activity Context is required for creation of dialogs internally by WebView
-   * Reactive Native needed for access to ReactNative internal system functionality
-   */
-  public BPCWebView(ThemedReactContext reactContext) {
-    super(reactContext);
-    this.createCatalystInstance();
-    progressChangedFilter = new ProgressChangedFilter();
-  }
-
-  public void setIgnoreErrFailedForThisURL(String url) {
-    mBPCWebViewClient.setIgnoreErrFailedForThisURL(url);
-  }
-
-  public void setBasicAuthCredential(BasicAuthCredential credential) {
-    mBPCWebViewClient.setBasicAuthCredential(credential);
-  }
+    /**
+     * android.webkit.WebChromeClient fundamentally does not support JS injection into frames other
+     * than the main frame, so these two properties are mostly here just for parity with iOS & macOS.
+     */
+    protected boolean injectedJavaScriptForMainFrameOnly = true;
+    protected boolean injectedJavaScriptBeforeContentLoadedForMainFrameOnly = true;
+
+    protected boolean messagingEnabled = false;
+    protected @Nullable
+    String messagingModuleName;
+    protected @Nullable
+    BPCWebViewClient mBPCWebViewClient;
+    protected @Nullable
+    CatalystInstance mCatalystInstance;
+    protected boolean sendContentSizeChangeEvents = false;
+    private OnScrollDispatchHelper mOnScrollDispatchHelper;
+    protected boolean hasScrollEvent = false;
+    protected boolean nestedScrollEnabled = false;
+    protected ProgressChangedFilter progressChangedFilter;
 
-  public void setSendContentSizeChangeEvents(boolean sendContentSizeChangeEvents) {
-    this.sendContentSizeChangeEvents = sendContentSizeChangeEvents;
-  }
+    /**
+     * WebView must be created with an context of the current activity
+     * <p>
+     * Activity Context is required for creation of dialogs internally by WebView
+     * Reactive Native needed for access to ReactNative internal system functionality
+     */
+    public BPCWebView(ThemedReactContext reactContext) {
+        super(reactContext);
+        this.createCatalystInstance();
+        progressChangedFilter = new ProgressChangedFilter();
+    }
 
-  public void setHasScrollEvent(boolean hasScrollEvent) {
-    this.hasScrollEvent = hasScrollEvent;
-  }
+    public void setIgnoreErrFailedForThisURL(String url) {
+        mBPCWebViewClient.setIgnoreErrFailedForThisURL(url);
+    }
 
-  public void setNestedScrollEnabled(boolean nestedScrollEnabled) {
-    this.nestedScrollEnabled = nestedScrollEnabled;
-  }
+    public void setBasicAuthCredential(BPCBasicAuthCredential credential) {
+        mBPCWebViewClient.setBasicAuthCredential(credential);
+    }
 
-  @Override
-  public void onHostResume() {
-    // do nothing
-  }
+    public void setSendContentSizeChangeEvents(boolean sendContentSizeChangeEvents) {
+        this.sendContentSizeChangeEvents = sendContentSizeChangeEvents;
+    }
 
-  @Override
-  public void onHostPause() {
-    // do nothing
-  }
+    public void setHasScrollEvent(boolean hasScrollEvent) {
+        this.hasScrollEvent = hasScrollEvent;
+    }
 
-  @Override
-  public void onHostDestroy() {
-    cleanupCallbacksAndDestroy();
-  }
+    public void setNestedScrollEnabled(boolean nestedScrollEnabled) {
+        this.nestedScrollEnabled = nestedScrollEnabled;
+    }
 
-  @Override
-  public boolean onTouchEvent(MotionEvent event) {
-    if (this.nestedScrollEnabled) {
-      requestDisallowInterceptTouchEvent(true);
+    @Override
+    public void onHostResume() {
+        // do nothing
     }
-    return super.onTouchEvent(event);
-  }
 
-  @Override
-  protected void onSizeChanged(int w, int h, int ow, int oh) {
-    super.onSizeChanged(w, h, ow, oh);
+    @Override
+    public void onHostPause() {
+        // do nothing
+    }
 
-    if (sendContentSizeChangeEvents) {
-      dispatchEvent(
-        this,
-        new ContentSizeChangeEvent(
-          this.getId(),
-          w,
-          h
-        )
-      );
+    @Override
+    public void onHostDestroy() {
+        cleanupCallbacksAndDestroy();
     }
-  }
 
-  @Override
-  public void setWebViewClient(WebViewClient client) {
-    super.setWebViewClient(client);
-    if (client instanceof BPCWebViewClient) {
-      mBPCWebViewClient = (BPCWebViewClient) client;
-      mBPCWebViewClient.setProgressChangedFilter(progressChangedFilter);
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        if (this.nestedScrollEnabled) {
+            requestDisallowInterceptTouchEvent(true);
+        }
+        return super.onTouchEvent(event);
     }
-  }
 
-  WebChromeClient mWebChromeClient;
-  @Override
-  public void setWebChromeClient(WebChromeClient client) {
-    this.mWebChromeClient = client;
-    super.setWebChromeClient(client);
-    if (client instanceof BPCWebChromeClient) {
-      ((BPCWebChromeClient) client).setProgressChangedFilter(progressChangedFilter);
+    @Override
+    protected void onSizeChanged(int w, int h, int ow, int oh) {
+        super.onSizeChanged(w, h, ow, oh);
+
+        if (sendContentSizeChangeEvents) {
+            dispatchEvent(
+                    this,
+                    new ContentSizeChangeEvent(
+                            this.getId(),
+                            w,
+                            h
+                    )
+            );
+        }
     }
-  }
 
-  public @Nullable
-  BPCWebViewClient getBPCWebViewClient() {
-    return mBPCWebViewClient;
-  }
+    protected @Nullable
+    List<Map<String, String>> menuCustomItems;
 
-  public void setInjectedJavaScript(@Nullable String js) {
-    injectedJS = js;
-  }
+    public void setMenuCustomItems(List<Map<String, String>> menuCustomItems) {
+      this.menuCustomItems = menuCustomItems;
+    }
 
-  public void setInjectedJavaScriptBeforeContentLoaded(@Nullable String js) {
-    injectedJSBeforeContentLoaded = js;
-  }
+    @Override
+    public ActionMode startActionMode(ActionMode.Callback callback, int type) {
+      if(menuCustomItems == null ){
+        return super.startActionMode(callback, type);
+      }
 
-  public void setInjectedJavaScriptForMainFrameOnly(boolean enabled) {
-    injectedJavaScriptForMainFrameOnly = enabled;
-  }
+      return super.startActionMode(new ActionMode.Callback2() {
+        @Override
+        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+          for (int i = 0; i < menuCustomItems.size(); i++) {
+            menu.add(Menu.NONE, i, i, (menuCustomItems.get(i)).get("label"));
+          }
+          return true;
+        }
 
-  public void setInjectedJavaScriptBeforeContentLoadedForMainFrameOnly(boolean enabled) {
-    injectedJavaScriptBeforeContentLoadedForMainFrameOnly = enabled;
-  }
+        @Override
+        public boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
+          return false;
+        }
 
-  protected BPCWebViewBridge createBPCWebViewBridge(BPCWebView webView) {
-    return new BPCWebViewBridge(webView);
-  }
+        @Override
+        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+          WritableMap wMap = Arguments.createMap();
+          BPCWebView.this.evaluateJavascript(
+            "(function(){return {selection: window.getSelection().toString()} })()",
+            new ValueCallback<String>() {
+              @Override
+              public void onReceiveValue(String selectionJson) {
+                Map<String, String> menuItemMap = menuCustomItems.get(item.getItemId());
+                wMap.putString("label", menuItemMap.get("label"));
+                wMap.putString("key", menuItemMap.get("key"));
+                String selectionText = "";
+                try {
+                  selectionText = new JSONObject(selectionJson).getString("selection");
+                } catch (JSONException ignored) {}
+                wMap.putString("selectedText", selectionText);
+                dispatchEvent(BPCWebView.this, new TopCustomMenuSelectionEvent(BPCWebView.this.getId(), wMap));
+                mode.finish();
+              }
+            }
+          );
+          return true;
+        }
 
-  protected void createCatalystInstance() {
-    ReactContext reactContext = (ReactContext) this.getContext();
+        @Override
+        public void onDestroyActionMode(ActionMode mode) {
+          mode = null;
+        }
 
-    if (reactContext != null) {
-      mCatalystInstance = reactContext.getCatalystInstance();
+        @Override
+        public void onGetContentRect (ActionMode mode,
+                View view,
+                Rect outRect){
+            if (callback instanceof ActionMode.Callback2) {
+                ((ActionMode.Callback2) callback).onGetContentRect(mode, view, outRect);
+            } else {
+                super.onGetContentRect(mode, view, outRect);
+            }
+          }
+      }, type);
     }
-  }
 
-  @SuppressLint("AddJavascriptInterface")
-  public void setMessagingEnabled(boolean enabled) {
-    if (messagingEnabled == enabled) {
-      return;
+    @Override
+    public void setWebViewClient(WebViewClient client) {
+        super.setWebViewClient(client);
+        if (client instanceof BPCWebViewClient) {
+            mBPCWebViewClient = (BPCWebViewClient) client;
+            mBPCWebViewClient.setProgressChangedFilter(progressChangedFilter);
+        }
     }
 
-    messagingEnabled = enabled;
-
-    if (enabled) {
-      addJavascriptInterface(createBPCWebViewBridge(this), JAVASCRIPT_INTERFACE);
-    } else {
-      removeJavascriptInterface(JAVASCRIPT_INTERFACE);
+    WebChromeClient mWebChromeClient;
+    @Override
+    public void setWebChromeClient(WebChromeClient client) {
+        this.mWebChromeClient = client;
+        super.setWebChromeClient(client);
+        if (client instanceof BPCWebChromeClient) {
+            ((BPCWebChromeClient) client).setProgressChangedFilter(progressChangedFilter);
+        }
     }
-  }
-
-  public void setMessagingModuleName(String moduleName) {
-    messagingModuleName = moduleName;
-  }
 
-  protected void evaluateJavascriptWithFallback(String script) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-      evaluateJavascript(script, null);
-      return;
+    public WebChromeClient getWebChromeClient() {
+        return this.mWebChromeClient;
     }
 
-    try {
-      loadUrl("javascript:" + URLEncoder.encode(script, "UTF-8"));
-    } catch (UnsupportedEncodingException e) {
-      // UTF-8 should always be supported
-      throw new RuntimeException(e);
+    public @Nullable
+    BPCWebViewClient getBPCWebViewClient() {
+        return mBPCWebViewClient;
     }
-  }
 
-  public void callInjectedJavaScript() {
-    if (getSettings().getJavaScriptEnabled() &&
-      injectedJS != null &&
-      !TextUtils.isEmpty(injectedJS)) {
-      evaluateJavascriptWithFallback("(function() {\n" + injectedJS + ";\n})();");
+    public boolean getMessagingEnabled() {
+        return this.messagingEnabled;
     }
-  }
 
-  public void callInjectedJavaScriptBeforeContentLoaded() {
-    if (getSettings().getJavaScriptEnabled() &&
-      injectedJSBeforeContentLoaded != null &&
-      !TextUtils.isEmpty(injectedJSBeforeContentLoaded)) {
-      evaluateJavascriptWithFallback("(function() {\n" + injectedJSBeforeContentLoaded + ";\n})();");
+    protected BPCWebViewBridge createBPCWebViewBridge(BPCWebView webView) {
+        if (bridge == null) {
+            bridge = new BPCWebViewBridge(webView);
+            addJavascriptInterface(bridge, JAVASCRIPT_INTERFACE);
+        }
+        return bridge;
     }
-  }
 
-  public void onMessage(String message) {
-    ReactContext reactContext = (ReactContext) this.getContext();
-    BPCWebView mContext = this;
+    protected void createCatalystInstance() {
+      ThemedReactContext reactContext = (ThemedReactContext) this.getContext();
 
-    if (mBPCWebViewClient != null) {
-      WebView webView = this;
-      webView.post(new Runnable() {
-        @Override
-        public void run() {
-          if (mBPCWebViewClient == null) {
+        if (reactContext != null) {
+            mCatalystInstance = reactContext.getCatalystInstance();
+        }
+    }
+
+    @SuppressLint("AddJavascriptInterface")
+    public void setMessagingEnabled(boolean enabled) {
+        if (messagingEnabled == enabled) {
             return;
-          }
-          WritableMap data = mBPCWebViewClient.createWebViewEvent(webView, webView.getUrl());
-          data.putString("data", message);
+        }
 
-          if (mCatalystInstance != null) {
-            mContext.sendDirectMessage("onMessage", data);
-          } else {
-            dispatchEvent(webView, new TopMessageEvent(webView.getId(), data));
-          }
+        messagingEnabled = enabled;
+
+        if (enabled) {
+            createBPCWebViewBridge(this);
         }
-      });
-    } else {
-      WritableMap eventData = Arguments.createMap();
-      eventData.putString("data", message);
-
-      if (mCatalystInstance != null) {
-        this.sendDirectMessage("onMessage", eventData);
-      } else {
-        dispatchEvent(this, new TopMessageEvent(this.getId(), eventData));
-      }
     }
-  }
 
-  protected void sendDirectMessage(final String method, WritableMap data) {
-    WritableNativeMap event = new WritableNativeMap();
-    event.putMap("nativeEvent", data);
-
-    WritableNativeArray params = new WritableNativeArray();
-    params.pushMap(event);
+    protected void evaluateJavascriptWithFallback(String script) {
+        evaluateJavascript(script, null);
+    }
 
-    mCatalystInstance.callFunction(messagingModuleName, method, params);
-  }
+    public void callInjectedJavaScript() {
+        if (getSettings().getJavaScriptEnabled() &&
+                injectedJS != null &&
+                !TextUtils.isEmpty(injectedJS)) {
+            evaluateJavascriptWithFallback("(function() {\n" + injectedJS + ";\n})();");
+        }
+    }
 
-  protected void onScrollChanged(int x, int y, int oldX, int oldY) {
-    super.onScrollChanged(x, y, oldX, oldY);
+    public void callInjectedJavaScriptBeforeContentLoaded() {
+        if (getSettings().getJavaScriptEnabled() &&
+                injectedJSBeforeContentLoaded != null &&
+                !TextUtils.isEmpty(injectedJSBeforeContentLoaded)) {
+            evaluateJavascriptWithFallback("(function() {\n" + injectedJSBeforeContentLoaded + ";\n})();");
+        }
+    }
 
-    if (!hasScrollEvent) {
-      return;
+    public void setInjectedJavaScriptObject(String obj) {
+        if (getSettings().getJavaScriptEnabled()) {
+            BPCWebViewBridge b = createBPCWebViewBridge(this);
+            b.setInjectedObjectJson(obj);
+        }
     }
 
-    if (mOnScrollDispatchHelper == null) {
-      mOnScrollDispatchHelper = new OnScrollDispatchHelper();
+    public void onMessage(String message) {
+        ThemedReactContext reactContext = getThemedReactContext();
+        BPCWebView mWebView = this;
+
+        if (mBPCWebViewClient != null) {
+            WebView webView = this;
+            webView.post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mBPCWebViewClient == null) {
+                        return;
+                    }
+                    WritableMap data = mBPCWebViewClient.createWebViewEvent(webView, webView.getUrl());
+                    data.putString("data", message);
+
+                    if (mCatalystInstance != null) {
+                        mWebView.sendDirectMessage("onMessage", data);
+                    } else {
+                        dispatchEvent(webView, new TopMessageEvent(webView.getId(), data));
+                    }
+                }
+            });
+        } else {
+            WritableMap eventData = Arguments.createMap();
+            eventData.putString("data", message);
+
+            if (mCatalystInstance != null) {
+                this.sendDirectMessage("onMessage", eventData);
+            } else {
+                dispatchEvent(this, new TopMessageEvent(this.getId(), eventData));
+            }
+        }
     }
 
-    if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
-      ScrollEvent event = ScrollEvent.obtain(
-        this.getId(),
-        ScrollEventType.SCROLL,
-        x,
-        y,
-        mOnScrollDispatchHelper.getXFlingVelocity(),
-        mOnScrollDispatchHelper.getYFlingVelocity(),
-        this.computeHorizontalScrollRange(),
-        this.computeVerticalScrollRange(),
-        this.getWidth(),
-        this.getHeight());
+    protected void sendDirectMessage(final String method, WritableMap data) {
+        WritableNativeMap event = new WritableNativeMap();
+        event.putMap("nativeEvent", data);
+
+        WritableNativeArray params = new WritableNativeArray();
+        params.pushMap(event);
 
-      dispatchEvent(this, event);
+        mCatalystInstance.callFunction(messagingModuleName, method, params);
     }
-  }
 
-  protected void dispatchEvent(WebView webView, Event event) {
-    ReactContext reactContext = (ReactContext) webView.getContext();
-    EventDispatcher eventDispatcher =
-      reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();
-    eventDispatcher.dispatchEvent(event);
-  }
+    protected void onScrollChanged(int x, int y, int oldX, int oldY) {
+        super.onScrollChanged(x, y, oldX, oldY);
 
-  protected void cleanupCallbacksAndDestroy() {
-    setWebViewClient(null);
-    destroy();
-  }
+        if (!hasScrollEvent) {
+            return;
+        }
+
+        if (mOnScrollDispatchHelper == null) {
+            mOnScrollDispatchHelper = new OnScrollDispatchHelper();
+        }
 
-  @Override
-  public void destroy() {
-    if (mWebChromeClient != null) {
-      mWebChromeClient.onHideCustomView();
+        if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
+            ScrollEvent event = ScrollEvent.obtain(
+                    this.getId(),
+                    ScrollEventType.SCROLL,
+                    x,
+                    y,
+                    mOnScrollDispatchHelper.getXFlingVelocity(),
+                    mOnScrollDispatchHelper.getYFlingVelocity(),
+                    this.computeHorizontalScrollRange(),
+                    this.computeVerticalScrollRange(),
+                    this.getWidth(),
+                    this.getHeight());
+
+            dispatchEvent(this, event);
+        }
     }
-    super.destroy();
-  }
 
-  protected class BPCWebViewBridge {
-    BPCWebView mContext;
+    protected void dispatchEvent(WebView webView, Event event) {
+        ThemedReactContext reactContext = getThemedReactContext();
+        int reactTag = webView.getId();
+        UIManagerHelper.getEventDispatcherForReactTag(reactContext, reactTag).dispatchEvent(event);
+    }
 
-    BPCWebViewBridge(BPCWebView c) {
-      mContext = c;
+    protected void cleanupCallbacksAndDestroy() {
+        setWebViewClient(null);
+        destroy();
     }
 
-    /**
-     * This method is called whenever JavaScript running within the web view calls:
-     * - window[JAVASCRIPT_INTERFACE].postMessage
-     */
-    @JavascriptInterface
-    public void postMessage(String message) {
-      mContext.onMessage(message);
+    @Override
+    public void destroy() {
+        if (mWebChromeClient != null) {
+            mWebChromeClient.onHideCustomView();
+        }
+        super.destroy();
     }
+
+  public ThemedReactContext getThemedReactContext() {
+    return (ThemedReactContext) this.getContext();
   }
 
-  protected static class ProgressChangedFilter {
-    private boolean waitingForCommandLoadUrl = false;
+  protected class BPCWebViewBridge {
+        private String TAG = "BPCWebViewBridge";
+        BPCWebView mWebView;
+        String injectedObjectJson;
+
+        BPCWebViewBridge(BPCWebView c) {
+          mWebView = c;
+        }
+
+        public void setInjectedObjectJson(String s) {
+            injectedObjectJson = s;
+        }
+
+        /**
+         * This method is called whenever JavaScript running within the web view calls:
+         * - window[JAVASCRIPT_INTERFACE].postMessage
+         */
+        @JavascriptInterface
+        public void postMessage(String message) {
+            if (mWebView.getMessagingEnabled()) {
+                mWebView.onMessage(message);
+            } else {
+                FLog.w(TAG, "ReactNativeWebView.postMessage method was called but messaging is disabled. Pass an onMessage handler to the WebView.");
+            }
+        }
 
-    public void setWaitingForCommandLoadUrl(boolean isWaiting) {
-      waitingForCommandLoadUrl = isWaiting;
+        @JavascriptInterface
+        public String injectedObjectJson() { return injectedObjectJson; }
     }
 
-    public boolean isWaitingForCommandLoadUrl() {
-      return waitingForCommandLoadUrl;
+
+    protected static class ProgressChangedFilter {
+        private boolean waitingForCommandLoadUrl = false;
+
+        public void setWaitingForCommandLoadUrl(boolean isWaiting) {
+            waitingForCommandLoadUrl = isWaiting;
+        }
+
+        public boolean isWaitingForCommandLoadUrl() {
+            return waitingForCommandLoadUrl;
+        }
     }
-  }
 }