Merge pull request #51 from react-native-community/renaming/rct-rnc-android

(Contains #50) Renaming rct rnc android to stay consistent with iOS

android/src/main/java/com/reactnativecommunity/webview/RCTWebViewManager.java → android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManager.java

  *  - canGoBack - boolean, whether there is anything on a history stack to go back
  *  - canGoForward - boolean, whether it is possible to request GO_FORWARD command
  */
-@ReactModule(name = RCTWebViewManager.REACT_CLASS)
-public class RCTWebViewManager extends SimpleViewManager<WebView> {
+@ReactModule(name = RNCWebViewManager.REACT_CLASS)
+public class RNCWebViewManager extends SimpleViewManager<WebView> {
 
-  protected static final String REACT_CLASS = "RCTWebView";
+  protected static final String REACT_CLASS = "RNCWebView";
 
   protected static final String HTML_ENCODING = "UTF-8";
   protected static final String HTML_MIME_TYPE = "text/html";
   protected WebViewConfig mWebViewConfig;
   protected @Nullable WebView.PictureListener mPictureListener;
 
-  protected static class RCTWebViewClient extends WebViewClient {
+  protected static class RNCWebViewClient extends WebViewClient {
 
     protected boolean mLastLoadFailed = false;
     protected @Nullable ReadableArray mUrlPrefixesForDefaultIntent;
       super.onPageFinished(webView, url);
 
       if (!mLastLoadFailed) {
-        RCTWebView reactWebView = (RCTWebView) webView;
+        RNCWebView reactWebView = (RNCWebView) webView;
         reactWebView.callInjectedJavaScript();
         reactWebView.linkBridge();
         emitFinishEvent(webView, url);
    * 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
    */
-  protected static class RCTWebView extends WebView implements LifecycleEventListener {
+  protected static class RNCWebView extends WebView implements LifecycleEventListener {
     protected @Nullable String injectedJS;
     protected boolean messagingEnabled = false;
-    protected @Nullable RCTWebViewClient mRCTWebViewClient;
+    protected @Nullable RNCWebViewClient mRNCWebViewClient;
 
-    protected class RCTWebViewBridge {
-      RCTWebView mContext;
+    protected class RNCWebViewBridge {
+      RNCWebView mContext;
 
-      RCTWebViewBridge(RCTWebView c) {
+      RNCWebViewBridge(RNCWebView c) {
         mContext = c;
       }
 
      * Reactive Native needed for access to ReactNative internal system functionality
      *
      */
-    public RCTWebView(ThemedReactContext reactContext) {
+    public RNCWebView(ThemedReactContext reactContext) {
       super(reactContext);
     }
 
     @Override
     public void setWebViewClient(WebViewClient client) {
       super.setWebViewClient(client);
-      mRCTWebViewClient = (RCTWebViewClient)client;
+      mRNCWebViewClient = (RNCWebViewClient)client;
     }
 
-    public @Nullable RCTWebViewClient getRCTWebViewClient() {
-      return mRCTWebViewClient;
+    public @Nullable RNCWebViewClient getRNCWebViewClient() {
+      return mRNCWebViewClient;
     }
 
     public void setInjectedJavaScript(@Nullable String js) {
       injectedJS = js;
     }
 
-    protected RCTWebViewBridge createRCTWebViewBridge(RCTWebView webView) {
-      return new RCTWebViewBridge(webView);
+    protected RNCWebViewBridge createRNCWebViewBridge(RNCWebView webView) {
+      return new RNCWebViewBridge(webView);
     }
 
     public void setMessagingEnabled(boolean enabled) {
 
       messagingEnabled = enabled;
       if (enabled) {
-        addJavascriptInterface(createRCTWebViewBridge(this), BRIDGE_NAME);
+        addJavascriptInterface(createRNCWebViewBridge(this), BRIDGE_NAME);
         linkBridge();
       } else {
         removeJavascriptInterface(BRIDGE_NAME);
     }
   }
 
-  public RCTWebViewManager() {
+  public RNCWebViewManager() {
     mWebViewConfig = new WebViewConfig() {
       public void configWebView(WebView webView) {
       }
     };
   }
 
-  public RCTWebViewManager(WebViewConfig webViewConfig) {
+  public RNCWebViewManager(WebViewConfig webViewConfig) {
     mWebViewConfig = webViewConfig;
   }
 
     return REACT_CLASS;
   }
 
-  protected RCTWebView createRCTWebViewInstance(ThemedReactContext reactContext) {
-    return new RCTWebView(reactContext);
+  protected RNCWebView createRNCWebViewInstance(ThemedReactContext reactContext) {
+    return new RNCWebView(reactContext);
   }
 
   @Override
   @TargetApi(Build.VERSION_CODES.LOLLIPOP)
   protected WebView createViewInstance(ThemedReactContext reactContext) {
-    RCTWebView webView = createRCTWebViewInstance(reactContext);
+    RNCWebView webView = createRNCWebViewInstance(reactContext);
     webView.setWebChromeClient(new WebChromeClient() {
       @Override
       public boolean onConsoleMessage(ConsoleMessage message) {
 
   @ReactProp(name = "injectedJavaScript")
   public void setInjectedJavaScript(WebView view, @Nullable String injectedJavaScript) {
-    ((RCTWebView) view).setInjectedJavaScript(injectedJavaScript);
+    ((RNCWebView) view).setInjectedJavaScript(injectedJavaScript);
   }
 
   @ReactProp(name = "messagingEnabled")
   public void setMessagingEnabled(WebView view, boolean enabled) {
-    ((RCTWebView) view).setMessagingEnabled(enabled);
+    ((RNCWebView) view).setMessagingEnabled(enabled);
   }
 
   @ReactProp(name = "source")
   public void setUrlPrefixesForDefaultIntent(
       WebView view,
       @Nullable ReadableArray urlPrefixesForDefaultIntent) {
-    RCTWebViewClient client = ((RCTWebView) view).getRCTWebViewClient();
+    RNCWebViewClient client = ((RNCWebView) view).getRNCWebViewClient();
     if (client != null && urlPrefixesForDefaultIntent != null) {
       client.setUrlPrefixesForDefaultIntent(urlPrefixesForDefaultIntent);
     }
   public void setOriginWhitelist(
     WebView view,
     @Nullable ReadableArray originWhitelist) {
-    RCTWebViewClient client = ((RCTWebView) view).getRCTWebViewClient();
+    RNCWebViewClient client = ((RNCWebView) view).getRNCWebViewClient();
     if (client != null && originWhitelist != null) {
       List<Pattern> whiteList = new LinkedList<>();
       for (int i = 0 ; i < originWhitelist.size() ; i++) {
   @Override
   protected void addEventEmitters(ThemedReactContext reactContext, WebView view) {
     // Do not register default touch emitter and let WebView implementation handle touches
-    view.setWebViewClient(new RCTWebViewClient());
+    view.setWebViewClient(new RNCWebViewClient());
   }
 
   @Override
         break;
       case COMMAND_POST_MESSAGE:
         try {
-          RCTWebView reactWebView = (RCTWebView) root;
+          RNCWebView reactWebView = (RNCWebView) root;
           JSONObject eventInitDict = new JSONObject();
           eventInitDict.put("data", args.getString(0));
           reactWebView.evaluateJavascriptWithFallback("(function () {" +
         }
         break;
       case COMMAND_INJECT_JAVASCRIPT:
-        RCTWebView reactWebView = (RCTWebView) root;
+        RNCWebView reactWebView = (RNCWebView) root;
         reactWebView.evaluateJavascriptWithFallback(args.getString(0));
         break;
     }
   @Override
   public void onDropViewInstance(WebView webView) {
     super.onDropViewInstance(webView);
-    ((ThemedReactContext) webView.getContext()).removeLifecycleEventListener((RCTWebView) webView);
-    ((RCTWebView) webView).cleanupCallbacksAndDestroy();
+    ((ThemedReactContext) webView.getContext()).removeLifecycleEventListener((RNCWebView) webView);
+    ((RNCWebView) webView).cleanupCallbacksAndDestroy();
   }
 
   protected WebView.PictureListener getPictureListener() {

android/src/main/java/com/reactnativecommunity/webview/RCTWebViewModule.java → android/src/main/java/com/reactnativecommunity/webview/RNCWebViewModule.java

 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.Callback;
 
-public class RCTWebViewModule extends ReactContextBaseJavaModule {
+public class RNCWebViewModule extends ReactContextBaseJavaModule {
 
   private final ReactApplicationContext reactContext;
 
-  public RCTWebViewModule(ReactApplicationContext reactContext) {
+  public RNCWebViewModule(ReactApplicationContext reactContext) {
     super(reactContext);
     this.reactContext = reactContext;
   }
 
   @Override
   public String getName() {
-    return "RCTWebView";
+    return "RNCWebView";
   }
 }

android/src/main/java/com/reactnativecommunity/webview/RCTWebViewPackage.java → android/src/main/java/com/reactnativecommunity/webview/RNCWebViewPackage.java

 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.bridge.JavaScriptModule;
-public class RCTWebViewPackage implements ReactPackage {
+public class RNCWebViewPackage implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-      return Arrays.<NativeModule>asList(new RCTWebViewModule(reactContext));
+      return Arrays.<NativeModule>asList(new RNCWebViewModule(reactContext));
     }
 
     // Deprecated from RN 0.47
 
     @Override
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-        RCTWebViewManager viewManager = new RCTWebViewManager();
+        RNCWebViewManager viewManager = new RNCWebViewManager();
         return Arrays.<ViewManager>asList(viewManager);
     }
 }

android/src/main/java/com/reactnativecommunity/webview/WebViewConfig.java

 
 /**
  * Implement this interface in order to config your {@link WebView}. An instance of that
- * implementation will have to be given as a constructor argument to {@link RCTWebViewManager}.
+ * implementation will have to be given as a constructor argument to {@link RNCWebViewManager}.
  */
 public interface WebViewConfig {
 

js/WebView.android.js

 
 const resolveAssetSource = Image.resolveAssetSource;
 
-const RCT_WEBVIEW_REF = 'webview';
-
 const WebViewState = keyMirror({
   IDLE: null,
   LOADING: null,
     startInLoadingState: true,
   };
 
+  webViewRef = React.createRef();
+
   UNSAFE_componentWillMount() {
     if (this.props.startInLoadingState) {
       this.setState({ viewState: WebViewState.LOADING });
         );
     } else if (this.state.viewState !== WebViewState.IDLE) {
       console.error(
-        'RCTWebView invalid state encountered: ' + this.state.viewState,
+        'RNCWebView invalid state encountered: ' + this.state.viewState,
       );
     }
 
       WebViewShared.originWhitelistToRegex,
     );
 
-    let NativeWebView = nativeConfig.component || RCTWebView;
+    let NativeWebView = nativeConfig.component || RNCWebView;
 
     const webView = (
       <NativeWebView
-        ref={RCT_WEBVIEW_REF}
+        ref={this.webViewRef}
         key="webViewKey"
         style={webViewStyles}
         source={resolveAssetSource(source)}
   goForward = () => {
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.goForward,
+      UIManager.RNCWebView.Commands.goForward,
       null,
     );
   };
   goBack = () => {
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.goBack,
+      UIManager.RNCWebView.Commands.goBack,
       null,
     );
   };
     });
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.reload,
+      UIManager.RNCWebView.Commands.reload,
       null,
     );
   };
   stopLoading = () => {
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.stopLoading,
+      UIManager.RNCWebView.Commands.stopLoading,
       null,
     );
   };
   postMessage = (data: string) => {
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.postMessage,
+      UIManager.RNCWebView.Commands.postMessage,
       [String(data)],
     );
   };
   injectJavaScript = (data: string) => {
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
-      UIManager.RCTWebView.Commands.injectJavaScript,
+      UIManager.RNCWebView.Commands.injectJavaScript,
       [data],
     );
   };
   };
 
   getWebViewHandle = () => {
-    return ReactNative.findNodeHandle(this.refs[RCT_WEBVIEW_REF]);
+    return ReactNative.findNodeHandle(this.webViewRef.current);
   };
 
   onLoadingStart = (event: WebViewNavigationEvent) => {
   };
 }
 
-const RCTWebView = requireNativeComponent('RCTWebView');
+const RNCWebView = requireNativeComponent('RNCWebView');
 
 const styles = StyleSheet.create({
   container: {