react-native-ui-lib 8.1.1 → 8.1.7-snapshot.7597

package/lib/android/build.gradle

@@ -0,0 +1,32 @@
+apply plugin: 'com.android.library'
+
+project.ext {
+    buildToolsVersion = rootProject.ext.has("buildToolsVersion") ? rootProject.ext.buildToolsVersion : '35.0.0'
+    minSdkVersion = rootProject.ext.has("minSdkVersion") ? rootProject.ext.minSdkVersion : 24
+    compileSdkVersion = rootProject.ext.has("compileSdkVersion") ? rootProject.ext.compileSdkVersion : 35
+    targetSdkVersion = rootProject.ext.has("targetSdkVersion") ? rootProject.ext.targetSdkVersion : 34
+    supportLibVersion = rootProject.ext.has("supportLibVersion") ? rootProject.ext.supportLibVersion  : '28.0.0'
+}
+
+android {
+    namespace "com.wix.reactnativeuilib"
+    compileSdkVersion project.ext.compileSdkVersion
+    buildToolsVersion project.ext.buildToolsVersion
+
+    defaultConfig {
+        minSdkVersion project.ext.minSdkVersion
+        targetSdkVersion project.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+}

package/lib/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/lib/android/src/main/java/com/wix/reactnativeuilib/UiLibPackageList.java

@@ -0,0 +1,28 @@
+package com.wix.reactnativeuilib;
+
+import android.app.Application;
+import com.facebook.react.ReactPackage;
+
+import com.wix.reactnativeuilib.dynamicfont.DynamicFontPackage;
+import com.wix.reactnativeuilib.highlighterview.HighlighterViewPackage;
+import com.wix.reactnativeuilib.keyboardinput.KeyboardInputPackage;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class UiLibPackageList {
+
+    private final Application application;
+
+    public UiLibPackageList(Application application) {
+        this.application = application;
+    }
+
+    public List<ReactPackage> getPackageList() {
+        return Arrays.asList(
+                new DynamicFontPackage(),
+                new HighlighterViewPackage(),
+                new KeyboardInputPackage(application)
+        );
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/dynamicfont/DynamicFontModule.java

@@ -0,0 +1,139 @@
+package com.wix.reactnativeuilib.dynamicfont;
+
+import android.app.Activity;
+import android.graphics.Typeface;
+import android.util.Base64;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.views.text.ReactFontManager;
+
+import java.io.File;
+import java.io.FileOutputStream;
+
+public class DynamicFontModule extends ReactContextBaseJavaModule {
+  int tempNameCounter = 0;
+
+  public DynamicFontModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return "DynamicFont";
+  }
+
+  // TODO: Needs to be tested
+  // @ReactMethod
+  // public void loadFontFromFile(final ReadableMap options, final Callback callback) {
+  //   Activity currentActivity = getCurrentActivity();
+  //   if (currentActivity == null) {
+  //     callback.invoke("Invalid activity");
+  //     return;
+  //   }
+
+  //   String filePath = options.hasKey("filePath") ? options.getString("filePath") : null,
+  //          name = (options.hasKey("name")) ? options.getString("name") : null;
+
+  //   if (filePath == null || filePath.length() == 0) {
+  //     callback.invoke("filePath property empty");
+  //     return;
+  //   }
+
+  //   File f = new File(filePath);
+
+  //   if (f.exists() && f.canRead()) {
+  //     boolean wasLoaded = false;
+  //     try {
+  //       Typeface typeface = Typeface.createFromFile(f);
+  //       //Cache the font for react
+  // TODO: probably needs to be Typeface.NORMAL and not typeface.getStyle()
+  //       ReactFontManager.getInstance().setTypeface(name, typeface.getStyle(), typeface);
+  //       wasLoaded = true;
+  //     } catch (Throwable e) {
+  //       callback.invoke(e.getMessage());
+  //     } finally {
+  //       if (wasLoaded) {
+  //         callback.invoke(null, name);
+  //       }
+  //     }
+  //   } else {
+  //     callback.invoke("invalid file");
+  //   }
+  // }
+
+  @ReactMethod
+  public void loadFont(final ReadableMap options, final Callback callback) throws Exception {
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity == null) {
+      callback.invoke("Invalid activity");
+      return;
+    }
+
+    String name = (options.hasKey("name")) ? options.getString("name") : null,
+           data = (options.hasKey("data")) ? options.getString("data") : null,
+           type = null;
+
+    if (name == null || name.length() == 0) {
+      callback.invoke("Name property empty");
+      return;
+    }
+
+    if (data == null || data.length() == 0) {
+      callback.invoke("Data property empty");
+      return;
+    }
+
+    if (("data:").equalsIgnoreCase(data.substring(0, 5))) {
+      Integer pos = data.indexOf(',');
+      if (pos > 0) {
+        String[] encodingParams = data.substring(5, pos).split(";");
+        String mimeType = encodingParams[0];
+
+        data = data.substring(pos + 1);
+
+        if (("application/x-font-ttf").equalsIgnoreCase(mimeType) ||
+            ("application/x-font-truetype").equalsIgnoreCase(mimeType) ||
+            ("font/ttf").equalsIgnoreCase(mimeType)) {
+          type = "ttf";
+        } else if (("application/x-font-opentype").equalsIgnoreCase(mimeType) ||
+                   ("font/opentype").equalsIgnoreCase(mimeType)) {
+          type = "otf";
+        }
+      }
+    }
+
+    if (options.hasKey("type"))
+      type = options.getString("type");
+
+    if (type == null)
+      type = "ttf";
+
+    try {
+      byte[] decodedBytes = Base64.decode(data, Base64.DEFAULT);
+      File cacheFile = new File(currentActivity.getCacheDir(), "tempFont" + (tempNameCounter++) + type);
+
+      FileOutputStream stream = new FileOutputStream(cacheFile);
+      try {
+        stream.write(decodedBytes);
+      } finally {
+        stream.close();
+      }
+
+      //Load the font from the temporary file we just created
+      Typeface typeface = Typeface.createFromFile(cacheFile);
+
+      //Cache the font for react
+      ReactFontManager.getInstance().setTypeface(name, Typeface.NORMAL, typeface);
+
+      cacheFile.delete();
+    } catch(Exception e) {
+      callback.invoke(e.getMessage());
+    } finally {
+      callback.invoke(null, name);
+    }
+  }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/dynamicfont/DynamicFontPackage.java

@@ -0,0 +1,28 @@
+package com.wix.reactnativeuilib.dynamicfont;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+
+public class DynamicFontPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+      return Arrays.<NativeModule>asList(new DynamicFontModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+      return Collections.emptyList();
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/highlighterview/HighlightFrame.java

@@ -0,0 +1,33 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import android.content.res.Resources;
+import android.graphics.RectF;
+
+import com.facebook.react.bridge.ReadableMap;
+
+public class HighlightFrame {
+    public float x;
+    public float y;
+    public float width;
+    public float height;
+
+    public HighlightFrame(Resources resources, ReadableMap highlightFrameMap) {
+        if (highlightFrameMap != null) {
+            x = UiUtils.pxToDp(resources, highlightFrameMap.getDouble("x"));
+            y = UiUtils.pxToDp(resources, highlightFrameMap.getDouble("y"));
+            width = UiUtils.pxToDp(resources, highlightFrameMap.getDouble("width"));
+            height = UiUtils.pxToDp(resources, highlightFrameMap.getDouble("height"));
+        }
+    }
+
+    public HighlightFrame(float x, float y, float width, float height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public RectF toRect() {
+        return new RectF(x, y, x + width,y + height);
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/highlighterview/HighlightViewTagParams.java

@@ -0,0 +1,50 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import android.content.res.Resources;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+public class HighlightViewTagParams {
+    public float paddingTop = 0;
+    public float paddingLeft = 0;
+    public float paddingBottom = 0;
+    public float paddingRight = 0;
+    public float offsetX = 0;
+    public float offsetY = 0;
+
+    public HighlightViewTagParams(Resources resources, ReadableMap highlightViewTagParams) {
+        if (highlightViewTagParams != null) {
+            if (highlightViewTagParams.hasKey("padding")) {
+                if (highlightViewTagParams.getType("padding") == ReadableType.Number) {
+                    float paddingValue = UiUtils.pxToDp(resources, highlightViewTagParams.getDouble("padding"));
+                    paddingTop = paddingLeft = paddingBottom = paddingRight = paddingValue;
+                } else if (highlightViewTagParams.getType("padding") == ReadableType.Map) {
+                    ReadableMap paddingMap = highlightViewTagParams.getMap("padding");
+                    if (paddingMap.hasKey("top")) {
+                        paddingTop = UiUtils.pxToDp(resources, paddingMap.getDouble("top"));
+                    }
+                    if (paddingMap.hasKey("left")) {
+                        paddingLeft = UiUtils.pxToDp(resources, paddingMap.getDouble("left"));
+                    }
+                    if (paddingMap.hasKey("bottom")) {
+                        paddingBottom = UiUtils.pxToDp(resources, paddingMap.getDouble("bottom"));
+                    }
+                    if (paddingMap.hasKey("right")) {
+                        paddingRight = UiUtils.pxToDp(resources, paddingMap.getDouble("right"));
+                    }
+                }
+            }
+
+            if (highlightViewTagParams.hasKey("offset")) {
+                ReadableMap offsetMap = highlightViewTagParams.getMap("offset");
+                if (offsetMap.hasKey("x")) {
+                    offsetX = UiUtils.pxToDp(resources, offsetMap.getDouble("x"));
+                }
+                if (offsetMap.hasKey("y")) {
+                    offsetY = UiUtils.pxToDp(resources, offsetMap.getDouble("y"));
+                }
+            }
+        }
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/highlighterview/HighlighterView.java

@@ -0,0 +1,167 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.RectF;
+import android.view.View;
+import android.util.SizeF;
+
+import androidx.annotation.ColorInt;
+
+public class HighlighterView extends View {
+    private RectF highlightFrame;
+    private RectF viewBasedHighlightFrame;
+    HighlightViewTagParams highlightViewTagParams;
+    private @ColorInt
+    int overlayColor;
+    private @ColorInt int strokeColor;
+    private float strokeWidth;
+    private float borderRadius;
+    private SizeF minimumRectSize;
+    private float innerPadding;
+
+    private static final PorterDuffXfermode porterDuffXfermode = new PorterDuffXfermode(PorterDuff.Mode.CLEAR);
+    private static final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+
+    public HighlighterView(Context context) {
+        super(context);
+        setLayerType(LAYER_TYPE_HARDWARE, null);
+    }
+
+    private RectF rectToDraw() {
+        if (viewBasedHighlightFrame != null && viewBasedHighlightFrame.width() > 0 && viewBasedHighlightFrame.height() > 0) {
+            if (highlightViewTagParams == null) {
+                RectF frame = adjustFrame(viewBasedHighlightFrame);
+                return frame;
+            }
+
+            RectF highlightRect = new RectF(viewBasedHighlightFrame);
+            highlightRect.left -= highlightViewTagParams.paddingLeft;
+            highlightRect.top -= highlightViewTagParams.paddingTop;
+            highlightRect.right += highlightViewTagParams.paddingRight;
+            highlightRect.bottom += highlightViewTagParams.paddingBottom;
+
+            if (highlightViewTagParams.offsetX > 0) {
+                highlightRect.left += highlightViewTagParams.offsetX;
+                highlightRect.right += highlightViewTagParams.offsetX;
+            }
+            if (highlightViewTagParams.offsetY > 0) {
+                highlightRect.top += highlightViewTagParams.offsetY;
+                highlightRect.bottom += highlightViewTagParams.offsetY;
+            }
+            return highlightRect;
+        } else {
+            return highlightFrame;
+        }
+    }
+
+    private float getRadius(RectF rect) {
+        float newRadius = 0;
+        if (borderRadius > 0) {
+            newRadius = borderRadius;
+        }
+        else {
+            if (rect != null) {
+                newRadius = Math.min(rect.width() / 2, rect.height() / 2);
+            }
+        }
+        return newRadius;
+    }
+
+    public void setHighlightFrame(HighlightFrame frame) {
+        highlightFrame = frame.toRect();
+        invalidate();
+    }
+
+    public void setOverlayColor(@ColorInt int overlayColor) {
+        this.overlayColor = overlayColor;
+        invalidate();
+    }
+
+    public void setStrokeColor(@ColorInt int strokeColor) {
+        this.strokeColor = strokeColor;
+        invalidate();
+    }
+
+    public void setStrokeWidth(int strokeWidth) {
+        this.strokeWidth = UiUtils.pxToDp(getResources(), strokeWidth);
+        invalidate();
+    }
+
+    public void setBorderRadius(int borderRadius) {
+        this.borderRadius = UiUtils.pxToDp(getResources(), borderRadius);
+        invalidate();
+    }
+
+    public void setViewBasedHighlightFrame(HighlightFrame viewBasedHighlightFrame) {
+        this.viewBasedHighlightFrame = viewBasedHighlightFrame.toRect();
+        invalidate();
+    }
+
+    public void setHighlightViewTagParams(HighlightViewTagParams highlightViewTagParams) {
+        this.highlightViewTagParams = highlightViewTagParams;
+        invalidate();
+    }
+
+    @TargetApi(21)
+    public void setMinimumRectSize(SizeF minimumRectSize) {
+        float width = UiUtils.pxToDp(getResources(), minimumRectSize.getWidth());
+        float height = UiUtils.pxToDp(getResources(), minimumRectSize.getHeight());
+        this.minimumRectSize = new SizeF(width, height);
+        invalidate();
+    }
+
+    public void setInnerPadding(int innerPadding) {
+        this.innerPadding = UiUtils.pxToDp(getResources(), innerPadding); //innerPadding;
+        invalidate();
+    }
+
+    @TargetApi(21)
+    public RectF adjustFrame(RectF frame) {
+        float x = frame.left;
+        float y = frame.top;
+        float fWidth = frame.right - frame.left;
+        float fHeight = frame.bottom - frame.top;
+        float width = fWidth + (innerPadding * 2);
+        float height = fHeight + (innerPadding * 2);
+        if (minimumRectSize != null) {
+            width = width < minimumRectSize.getWidth() ? minimumRectSize.getWidth() : width;
+            height = height < minimumRectSize.getHeight() ? minimumRectSize.getHeight() : height;
+        }
+
+        x = x - ((width - fWidth) / 2);
+        y = y - ((height - fHeight) / 2);
+
+        return new RectF(x, y, x + width, y + height); // float left, float top, float right, float bottom
+    }
+
+    @Override
+    public void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        paint.setColor(overlayColor);
+        paint.setStyle(Paint.Style.FILL);
+        canvas.drawPaint(paint);
+
+        RectF rect = rectToDraw();
+        float radius = getRadius(rect);
+
+        if(rect != null) {
+            paint.setXfermode(porterDuffXfermode);
+
+            canvas.drawRoundRect(rect, radius, radius, paint);
+
+            if (strokeWidth > 0) {
+                paint.setXfermode(null);
+                paint.setColor(strokeColor);
+                paint.setStrokeWidth(strokeWidth);
+                paint.setStyle(Paint.Style.STROKE);
+                canvas.drawRoundRect(rect, radius, radius, paint);
+            }
+        }
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/highlighterview/HighlighterViewManager.java

@@ -0,0 +1,131 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.graphics.Rect;
+import android.util.Log;
+import android.util.SizeF;
+import android.view.View;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.common.UIManagerType;
+
+import javax.annotation.Nullable;
+
+class HighlighterViewManager extends SimpleViewManager<HighlighterView> {
+    private static final String REACT_CLASS = "HighlighterView";
+
+    private ThemedReactContext context;
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public HighlighterView createViewInstance(ThemedReactContext context) {
+        this.context = context;
+        HighlighterView view = new HighlighterView(context);
+        view.setFitsSystemWindows(true);
+        return view;
+    }
+
+    @ReactProp(name = "highlightFrame")
+    public void setHighlightFrame(HighlighterView view, ReadableMap highlightFrame) {
+        view.setHighlightFrame(new HighlightFrame(view.getResources(), highlightFrame));
+    }
+
+    @ReactProp(name = "overlayColor")
+    public void setOverlayColor(HighlighterView view, @Nullable Integer overlayColor) {
+        view.setOverlayColor((overlayColor == null) ? 0 : overlayColor);
+    }
+
+    @ReactProp(name = "borderRadius")
+    public void setBorderRadius(HighlighterView view, @Nullable Integer borderRadius) {
+        view.setBorderRadius((borderRadius == null) ? 0 : borderRadius);
+    }
+
+    @ReactProp(name = "strokeColor")
+    public void setStrokeColor(HighlighterView view, @Nullable Integer strokeColor) {
+        view.setStrokeColor((strokeColor == null) ? 0 : strokeColor);
+    }
+
+    @ReactProp(name = "strokeWidth")
+    public void setStrokeWidth(HighlighterView view, @Nullable Integer strokeWidth) {
+        view.setStrokeWidth((strokeWidth == null) ? 0 : strokeWidth);
+    }
+
+    @TargetApi(21)
+    @ReactProp(name = "minimumRectSize")
+    public void setMinimumRectSize(HighlighterView view, ReadableMap minimumRectSize) {
+        float width = (float) minimumRectSize.getDouble("width");
+        float height = (float) minimumRectSize.getDouble("height");
+        view.setMinimumRectSize(new SizeF(width, height));
+    }
+
+    @ReactProp(name = "innerPadding")
+    public void setInnerPadding(HighlighterView view, @Nullable Integer innerPadding) {
+        view.setInnerPadding((innerPadding == null) ? 0 : innerPadding);
+    }
+
+    @ReactProp(name = "highlightViewTag")
+    public void setHighlightViewTag(final HighlighterView view, Integer highlightViewTag) {
+        if (highlightViewTag != null) {
+            try {
+                UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(context, highlightViewTag);
+                if (uiManager != null) {
+                    final View resolvedView = uiManager.resolveView(highlightViewTag);
+                    if (resolvedView != null) {
+                        if (resolvedView.getWidth() == 0 || resolvedView.getHeight() == 0) {
+                            resolvedView.addOnLayoutChangeListener(new View.OnLayoutChangeListener() {
+                                @Override
+                                public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
+                                    float width = right - left;
+                                    float height = bottom - top;
+                                    if (width > 0 && height > 0) {
+                                        setViewBasedHighlightFrame(view, resolvedView);
+                                        resolvedView.removeOnLayoutChangeListener(this);
+                                    }
+                                }
+                            });
+                        } else {
+                            setViewBasedHighlightFrame(view, resolvedView);
+                        }
+                    } else {
+                        Log.e("HighlighterView", "was not able to resolve highlightViewTag: " + highlightViewTag.toString());
+                    }
+                } else {
+                    Log.e("HighlighterView", "was not able to resolve get uiManager for highlightViewTag: " + highlightViewTag.toString());
+                }
+            } catch (IllegalViewOperationException e) {
+                Log.e("HighlighterView", "invalid highlightViewTag: " + highlightViewTag.toString() + " " + e.toString());
+            }
+        } else {
+            Log.e("HighlighterView", "highlightViewTag is null");
+        }
+    }
+
+    @ReactProp(name = "highlightViewTagParams")
+    public void setHighlightViewTagParams(HighlighterView view, ReadableMap highlightViewTagParams) {
+        view.setHighlightViewTagParams(new HighlightViewTagParams(view.getResources(), highlightViewTagParams));
+    }
+
+    private void setViewBasedHighlightFrame(HighlighterView view, View resolvedView) {
+        Activity currentActivity = context.getCurrentActivity();
+        if (currentActivity == null) {
+            return;
+        }
+
+        final float topOffset = UiUtils.getStatusBarHeight(view, currentActivity.getWindow());
+        Rect myViewRect = UiUtils.getVisibleRect(resolvedView);
+        view.setViewBasedHighlightFrame(new HighlightFrame(myViewRect.left, myViewRect.top - topOffset, resolvedView.getWidth(), resolvedView.getHeight()));
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/highlighterview/HighlighterViewPackage.java

@@ -0,0 +1,28 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class HighlighterViewPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList( new HighlighterViewManager() );
+    }
+}