@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/views/customkeyboard/RNCustomKeyboardModule.java

@@ -0,0 +1,417 @@
+
+package com.calculator.views.customkeyboard;
+
+import android.app.Activity;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.DisplayMetrics;
+import android.view.ActionMode;
+import android.view.Menu;
+import android.view.MenuItem;
+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.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.views.textinput.ReactEditText;
+import com.calculator.views.calculatorkeyboard.FixedRelativeLayout;
+
+
+public class RNCustomKeyboardModule extends ReactContextBaseJavaModule {
+    private final int TAG_ID = 0xdeadbeaf;
+    private final ReactApplicationContext reactContext;
+    public static ReactInstanceManager mReactInstanceManager;
+    public boolean isRegisted = false;
+    public RNCustomKeyboardModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.isRegisted = false;
+    }
+
+    Handler handle = new Handler(Looper.getMainLooper());
+
+    private ReactEditText getEditById(int id) {
+//        try{
+//            UIViewOperationQueue uii = this.getReactApplicationContext().getNativeModule(UIManagerModule.class).getUIImplementation().getUIViewOperationQueue();
+//            if(uii != null){
+//                return (ReactEditText) uii.getNativeViewHierarchyManager().resolveView(id);
+//            }
+//        }catch (Exception e){
+//            System.out.println("Exception occurred" + e.getMessage());
+//        }
+        return null;
+    }
+
+    @ReactMethod
+    public void onFocus(){
+
+    }
+
+    @ReactMethod
+    public void resetData(){
+        isRegisted = false;
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    if(activity != null){
+                    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+                     }
+                } catch (Exception e) {
+//                    install(tag,type);
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+
+    }
+    @ReactMethod
+    public void install(final int tag, final String type) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null || isRegisted) {
+                        return;
+                    }
+                    System.out.println("registed keyboard success");
+                    isRegisted = true;
+                    edit.setTag(TAG_ID, createCustomKeyboard(activity, tag, type));
+
+                    edit.setOnFocusChangeListener(new View.OnFocusChangeListener() {
+                        @Override
+                        public void onFocusChange(final View v, boolean hasFocus) {
+                            EventDispatcher eventDispatcher =
+                                    reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();
+//                            if (hasFocus) {
+//                                activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
+//                                View keyboard = (View)edit.getTag(TAG_ID);
+//                                eventDispatcher.dispatchEvent(
+//                                        new ReactTextInputFocusEvent(
+//                                                edit.getId()));
+//                                if (keyboard.getParent() == null) {
+//                                    activity.addContentView(keyboard, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+//                                }
+//                                UiThreadUtil.runOnUiThread(new Runnable() {
+//                                    @Override
+//                                    public void run() {
+//                                        ((InputMethodManager) getReactApplicationContext().getSystemService(Activity.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(v.getWindowToken(), 0);
+//                                    }
+//                                });
+//                            } else {
+//                                eventDispatcher.dispatchEvent(
+//                                        new ReactTextInputBlurEvent(
+//                                                edit.getId()));
+//                                eventDispatcher.dispatchEvent(
+//                                        new ReactTextInputEndEditingEvent(
+//                                                edit.getId(),
+//                                                edit.getText().toString()));
+//
+//                                View keyboard = (View)edit.getTag(TAG_ID);
+//                                if (keyboard.getParent() != null) {
+//                                    isRegisted = false;
+////                                    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+//                                    ((ViewGroup) keyboard.getParent()).removeView(keyboard);
+//                                }
+//                            }
+                        }
+                    });
+
+                    edit.setOnClickListener(new View.OnClickListener(){
+                        @Override
+                        public void onClick(final View v) {
+                            View keyboard = (View)edit.getTag(TAG_ID);
+                            if (keyboard.getParent() == null) {
+                                activity.addContentView(keyboard, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+                            }
+                            UiThreadUtil.runOnUiThread(new Runnable() {
+                                @Override
+                                public void run() {
+                                    ((InputMethodManager) getReactApplicationContext().getSystemService(Activity.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(v.getWindowToken(), 0);
+                                }
+                            });
+                        }
+                    });
+                    edit.setCustomSelectionActionModeCallback(new ActionMode.Callback(){
+
+                        @Override
+                        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+                            return false;
+                        }
+
+                        @Override
+                        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+                            return false;
+                        }
+
+                        @Override
+                        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+                            return false;
+                        }
+
+                        @Override
+                        public void onDestroyActionMode(ActionMode mode) {
+
+                        }
+                    });
+                } catch (Exception e) {
+//                    install(tag,type);
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    ReactRootView rootView = null;
+
+    private View createCustomKeyboard(Activity activity, int tag, String type) {
+        RelativeLayout layout = new FixedRelativeLayout(activity);
+        layout.setFitsSystemWindows(true);
+        rootView = new ReactRootView(this.getReactApplicationContext());
+        rootView.setBackgroundColor(Color.WHITE);
+        rootView.setFitsSystemWindows(true);
+        Bundle bundle = new Bundle();
+        bundle.putInt("tag", tag);
+        bundle.putString("type", type);
+        rootView.startReactApplication(mReactInstanceManager, "CustomKeyboard", bundle);
+        DisplayMetrics displayMetrics = new DisplayMetrics();
+        getCurrentActivity().getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
+
+        final float scale = activity.getResources().getDisplayMetrics().density;
+
+        int heightScreen = displayMetrics.heightPixels;
+        int heightkeyboard = (int) (heightScreen * 0.36);
+        //final int heightkeyboard = Math.round(265*scale);
+        System.out.println("height keyboard == " + heightkeyboard);
+        System.out.println("heightScreen == " + heightScreen);
+
+        RelativeLayout.LayoutParams lParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, heightkeyboard);
+        lParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM, RelativeLayout.TRUE);
+        activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
+        layout.addView(rootView, lParams);
+        return layout;
+    }
+
+    @ReactMethod
+    public void uninstall(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                final Activity activity = getCurrentActivity();
+                final ReactEditText edit = getEditById(tag);
+                if (edit == null) {
+                    return;
+                }
+
+                edit.setTag(TAG_ID, null);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void insertText(final int tag, final String text) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null) {
+                        return;
+                    }
+
+                    int start = Math.max(edit.getSelectionStart(), 0);
+                    int end = Math.max(edit.getSelectionEnd(), 0);
+                    if(text.equals("+") || text.equals("-") || text.equals("×") || text.equals("÷")){
+                        String txt = String.valueOf(edit.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("÷")){
+                            edit.getText().replace(Math.min(start, end)-1, Math.max(start, end),
+                                    text, 0, text.length());
+                        }else if(lastTxt.equals(" ")){
+                            edit.getText().replace(Math.min(start, end)-2, Math.max(start, end),
+                                    text, 0, text.length());
+                        }else{
+                            edit.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);
+                        edit.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(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null) {
+                        return;
+                    }
+                    int start = Math.max(edit.getSelectionStart(), 0);
+                    int end = Math.max(edit.getSelectionEnd(), 0);
+                    if (start != end) {
+                        edit.getText().delete(start, end);
+                    } else if (start > 0){
+                        String txt = String.valueOf(edit.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(" ")){
+                            edit.getText().delete(start - 2, end);
+                        }else{
+                            edit.getText().delete(start - 1, end);
+                        }
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void doDelete(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null) {
+                        return;
+                    }
+
+                    int start = Math.max(edit.getSelectionStart(), 0);
+                    int end = Math.max(edit.getSelectionEnd(), 0);
+                    if (start != end) {
+                        edit.getText().delete(start, end);
+                    } else if (start > 0){
+                        edit.getText().delete(0, end);
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void moveLeft(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null) {
+                        return;
+                    }
+                    int start = Math.max(edit.getSelectionStart(), 0);
+                    int end = Math.max(edit.getSelectionEnd(), 0);
+                    if (start != end) {
+                        edit.setSelection(start, start);
+                    } else {
+                        edit.setSelection(start - 1, start - 1);
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void moveRight(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Activity activity = getCurrentActivity();
+                    final ReactEditText edit = getEditById(tag);
+                    if (edit == null) {
+                        return;
+                    }
+
+                    int start = Math.max(edit.getSelectionStart(), 0);
+                    int end = Math.max(edit.getSelectionEnd(), 0);
+                    if (start != end) {
+                        edit.setSelection(end, end);
+                    } else if (start > 0){
+                        edit.setSelection(end + 1, end + 1);
+                    }
+                }catch (Exception e){
+                    System.out.println("Exception occurred" + e.getMessage());
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void switchSystemKeyboard(final int tag) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                final Activity activity = getCurrentActivity();
+                final ReactEditText edit = getEditById(tag);
+                if (edit == null) {
+                    return;
+                }
+
+                View keyboard = (View)edit.getTag(TAG_ID);
+                if (keyboard.getParent() != null) {
+                    ((ViewGroup) keyboard.getParent()).removeView(keyboard);
+                }
+                UiThreadUtil.runOnUiThread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        ((InputMethodManager) getReactApplicationContext().getSystemService(Activity.INPUT_METHOD_SERVICE)).showSoftInput(edit, InputMethodManager.SHOW_IMPLICIT);
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public String getName() {
+      return "CustomKeyboard";
+    }
+}

package/src/native/calculator/ios/Helper/MomoHelper.swift

@@ -0,0 +1,16 @@
+//
+//  MomoHelper.swift
+//  MoMoApp
+//
+//  Created by Hung Huynh on 4/20/18.
+//  Copyright © 2018 Hung Huynh. All rights reserved.
+//
+
+import Foundation
+
+
+public func dispatchUI(_ closure: @escaping () -> Void) {
+    DispatchQueue.main.async(execute: { () -> Void in
+        closure()
+    })
+}

package/src/native/calculator/ios/KeyboardView-Bridging-Header.h

@@ -0,0 +1,60 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+//  Created by react-native-create-bridge
+// NativeViews-Bridging-Header.h
+
+// import RCTBridgeModule
+#if __has_include(<React/RCTBridgeModule.h>)
+#import <React/RCTBridgeModule.h>
+#elif __has_include(“RCTBridgeModule.h”)
+#import “RCTBridgeModule.h”
+#else
+#import “React/RCTBridgeModule.h” // Required when used as a Pod in a Swift project
+#endif
+
+// import RCTEventEmitter
+#if __has_include(<React/RCTViewManager.h>)
+#import <React/RCTViewManager.h>
+#elif __has_include(“RCTViewManager.h”)
+#import “RCTViewManager.h”
+#else
+#import “React/RCTViewManager.h” // Required when used as a Pod in a Swift project
+#endif
+
+// import RCTEventEmitter
+#if __has_include(<React/RCTBaseTextInputViewManager.h>)
+#import <React/RCTBaseTextInputViewManager.h>
+#elif __has_include(“RCTBaseTextInputViewManager.h”)
+#import “RCTBaseTextInputViewManager.h”
+#else
+#import “React/RCTBaseTextInputViewManager.h” // Required when used as a Pod in a Swift project
+#endif
+
+// import RCTEventEmitter
+#if __has_include(<React/RCTSinglelineTextInputView.h>)
+#import <React/RCTSinglelineTextInputView.h>
+#elif __has_include(“RCTSinglelineTextInputView.h”)
+#import “RCTSinglelineTextInputView.h”
+#else
+#import “React/RCTSinglelineTextInputView.h” // Required when used as a Pod in a Swift project
+#endif
+
+// import RCTEventEmitter
+#if __has_include(<React/RCTRootView.h>)
+#import <React/RCTRootView.h>
+#elif __has_include(“RCTRootView.h”)
+#import “RCTRootView.h”
+#else
+#import “React/RCTRootView.h” // Required when used as a Pod in a Swift project
+#endif
+
+// import RCTEventEmitter
+#if __has_include(<React/RCTUITextField.h>)
+#import <React/RCTUITextField.h>
+#elif __has_include(“RCTUITextField.h”)
+#import “RCTUITextField.h”
+#else
+#import “React/RCTUITextField.h” // Required when used as a Pod in a Swift project
+#endif

package/src/native/calculator/ios/KeyboardView.h

@@ -0,0 +1,19 @@
+
+#if __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+#if __has_include(<React/RCTViewManager.h>)
+#import <React/RCTViewManager.h>
+#elif __has_include(“RCTViewManager.h”)
+#import “RCTViewManager.h”
+#else
+#import “React/RCTViewManager.h” // Required when used as a Pod in a Swift project
+#endif
+
+@interface KeyboardView : NSObject <RCTBridgeModule>
+
+@end
+  

package/src/native/calculator/ios/KeyboardView.m

@@ -0,0 +1,56 @@
+
+#import "KeyboardView.h"
+
+@implementation KeyboardView
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+RCT_EXPORT_MODULE()
+
+@end
+
+@interface RCT_EXTERN_MODULE(MomoTextInputCalculator, RCTViewManager)
+RCT_REMAP_VIEW_PROPERTY(autoCapitalize, backedTextInputView.autocapitalizationType, UITextAutocapitalizationType)
+RCT_REMAP_VIEW_PROPERTY(autoCorrect, backedTextInputView.autocorrectionType, UITextAutocorrectionType)
+RCT_REMAP_VIEW_PROPERTY(contextMenuHidden, backedTextInputView.contextMenuHidden, BOOL)
+RCT_REMAP_VIEW_PROPERTY(editable, backedTextInputView.editable, BOOL)
+RCT_REMAP_VIEW_PROPERTY(enablesReturnKeyAutomatically, backedTextInputView.enablesReturnKeyAutomatically, BOOL)
+RCT_REMAP_VIEW_PROPERTY(keyboardAppearance, backedTextInputView.keyboardAppearance, UIKeyboardAppearance)
+RCT_REMAP_VIEW_PROPERTY(placeholder, backedTextInputView.placeholder, NSString)
+RCT_REMAP_VIEW_PROPERTY(placeholderTextColor, backedTextInputView.placeholderColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(returnKeyType, backedTextInputView.returnKeyType, UIReturnKeyType)
+RCT_REMAP_VIEW_PROPERTY(selectionColor, backedTextInputView.tintColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(spellCheck, backedTextInputView.spellCheckingType, UITextSpellCheckingType)
+RCT_REMAP_VIEW_PROPERTY(caretHidden, backedTextInputView.caretHidden, BOOL)
+RCT_REMAP_VIEW_PROPERTY(clearButtonMode, backedTextInputView.clearButtonMode, UITextFieldViewMode)
+RCT_REMAP_VIEW_PROPERTY(scrollEnabled, backedTextInputView.scrollEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(secureTextEntry, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(blurOnSubmit, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(clearTextOnFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(keyboardType, UIKeyboardType)
+RCT_EXPORT_VIEW_PROPERTY(maxLength, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(selectTextOnFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(selection, RCTTextSelection)
+RCT_EXPORT_VIEW_PROPERTY(inputAccessoryViewID, NSString)
+RCT_EXPORT_VIEW_PROPERTY(textContentType, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(onChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onSelectionChange, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onTextInput, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onScroll, RCTDirectEventBlock)
+
+RCT_EXPORT_VIEW_PROPERTY(mostRecentEventCount, NSInteger)
+
+RCT_EXPORT_SHADOW_PROPERTY(text, NSString)
+RCT_EXPORT_SHADOW_PROPERTY(placeholder, NSString)
+RCT_EXPORT_SHADOW_PROPERTY(onContentSizeChange, RCTBubblingEventBlock)
+@end
+
+@interface RCT_EXTERN_MODULE(CalculatorKeyboardModule, RCTViewManager)
+RCT_EXTERN_METHOD(insertText:(NSString*)text)
+RCT_EXTERN_METHOD(backSpace)
+RCT_EXTERN_METHOD(doDelete)
+@end
+