react-native-ui-lib 8.1.1 → 8.1.5

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

@@ -0,0 +1,50 @@
+package com.wix.reactnativeuilib.highlighterview;
+
+import android.content.res.Resources;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.view.Display;
+import android.view.View;
+import android.view.Window;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+
+import java.lang.reflect.Method;
+
+public class UiUtils {
+    public static float pxToDp(Resources resources, double pixels) {
+        return (float) (resources.getDisplayMetrics().density * pixels);
+    }
+
+    public static int getStatusBarHeight(View view, Window window) {
+        int height = 0;
+        if (UiUtils.hasOnScreenSystemBar(window)) {
+            Resources resources = view.getResources();
+            int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
+            if (resourceId > 0) {
+                height = resources.getDimensionPixelSize(resourceId);
+            }
+        }
+        return height;
+    }
+
+    public static Rect getVisibleRect(View view) {
+        Rect myViewRect = new Rect();
+        view.getGlobalVisibleRect(myViewRect);
+        return myViewRect;
+    }
+
+    private static boolean hasOnScreenSystemBar(Window window) {
+        Display display = window.getWindowManager().getDefaultDisplay();
+        int rawDisplayHeight = 0;
+        try {
+            Method getRawHeight = Display.class.getMethod("getRawHeight");
+            rawDisplayHeight = (Integer) getRawHeight.invoke(display);
+        } catch (Exception ex) {
+        }
+
+        Point point = new Point();
+        display.getSize(point);
+        return (rawDisplayHeight - point.y) <= 0;
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/AppContextHolder.java

@@ -0,0 +1,52 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+
+public class AppContextHolder {
+
+    private static Activity sCurrentActivity;
+
+    public static void setApplication(Application application) {
+        application.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
+            @Override
+            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+                sCurrentActivity = activity;
+            }
+
+            @Override
+            public void onActivityStarted(Activity activity) {
+                sCurrentActivity = activity;
+            }
+
+            @Override
+            public void onActivityResumed(Activity activity) {
+                sCurrentActivity = activity;
+            }
+
+            @Override
+            public void onActivityPaused(Activity activity) {
+            }
+
+            @Override
+            public void onActivityStopped(Activity activity) {
+            }
+
+            @Override
+            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+            }
+
+            @Override
+            public void onActivityDestroyed(Activity activity) {
+                if (sCurrentActivity == activity) {
+                    sCurrentActivity = null;
+                }
+            }
+        });
+    }
+
+    public static Activity getCurrentActivity() {
+        return sCurrentActivity;
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/CustomKeyboardLayout.java

@@ -0,0 +1,213 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import android.app.Activity;
+import android.content.Context;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.EditText;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.lang.ref.WeakReference;
+
+import static com.wix.reactnativeuilib.keyboardinput.AppContextHolder.getCurrentActivity;
+import static com.wix.reactnativeuilib.keyboardinput.utils.RuntimeUtils.dispatchUIUpdates;
+import static com.wix.reactnativeuilib.keyboardinput.utils.RuntimeUtils.runOnUIThread;
+import static com.wix.reactnativeuilib.keyboardinput.utils.ViewUtils.getWindow;
+
+public class CustomKeyboardLayout implements ReactSoftKeyboardMonitor.Listener, ReactScreenMonitor.Listener {
+    private boolean mFirstKeyboardShow = true;
+    private final InputMethodManager mInputMethodManager;
+    private final ReactSoftKeyboardMonitor mKeyboardMonitor;
+    private WeakReference<CustomKeyboardRootViewShadow> mShadowNode = new WeakReference<>(null);
+    private int mSoftInputMode;
+    private boolean mIsShown = false;
+
+    public CustomKeyboardLayout(ReactContext reactContext, ReactSoftKeyboardMonitor keyboardMonitor, ReactScreenMonitor screenMonitor) {
+        mKeyboardMonitor = keyboardMonitor;
+        mInputMethodManager = (InputMethodManager) reactContext.getSystemService(Context.INPUT_METHOD_SERVICE);
+
+        mKeyboardMonitor.setListener(this);
+        screenMonitor.addListener(this);
+    }
+
+    public void setShown(boolean isShown) {
+        mIsShown = isShown;
+        Window window = getWindow();
+        if (window != null) {
+            if (mIsShown) {
+                mSoftInputMode = window.getAttributes().softInputMode;
+            } else {
+                window.setSoftInputMode(mSoftInputMode);
+            }
+        }
+    }
+
+    @Override
+    public void onSoftKeyboardVisible(boolean distinct) {
+        if (distinct) {
+            clearKeyboardOverlayMode();
+        }
+        hideCustomKeyboardContent();
+    }
+
+    @Override
+    public void onSoftKeyboardHidden() {
+        if (getShadowNodeHeight() == 0) {
+            mFirstKeyboardShow = true;
+        }
+    }
+
+    @Override
+    public void onNewReactScreen(ReactRootView reactRootView) {
+        clearKeyboardOverlayMode();
+        if (reactRootView != null) {
+            sendCustomKeyboardResignedEvent();
+        }
+    }
+
+    public void setShadowNode(CustomKeyboardRootViewShadow node) {
+        mShadowNode = new WeakReference<>(node);
+    }
+
+    public void onKeyboardHasCustomContent() {
+        runOnUIThread(new Runnable() {
+            @Override
+            public void run() {
+                showCustomKeyboardContent();
+                setKeyboardOverlayMode();
+                hideSoftKeyboardIfNeeded();
+            }
+        });
+    }
+
+    public void forceReset(final Promise promise) {
+        runOnUIThread(new Runnable() {
+            @Override
+            public void run() {
+                Activity currentActivity = getCurrentActivity();
+                if (currentActivity != null) {
+                    final View focusedView = currentActivity.getCurrentFocus();
+                    if (focusedView instanceof EditText) {
+                        showSoftKeyboard();
+                    } else {
+                        hideCustomKeyboardContent();
+                        clearKeyboardOverlayMode();
+                    }
+                    promise.resolve(null);
+                }
+            }
+        });
+    }
+
+    public void clearFocusedView() {
+        runOnUIThread(new Runnable() {
+            @Override
+            public void run() {
+                Activity currentActivity = getCurrentActivity();
+                if (currentActivity != null) {
+                    final View focusedView = currentActivity.getCurrentFocus();
+                    if (focusedView != null) {
+                        focusedView.clearFocus();
+                    }
+                }
+            }
+        });
+    }
+
+    private void showCustomKeyboardContent() {
+        setCustomKeyboardHeight(getHeightForCustomContent());
+    }
+
+    private void hideCustomKeyboardContent() {
+        setCustomKeyboardHeight(0);
+        runOnUIThread(new Runnable() {
+            @Override
+            public void run() {
+                sendCustomKeyboardResignedEvent();
+            }
+        });
+    }
+
+    private void syncCustomKeyboardHeightAfterUIUpdate(final int height) {
+        dispatchUIUpdates(new Runnable() {
+            @Override
+            public void run() {
+                setShadowNodeHeight(height);
+            }
+        });
+    }
+
+    private void setCustomKeyboardHeight(int height) {
+        try {
+            if (mFirstKeyboardShow) {
+                mFirstKeyboardShow = false;
+                syncCustomKeyboardHeightAfterUIUpdate(height);
+            } else {
+                setShadowNodeHeight(height);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void setShadowNodeHeight(int height) {
+        final CustomKeyboardRootViewShadow shadowNode = mShadowNode.get();
+        if (shadowNode != null) {
+            shadowNode.setHeight(height);
+        }
+    }
+
+    private float getShadowNodeHeight() {
+        float height = 0;
+        final CustomKeyboardRootViewShadow shadowNode = mShadowNode.get();
+        if (shadowNode != null) {
+            height = shadowNode.getHeight();
+        }
+        return height;
+    }
+
+    private void showSoftKeyboard() {
+        mInputMethodManager.showSoftInput(getCurrentActivity().getCurrentFocus(), 0);
+    }
+
+    private void hideSoftKeyboardIfNeeded() {
+        final View focusedView = getCurrentActivity().getCurrentFocus();
+        if (focusedView != null) {
+            mInputMethodManager.hideSoftInputFromWindow(focusedView.getWindowToken(), 0);
+        }
+    }
+
+    private int getHeightForCustomContent() {
+        return mKeyboardMonitor.getKeyboardHeight();
+    }
+
+    private void setKeyboardOverlayMode() {
+        setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
+    }
+
+    private void clearKeyboardOverlayMode() {
+        setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+    }
+
+    private void setSoftInputMode(int softInputMode) {
+        if (mIsShown) {
+            Window window = getWindow();
+            if (window != null) {
+                window.setSoftInputMode(softInputMode);
+            }
+        }
+    }
+
+    private void sendCustomKeyboardResignedEvent() {
+        if (ReactContextHolder.getContext().hasActiveCatalystInstance()) {
+            ReactContextHolder.getContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit("kbdResigned", null);
+        }
+    }
+
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/CustomKeyboardRootView.java

@@ -0,0 +1,39 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+
+public class CustomKeyboardRootView extends FrameLayout {
+
+    private final CustomKeyboardLayout mLayout;
+
+    public CustomKeyboardRootView(@NonNull Context context, CustomKeyboardLayout layout) {
+        super(context);
+        mLayout = layout;
+
+        setWillNotDraw(false);
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        if (getChildCount() == 1) {
+            mLayout.onKeyboardHasCustomContent();
+        }
+        super.onViewAdded(child);
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mLayout.setShown(true);
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        mLayout.setShown(false);
+        super.onDetachedFromWindow();
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/CustomKeyboardRootViewManager.java

@@ -0,0 +1,29 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+
+public class CustomKeyboardRootViewManager extends ViewGroupManager<CustomKeyboardRootView> {
+
+    private final CustomKeyboardLayout mLayout;
+
+    public CustomKeyboardRootViewManager(CustomKeyboardLayout layout) {
+        mLayout = layout;
+    }
+
+    @Override
+    public String getName() {
+        return "CustomKeyboardViewNativeTemp";
+    }
+
+    @Override
+    public CustomKeyboardRootView createViewInstance(ThemedReactContext reactContext) {
+        return new CustomKeyboardRootView(reactContext, mLayout);
+    }
+
+    @Override
+    public LayoutShadowNode createShadowNodeInstance() {
+        return new CustomKeyboardRootViewShadow(mLayout);
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/CustomKeyboardRootViewShadow.java

@@ -0,0 +1,29 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.NativeViewHierarchyOptimizer;
+
+public class CustomKeyboardRootViewShadow extends LayoutShadowNode {
+
+    private final CustomKeyboardLayout mLayout;
+
+    CustomKeyboardRootViewShadow(CustomKeyboardLayout layout) {
+        setStyleHeight(0);
+
+        mLayout = layout;
+        mLayout.setShadowNode(this);
+    }
+
+    @Override
+    public void onBeforeLayout(NativeViewHierarchyOptimizer nativeViewHierarchyOptimizer) {
+        mLayout.setShadowNode(this);
+    }
+
+    public void setHeight(int heightPx) {
+        setStyleHeight(heightPx);
+    }
+
+    public float getHeight() {
+        return getStyleHeight().value;
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/KeyboardInputModule.java

@@ -0,0 +1,34 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+public class KeyboardInputModule extends ReactContextBaseJavaModule {
+
+    private static final String REACT_CLASS = "CustomKeyboardInputTemp";
+
+    private final CustomKeyboardLayout mLayout;
+
+    public KeyboardInputModule(ReactApplicationContext reactContext, CustomKeyboardLayout layout) {
+        super(reactContext);
+
+        mLayout = layout;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void reset(Promise promise) {
+        mLayout.forceReset(promise);
+    }
+
+    @ReactMethod
+    public void clearFocusedView() {
+        mLayout.clearFocusedView();
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/KeyboardInputPackage.java

@@ -0,0 +1,49 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import android.app.Application;
+
+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 KeyboardInputPackage implements ReactPackage {
+
+    private CustomKeyboardLayout mLayout;
+
+    public KeyboardInputPackage(Application application) {
+        AppContextHolder.setApplication(application);
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        init(reactContext);
+        return Arrays.<NativeModule>asList(new KeyboardInputModule(reactContext, mLayout));
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        init(reactContext);
+        return Arrays.<ViewManager>asList(new CustomKeyboardRootViewManager(mLayout));
+    }
+
+    // Deprecated in RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    private synchronized void init(ReactApplicationContext reactContext) {
+        if (ReactContextHolder.getContext() != reactContext) {
+            ReactContextHolder.setContext(reactContext);
+
+            final ReactScreenMonitor screenMonitor = new ReactScreenMonitor(reactContext);
+            final ReactSoftKeyboardMonitor keyboardMonitor = new ReactSoftKeyboardMonitor(screenMonitor);
+            mLayout = new CustomKeyboardLayout(reactContext, keyboardMonitor, screenMonitor);
+        }
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/ReactContextHolder.java

@@ -0,0 +1,16 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+public class ReactContextHolder {
+
+    private static ReactApplicationContext sContext;
+
+    public static void setContext(ReactApplicationContext context) {
+        sContext = context;
+    }
+
+    public static ReactApplicationContext getContext() {
+        return sContext;
+    }
+}

package/lib/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/ReactScreenMonitor.java

@@ -0,0 +1,83 @@
+package com.wix.reactnativeuilib.keyboardinput;
+
+import android.view.ViewTreeObserver;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactContext;
+import com.wix.reactnativeuilib.keyboardinput.utils.ViewUtils;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.wix.reactnativeuilib.keyboardinput.utils.ViewUtils.getWindow;
+
+public class ReactScreenMonitor implements LifecycleEventListener {
+
+    public interface Listener {
+        void onNewReactScreen(ReactRootView reactRootView);
+    }
+
+    private final ViewTreeObserver.OnGlobalLayoutListener mWindowLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
+        @Override
+        public void onGlobalLayout() {
+            final ReactRootView reactRootView = ViewUtils.getReactRootView();
+            if (mLastReactRootView != reactRootView) {
+                mLastReactRootView = reactRootView;
+                notifyNewScreen();
+            }
+        }
+    };
+
+    private ReactRootView mLastReactRootView;
+    private Set<Listener> mExternalListeners = new HashSet<>();
+
+    private boolean mHasWindowLayoutListener;
+
+    public ReactScreenMonitor(ReactContext reactContext) {
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    public void addListener(Listener listener) {
+        mExternalListeners.add(listener);
+    }
+
+    @Override
+    public void onHostResume() {
+        if (mHasWindowLayoutListener) {
+            removeWindowLayoutListener();
+        }
+        mHasWindowLayoutListener = true;
+        registerWindowLayoutListener();
+    }
+
+    @Override
+    public void onHostDestroy() {
+        removeWindowLayoutListener();
+        mHasWindowLayoutListener = false;
+    }
+
+    @Override
+    public void onHostPause() {
+    }
+
+    private void registerWindowLayoutListener() {
+        if (getWindow() != null) {
+            getWindow().getDecorView().getViewTreeObserver().addOnGlobalLayoutListener(mWindowLayoutListener);
+        }
+    }
+
+    private void removeWindowLayoutListener() {
+        if (getWindow() == null) {
+            // No window => no activity => nothing to clear.
+            return;
+        }
+        getWindow().getDecorView().getViewTreeObserver().removeOnGlobalLayoutListener(mWindowLayoutListener);
+    }
+
+    private void notifyNewScreen() {
+        for (Listener listener : mExternalListeners) {
+            listener.onNewReactScreen(mLastReactRootView);
+        }
+    }
+}