@momo-kits/native-kits 0.157.1-beta.9-debug → 0.157.1-com.1-debug

package/src/native/calculator/android/src/main/java/com/calculator/KeyboardViewPackage.java

@@ -0,0 +1,35 @@
+
+package com.calculator;
+
+import java.util.ArrayList;
+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;
+import com.calculator.modules.CalculatorKeyboardModule;
+import com.calculator.views.calculatorkeyboard.MomoTextInputCalculatorManager;
+import com.calculator.views.customkeyboard.RNCustomKeyboardModule;
+
+public class KeyboardViewPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> nativeModules = new ArrayList<>();
+        nativeModules.add(new CalculatorKeyboardModule(reactContext));
+        nativeModules.add(new RNCustomKeyboardModule(reactContext));
+        return nativeModules;
+    }
+
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        // Register your native component's view manager
+        // https://facebook.github.io/react-native/docs/native-components-android.html#4-register-the-viewmanager
+        List<ViewManager> viewManagers = new ArrayList<>();
+        viewManagers.add(new MomoTextInputCalculatorManager());
+        return viewManagers;
+    }
+}

package/src/native/calculator/android/src/main/java/com/calculator/modules/CalculatorKeyboardModule.java

@@ -0,0 +1,157 @@
+package com.calculator.modules;
+
+
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.views.textinput.ReactEditText;
+
+
+public class CalculatorKeyboardModule extends ReactContextBaseJavaModule {
+    public boolean isRegisted = false;
+    public static ReactEditText editText = null;
+
+    public CalculatorKeyboardModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.isRegisted = false;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "CalculatorKeyboardModule";
+    }
+
+    @ReactMethod
+    public void setText(String text) {
+        if(isValidText(text)) {
+            UiThreadUtil.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        editText.setText("");
+                        editText.append(text);
+                    }
+                    catch (Exception e){
+                        System.out.println("Exception occurred" + e.getMessage());
+                    }
+                }
+            });
+
+        }
+    }
+
+    boolean isValidText(String text) {
+        boolean numeric = true;
+        try {
+            Double num = Double.parseDouble(text);
+            if(num <= 0) {
+                numeric = false;
+            }
+        } catch (NumberFormatException e) {
+            numeric = false;
+        }
+
+        return numeric;
+    }
+
+    @ReactMethod
+    public static void insertText(final String text) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    int start = Math.max(editText.getSelectionStart(), 0);
+                    int end = Math.max(editText.getSelectionEnd(), 0);
+                    if(text.equals("+") || text.equals("-") || text.equals("×") || text.equals("÷")){
+                        String txt = String.valueOf(editText.getText());
+                        String newtxt = "";
+                        String lastTxt = "";
+                        if(txt.length() >= Math.max(start, end)){
+                            newtxt = txt.substring(0, Math.max(start, end));
+                        }
+                        if(newtxt.length() > 0){
+                            lastTxt = newtxt.substring(newtxt.length()-1);
+                        }
+                        if ( lastTxt.equals("+") || lastTxt.equals("-")||lastTxt.equals("×")||lastTxt.equals("÷")){
+                            editText.getText().replace(Math.min(start, end)-1, Math.max(start, end),
+                                    text, 0, text.length());
+                        }else if(lastTxt.equals(" ")){
+                            editText.getText().replace(Math.min(start, end)-2, Math.max(start, end),
+                                    text, 0, text.length());
+                        }else{
+                            editText.getText().replace(Math.min(start, end), Math.max(start, end),
+                                    text, 0, text.length());
+                        }
+                    }else{
+                        int min1 = Math.min(start, end);
+                        int min2 = Math.max(start, end);
+                        editText.getText().replace(Math.min(start, end), Math.max(start, end),
+                                text, 0, text.length());
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void backSpace() {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    int start = Math.max(editText.getSelectionStart(), 0);
+                    int end = Math.max(editText.getSelectionEnd(), 0);
+                    if (start != end) {
+                        editText.getText().delete(start, end);
+                    } else if (start > 0){
+                        String txt = String.valueOf(editText.getText());
+                        String newtxt = "";
+                        String lastTxt = "";
+                        if(txt.length() >= Math.max(start, end)){
+                            newtxt = txt.substring(0, Math.max(start, end));
+                        }
+                        if(newtxt.length() > 0){
+                            lastTxt = newtxt.substring(newtxt.length()-1);
+                        }
+                        if (lastTxt.equals(" ")){
+                            editText.getText().delete(start - 2, end);
+                        }else{
+                            editText.getText().delete(start - 1, end);
+                        }
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void doDelete() {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    int start = Math.max(editText.getSelectionStart(), 0);
+                    int end = Math.max(editText.getSelectionEnd(), 0);
+                    if (start != end) {
+                        editText.getText().delete(start, end);
+                    } else if (start > 0){
+                        editText.getText().delete(0, end);
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+}

package/src/native/calculator/android/src/main/java/com/calculator/views/calculatorkeyboard/CalculatorEditText.java

@@ -0,0 +1,36 @@
+package com.calculator.views.calculatorkeyboard;
+
+import android.content.Context;
+import android.graphics.Rect;
+
+import com.facebook.react.views.textinput.ReactEditText;
+
+class CalculatorEditText extends ReactEditText {
+    public OnFocusChangeListener onFocusListener = null;
+
+    public CalculatorEditText(Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
+        // Always return true if we are already focused. This is used by android in certain places,
+        // such as text selection.
+        if (isFocused()) {
+            return true;
+        }
+        this.setFocusable(true);
+        this.setFocusableInTouchMode(true);
+        boolean focused = super.requestFocus(direction, previouslyFocusedRect);
+
+        return focused;
+    }
+
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+        if (this.onFocusListener != null) {
+            this.onFocusListener.onFocusChange(this, this.isFocused());
+        }
+    }
+}

package/src/native/calculator/android/src/main/java/com/calculator/views/calculatorkeyboard/FixedRelativeLayout.java

@@ -0,0 +1,45 @@
+package com.calculator.views.calculatorkeyboard;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.WindowInsets;
+import android.widget.RelativeLayout;
+
+/**
+ * Created by phancuong on 6/7/18.
+ */
+
+public class FixedRelativeLayout extends RelativeLayout {
+    private int[] mInsets = new int[4];
+
+    public FixedRelativeLayout(Context context) {
+        super(context);
+    }
+
+    public FixedRelativeLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public FixedRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public FixedRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    @Override
+    public final WindowInsets onApplyWindowInsets(WindowInsets insets) {
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
+            mInsets[0] = insets.getSystemWindowInsetLeft();
+            mInsets[1] = insets.getSystemWindowInsetTop();
+            mInsets[2] = insets.getSystemWindowInsetRight();
+            return super.onApplyWindowInsets(insets.replaceSystemWindowInsets(0, 0, 0, insets.getSystemWindowInsetBottom()));
+        } else {
+            return insets;
+        }
+    }
+}

package/src/native/calculator/android/src/main/java/com/calculator/views/calculatorkeyboard/MomoTextInputCalculatorManager.java

@@ -0,0 +1,173 @@
+package com.calculator.views.calculatorkeyboard;
+
+import android.app.Activity;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.os.ResultReceiver;
+import android.text.InputType;
+import android.util.DisplayMetrics;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.RelativeLayout;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.views.textinput.ReactEditText;
+import com.facebook.react.views.textinput.ReactTextInputManager;
+import com.calculator.modules.CalculatorKeyboardModule;
+
+import javax.annotation.Nullable;
+
+public class MomoTextInputCalculatorManager extends ReactTextInputManager {
+
+    public static final String REACT_CLASS = "MomoTextInputCalculator";
+    public static ReactInstanceManager mReactInstanceManager;
+    private RelativeLayout layout = null;
+
+    private int HEIGHT_SCREEN = 0;
+    private int HEIGHT_CALCULATOR = 0;
+    private int PIXEL_KEYBOARD = 0;
+    private int STATUS_BAR_HEIGHT = 0;
+
+    ThemedReactContext mContext = null;
+    ReactRootView mContentView = null;
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public ReactEditText createViewInstance(final ThemedReactContext context) {
+        mContext = context;
+        mContentView =  new ReactRootView(mContext);
+        final CalculatorEditText editText = new CalculatorEditText(context);
+        int inputType = editText.getInputType();
+        editText.setInputType(inputType & (~InputType.TYPE_TEXT_FLAG_MULTI_LINE));
+        editText.setReturnKeyType("done");
+        editText.setShowSoftInputOnFocus(false);
+        CalculatorKeyboardModule.editText = editText;
+        CalculatorKeyboardModule.insertText("0");
+        getCustomKeyboard(context);
+
+        editText.setOnClickListener(v -> UiThreadUtil.runOnUiThread(() -> {
+            ((InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(v.getWindowToken(), 0);
+            editText.setShowSoftInputOnFocus(false);
+            if (!editText.isFocused()) {
+                editText.requestFocusFromJS();
+            }
+        }));
+
+        editText.onFocusListener = (v, hasFocus) -> UiThreadUtil.runOnUiThread(() -> {
+            if (editText.isFocused()) {
+                addContentView(context, editText);
+            } else {
+                removeContentView(context, editText);
+            }
+        });
+
+        editText.setOnKeyListener((view, keyCode, keyEvent) -> {
+            if(keyCode == KeyEvent.KEYCODE_BACK && editText.isFocused()) {
+                editText.setFocusable(false);
+                editText.clearFocus();
+                return true;
+            }
+            return false;
+        });
+        return editText;
+    }
+
+    void addContentView(final ThemedReactContext context, CalculatorEditText editText) {
+        sendEvent("keyboardDidShow", getShowCalculatorParam());
+        if (layout.getParent() == null) {
+            context.getCurrentActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
+            layout.setY(HEIGHT_CALCULATOR);
+            context.getCurrentActivity().addContentView(layout, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+            layout.animate().translationY(0).setDuration(250).withEndAction(() -> {
+                sendEvent("keyboardDidShow", getShowCalculatorParam());
+            });
+        }
+    }
+
+    void removeContentView(final ThemedReactContext context, CalculatorEditText editText) {
+        sendEvent("keyboardDidHide", getHideCalculatorParam());
+        if(layout.getParent() != null){
+            layout.setY(0);
+            layout.animate().translationY(HEIGHT_CALCULATOR).setDuration(250).withEndAction(() -> {
+                context.getCurrentActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+                sendEvent("keyboardDidHide", getHideCalculatorParam());
+                if (layout.getParent() != null) {
+                    ((ViewGroup) layout.getParent()).removeView(layout);
+                }
+            });
+        }
+    }
+
+    WritableMap getShowCalculatorParam() {
+        WritableMap params = Arguments.createMap();
+        WritableMap coordinates = Arguments.createMap();
+
+        coordinates.putDouble("screenY", PixelUtil.toDIPFromPixel(this.PIXEL_KEYBOARD));
+        coordinates.putDouble("screenX", PixelUtil.toDIPFromPixel(0));
+        coordinates.putDouble("width", PixelUtil.toDIPFromPixel(0));
+        coordinates.putDouble("height", PixelUtil.toDIPFromPixel(this.HEIGHT_CALCULATOR + STATUS_BAR_HEIGHT));
+        coordinates.putString("keyboardType", "calculator");
+        params.putMap("endCoordinates", coordinates);
+        return params;
+    }
+
+    WritableMap getHideCalculatorParam() {
+        WritableMap params = Arguments.createMap();
+        WritableMap coordinates = Arguments.createMap();
+
+        coordinates.putDouble("screenY", PixelUtil.toDIPFromPixel(this.HEIGHT_SCREEN));
+        coordinates.putDouble("screenX", PixelUtil.toDIPFromPixel(0));
+        coordinates.putDouble("width", PixelUtil.toDIPFromPixel(0));
+        coordinates.putDouble("height", PixelUtil.toDIPFromPixel(0));
+        coordinates.putString("keyboardType", "calculator");
+        params.putMap("endCoordinates", coordinates);
+        return params;
+    }
+
+    void sendEvent(String eventName, @Nullable WritableMap params) {
+        DeviceEventManagerModule.RCTDeviceEventEmitter emitter = mContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+        if(emitter != null) {
+            emitter.emit(eventName, params);
+        }
+    }
+    
+    private View getCustomKeyboard(ThemedReactContext context) {
+        ReactRootView rootView;
+        layout = new FixedRelativeLayout(context);
+        layout.setFitsSystemWindows(true);
+        rootView = new ReactRootView(context);
+        rootView.setBackgroundColor(Color.WHITE);
+        rootView.setFitsSystemWindows(true);
+
+        Bundle bundle = new Bundle();
+        rootView.startReactApplication(mReactInstanceManager, "KeyboardCalculator", bundle);
+        DisplayMetrics displayMetrics = context.getCurrentActivity().getResources().getDisplayMetrics();
+        int resourceId = context.getCurrentActivity().getResources().getIdentifier("status_bar_height", "dimen", "android");
+
+        this.HEIGHT_SCREEN = displayMetrics.heightPixels;
+        this.HEIGHT_CALCULATOR = (int) (displayMetrics.widthPixels * 0.675);
+        this.PIXEL_KEYBOARD = this.HEIGHT_SCREEN - this.HEIGHT_CALCULATOR;
+        this.STATUS_BAR_HEIGHT = context.getCurrentActivity().getResources().getDimensionPixelSize(resourceId);
+
+        RelativeLayout.LayoutParams lParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
+        lParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM, RelativeLayout.TRUE);
+        lParams.setMargins(0, this.PIXEL_KEYBOARD, 0, 0);
+        if (context.getCurrentActivity() != null) {
+            layout.addView(rootView, lParams);
+        }
+        return layout;
+    }
+}