@momo-kits/calculator-keyboard 0.150.2-beta.21 → 0.150.2-beta.22

package/README.md

@@ -10,57 +10,15 @@ npm install react-native-calculator-keyboard
 
 ## Usage
 
+
 ```js
-import InputCalculator from '@momo-kits/calculator-keyboard';
+import { CalculatorKeyboardView } from "react-native-calculator-keyboard";
 
 // ...
 
-<InputCalculator
-  mode="NumDefault"
-  customKeyText="Next"
-  onCustomKeyEvent={() => console.log('Custom key pressed')}
-/>;
-```
-
-## Requirements
-
-**React Native 0.80+** with **Fabric (New Architecture) enabled**.
-
-This library is **pure Fabric** implementation with:
-
-- ✅ Zero RCTBridge dependencies
-- ✅ Native C++ ComponentView on iOS
-- ✅ Fabric ViewManager with codegen delegates on Android
-- ✅ All Props, Events, Commands auto-generated by codegen
-- ❌ No Paper (old architecture) support
-
-### Android Setup
-
-Add to your `gradle.properties`:
-
-```properties
-newArchEnabled=true
-```
-
-Then rebuild:
-
-```bash
-cd android && ./gradlew clean && cd ..
-npx react-native run-android
-```
-
-### iOS Setup
-
-**Required**: Set the environment variable before installing pods:
-
-```bash
-cd ios
-RCT_NEW_ARCH_ENABLED=1 pod install
-cd ..
-npx react-native run-ios
+<CalculatorKeyboardView color="tomato" />
 ```
 
-**Note**: This library uses Fabric ComponentView (`.mm` files) and will not work without `RCT_NEW_ARCH_ENABLED=1`.
 
 ## Contributing
 

package/android/src/main/java/com/calculatorkeyboard/CalculatorKeyboardPackage.kt

@@ -12,6 +12,6 @@ class CalculatorKeyboardPackage : ReactPackage {
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf(InputCalculatorViewManager())
+    return listOf(RCTInputCalculator())
   }
 }

package/android/src/main/java/com/calculatorkeyboard/CustomKeyboardView.kt

@@ -1,21 +1,19 @@
 package com.calculatorkeyboard
 
 import android.annotation.SuppressLint
-import android.content.Context
 import android.content.res.ColorStateList
 import android.graphics.Color
 import android.graphics.drawable.GradientDrawable
 import android.view.Gravity
 import android.widget.Button
 import android.widget.ImageButton
+import androidx.appcompat.app.AppCompatActivity
 import androidx.constraintlayout.widget.ConstraintLayout
 import com.facebook.react.uimanager.ThemedReactContext
 import org.mariuszgromada.math.mxparser.Expression
 import androidx.core.graphics.toColorInt
-import com.calculatorkeyboard.InputCalculatorViewManager.Companion.calculatorHeight
+import com.calculatorkeyboard.RCTInputCalculator.Companion.calculatorHeight
 import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.RCTEventEmitter
 
 @SuppressLint("SetTextI18n", "ViewConstructor")
@@ -23,57 +21,53 @@ class CustomKeyboardView(
   context: ThemedReactContext,
   private val editText: CalculatorEditText
 ) : ConstraintLayout(context) {
-  private val numWithCTAKeys = listOf(
+  private val keys = listOf(
     listOf("1", "2", "3", "÷", "back"),
     listOf("4", "5", "6", "×", "="),
-    listOf("7", "8", "9", "-", "Tiếp"),
+    listOf("7", "8", "9", "-", "Xong"),
     listOf("000", "0", "+")
   )
-  private val defaultKeys = listOf(
-    listOf("1", "2", "3", "÷", "AC"),
-    listOf("4", "5", "6", "×", "back"),
-    listOf("7", "8", "9", "-", "="),
-    listOf("000", "0", "+")
-  )
-  private val specialKeys = listOf("=", "-", "×", "÷", "back", "+", "AC")
+  private val specialKeys = listOf("=", "-", "×", "÷", "back", "+")
   private val separatorWidth = 8f
   private var specialButtonColor: Int = "#D8D8D8".toColorInt()
 
-  private var keyboardMode: String = "NumDefault"
-
   private var customKeyButton: Button? = null
   private var customKeyButtonBackground: Int = "#D8D8D8".toColorInt()
   private var customKeyButtonTextColor: Int = Color.BLACK
   private var customKeyButtonState: String = "default"
 
   init {
+    val activity = context.currentActivity as? AppCompatActivity
+    if (activity != null) {
+      val displayMetrics = resources.displayMetrics
+      val widthButton = (displayMetrics.widthPixels - separatorWidth * 2 - 4 * separatorWidth) / 5f
+      val heightButton = (calculatorHeight - separatorWidth * 2 - 3 * separatorWidth) / 4
+
       isClickable = false
       isFocusable = false
       isFocusableInTouchMode = false
       clipToPadding = false
       clipChildren = false
-  }
 
-  private fun renderUI() {
-    val displayMetrics = resources.displayMetrics
-    val buttonWidth = (displayMetrics.widthPixels - separatorWidth * 2 - 4 * separatorWidth) / 5f
-    val buttonHeight = (calculatorHeight - separatorWidth * 2 - 3 * separatorWidth) / 4
+      renderUI(widthButton, heightButton)
+    }
+
+  }
 
+  private fun renderUI(buttonWidth: Float, buttonHeight: Float) {
     var yOffset = separatorWidth
-    val keys = if (keyboardMode == "NumWithCTA") numWithCTAKeys else defaultKeys
     for ((rowIndex, row) in keys.withIndex()) {
       var xOffset = separatorWidth
       for ((colIndex, key) in row.withIndex()) {
-        val isMainKey = rowIndex == 2 && colIndex == 4
-        val isMainCTAKey = isMainKey && keyboardMode == "NumWithCTA"
+        val isCustomKey = rowIndex == 2 && colIndex == 4
         val width = if (key == "000") buttonWidth * 2 + separatorWidth else buttonWidth
-        val height = if (isMainKey) buttonHeight * 2 + separatorWidth else buttonHeight
+        val height = if (isCustomKey) buttonHeight * 2 + separatorWidth else buttonHeight
 
         val button = if (key == "back") {
           createImageButton(key, xOffset, yOffset, buttonWidth.toInt(), buttonHeight.toInt())
         } else {
-          createButton(key, xOffset, yOffset, width.toInt(), height.toInt(), isMainKey, isMainCTAKey).also { b ->
-            if (isMainCTAKey) customKeyButton = b
+          createButton(key, xOffset, yOffset, width.toInt(), height.toInt(), isCustomKey).also { b ->
+            if (isCustomKey) customKeyButton = b
           }
         }
 
@@ -91,8 +85,7 @@ class CustomKeyboardView(
     yOffset: Float,
     buttonWidth: Int,
     buttonHeight: Int,
-    isMainKey: Boolean,
-    isMainCTAKey: Boolean
+    isCustomKey: Boolean
   ): Button {
     return Button(context).apply {
       val shapeInit = GradientDrawable().apply {
@@ -105,7 +98,7 @@ class CustomKeyboardView(
       background = shapeInit
       text = key
       setTypeface(typeface)
-      textSize = (if (isMainCTAKey) 18 else 24).toFloat()
+      textSize = (if (isCustomKey) 18 else 24).toFloat()
       setTextColor(Color.BLACK)
       stateListAnimator = null
       maxLines = 1
@@ -117,7 +110,7 @@ class CustomKeyboardView(
         constrainedWidth = false
       }
 
-      if (specialKeys.contains(key) || isMainKey) {
+      if (specialKeys.contains(key)) {
         background = GradientDrawable().apply {
           shape = GradientDrawable.RECTANGLE
           cornerRadius = 24f
@@ -132,7 +125,7 @@ class CustomKeyboardView(
 
       translationX = xOffset.toInt().toFloat()
       translationY = yOffset.toInt().toFloat()
-      setOnClickListener { onKeyPress(key, isMainCTAKey) }
+      setOnClickListener { onKeyPress(key, isCustomKey) }
     }
   }
 
@@ -170,15 +163,46 @@ class CustomKeyboardView(
     }
   }
 
-  private fun onKeyPress(key: String, isMainCTAKey: Boolean) {
-    if (isMainCTAKey) {
-      emitCustomKey(context)
+  fun updateButtonColors(color: Int) {
+    specialButtonColor = color
+    for (i in 0 until childCount) {
+      val child = getChildAt(i)
+      if (child is Button) {
+        val key = child.text.toString()
+        if (specialKeys.contains(key)) {
+          if (key == "=") {
+            child.background = GradientDrawable().apply {
+              shape = GradientDrawable.RECTANGLE
+              cornerRadius = 24f
+              setColor(specialButtonColor)
+            }
+          } else {
+            child.background = GradientDrawable().apply {
+              shape = GradientDrawable.RECTANGLE
+              cornerRadius = 24f
+              setColor(specialButtonColor)
+            }
+          }
+          child.setTextColor(Color.BLACK)
+        }
+      } else if (child is ImageButton) {
+        child.background = GradientDrawable().apply {
+          shape = GradientDrawable.RECTANGLE
+          cornerRadius = 24f
+          setColor(specialButtonColor)
+        }
+      }
+    }
+  }
+
+  private fun onKeyPress(key: String, isCustomKey: Boolean) {
+    if (isCustomKey) {
+      emitCustomKey()
       return
     }
 
-    emitKeyPress(context, key)
+    emitKeyPress(key)
     when (key) {
-      "AC" -> clearText()
       "back" -> onBackSpace()
       "=" -> calculateResult()
       "×", "+", "-", "÷" -> keyDidPress(" $key ")
@@ -191,10 +215,6 @@ class CustomKeyboardView(
     editText.text?.replace(editText.selectionStart, editText.selectionEnd, key)
   }
 
-  private fun clearText() {
-    editText.text?.clear()
-  }
-
   private fun onBackSpace() {
     val start = editText.selectionStart
     val end = editText.selectionEnd
@@ -231,56 +251,44 @@ class CustomKeyboardView(
     }
   }
 
-  private fun emitKeyPress(context: Context, key: String) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-    val payload =
-      Arguments.createMap().apply {
-        putString("key", key)
-      }
-    val event = OnKeyPressEvent(surfaceId, editText.id, payload)
-
-    eventDispatcher?.dispatchEvent(event)
+  private fun emitKeyPress(key: String) {
+    val reactContext = context as ThemedReactContext
+    val params = Arguments.createMap().apply {
+      putString("key", key)
+    }
+    reactContext.getJSModule(RCTEventEmitter::class.java)
+      .receiveEvent(editText.id, "onKeyPress", params)
   }
 
-  private fun emitCustomKey(context: Context) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-
-    val event = OnCustomKeyPressEvent(surfaceId, editText.id)
-
-    eventDispatcher?.dispatchEvent(event)
+  private fun emitCustomKey() {
+    val reactContext = context as ThemedReactContext
+    reactContext.getJSModule(RCTEventEmitter::class.java)
+      .receiveEvent(editText.id, "onCustomKeyEvent", null)
   }
 
   fun setCustomKeyText(text: String) {
     customKeyButton?.text = text
   }
 
-  fun setMode(mode: String) {
-    keyboardMode = mode
-    renderUI()
-  }
-
   fun setCustomKeyBackground(background: Int) {
     customKeyButtonBackground = background
-    updateCustomKeyUI(background, customKeyButtonTextColor)
+    updateCustomKeyUI(background, customKeyButtonTextColor, customKeyButtonState)
   }
 
   fun setCustomKeyTextColor(textColor: Int) {
     customKeyButtonTextColor = textColor
-    updateCustomKeyUI(customKeyButtonBackground, textColor)
+    updateCustomKeyUI(customKeyButtonBackground, textColor, customKeyButtonState)
   }
 
 
   fun setCustomKeyState(state: String) {
     customKeyButtonState = state
     customKeyButton?.isEnabled = state != "disable"
-    updateCustomKeyUI(customKeyButtonBackground, customKeyButtonTextColor)
+    updateCustomKeyUI(customKeyButtonBackground, customKeyButtonTextColor, state)
   }
 
-  private fun updateCustomKeyUI(background: Int, textColor: Int){
+  private fun updateCustomKeyUI(background: Int, textColor: Int, state: String){
+
     customKeyButton?.background = GradientDrawable().apply {
       shape = GradientDrawable.RECTANGLE
       cornerRadius = 24f
@@ -289,4 +297,5 @@ class CustomKeyboardView(
     customKeyButton?.setTextColor(textColor)
   }
 
+
 }

package/android/src/main/java/com/calculatorkeyboard/{InputCalculatorViewManager.kt → RCTInputCalculator.kt}

@@ -3,43 +3,20 @@ package com.calculatorkeyboard
 import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.Color
-import android.graphics.Typeface
-import android.os.Build
-import android.provider.Settings.Global.putString
-import android.text.Editable
-import android.text.TextWatcher
 import android.view.KeyEvent
 import android.view.inputmethod.InputMethodManager
 import androidx.core.graphics.toColorInt
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
-import androidx.core.widget.addTextChangedListener
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil.dpToPx
-import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.uimanager.events.RCTEventEmitter
-import com.facebook.react.viewmanagers.NativeInputCalculatorManagerDelegate
-import com.facebook.react.viewmanagers.NativeInputCalculatorManagerInterface
 import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.textinput.ReactTextInputManager
 
-@ReactModule(name = InputCalculatorViewManager.REACT_CLASS)
-class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInputCalculatorManagerInterface<ReactEditText> {
-  private val delegate: NativeInputCalculatorManagerDelegate<ReactEditText, InputCalculatorViewManager> =
-    NativeInputCalculatorManagerDelegate(this)
-
-  override fun getDelegate(): ViewManagerDelegate<ReactEditText> = delegate
-
-  override fun getName() = REACT_CLASS
+class RCTInputCalculator : ReactTextInputManager() {
 
   private var keyboardView: CustomKeyboardView? = null
   private lateinit var editText: CalculatorEditText
@@ -50,14 +27,15 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
   private var backListenerAttached = false
   private var overlayShowing = false
 
+  override fun getName() = REACT_CLASS
 
   companion object {
-    const val REACT_CLASS = "NativeInputCalculator"
+    const val REACT_CLASS = "RCTInputCalculator"
     val calculatorHeight: Int = 240.dpToPx().toInt()
   }
 
   @ReactProp(name = "value")
-  override fun setValue(view: ReactEditText, value: String?) {
+  fun setValue(view: ReactEditText, value: String?) {
     UiThreadUtil.runOnUiThread {
       val e = view.editableText ?: run { view.setText(value ?: ""); return@runOnUiThread }
       val newText = value ?: ""
@@ -70,72 +48,29 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
     }
   }
 
-  override fun setTextAttributes(view: ReactEditText?, value: ReadableMap?) {
-    val fontWeightStr = value?.getString("fontWeight")
-    val fontSize = value?.getDouble("fontSize")
-
-    fontWeightStr?.let { weightStr ->
-      val weight = when (weightStr) {
-        "100" -> 100
-        "200" -> 200
-        "300" -> 300
-        "400", "normal" -> 400
-        "500" -> 500
-        "600" -> 600
-        "700", "bold" -> 700
-        "800" -> 800
-        "900" -> 900
-        else -> 400
-      }
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-        view?.typeface = Typeface.create(view.typeface, weight, false)
-      } else {
-        view?.typeface = if (weight >= 600) {
-          Typeface.create(view.typeface, Typeface.BOLD)
-        } else {
-          Typeface.create(view.typeface, Typeface.NORMAL)
-        }
-      }
-    }
-
-    fontSize?.let {
-      view?.textSize = it.toFloat()
-    }
-  }
-
-
-  @ReactProp(name = "mode")
-  override fun setMode(view: ReactEditText, mode: String?) {
-    keyboardView?.setMode(mode ?: "NumDefault")
-  }
-
   @ReactProp(name = "customKeyText")
-  override fun setCustomKeyText(view: ReactEditText, text: String?) {
-    keyboardView?.setCustomKeyText(text ?: "Tiếp")
+  fun setCustomKeyText(view: ReactEditText, text: String?) {
+    keyboardView?.setCustomKeyText(text ?: "Xong")
   }
 
   @ReactProp(name = "customKeyBackground")
-  override fun setCustomKeyBackground(view: ReactEditText, background: String?) {
+  fun setCustomKeyBackground(view: ReactEditText, background: String?) {
     keyboardView?.setCustomKeyBackground((background ?: "#d8d8d8").toColorInt())
   }
 
   @ReactProp(name = "customKeyTextColor")
-  override fun setCustomKeyTextColor(view: ReactEditText, textColor: String?) {
+  fun setCustomKeyTextColor(view: ReactEditText, textColor: String?) {
     keyboardView?.setCustomKeyTextColor(textColor?.toColorInt() ?: Color.BLACK)
   }
 
   @ReactProp(name = "customKeyState")
-  override fun setCustomKeyState(view: ReactEditText, state: String?) {
+  fun setCustomKeyState(view: ReactEditText, state: String?) {
     keyboardView?.setCustomKeyState(state ?: "default")
   }
 
-  override fun focus(view: ReactEditText?) {
-    UiThreadUtil.runOnUiThread { if (!editText.isFocused) editText.requestFocus() }
-  }
-
-  override fun blur(view: ReactEditText?) {
-    UiThreadUtil.runOnUiThread { if (editText.isFocused) editText.clearFocus() }
+  @ReactProp(name = "keyboardColor")
+  fun setKeyboardColor(view: ReactEditText, color: String) {
+    keyboardView?.updateButtonColors(color.toColorInt())
   }
 
   @SuppressLint("ClickableViewAccessibility")
@@ -166,16 +101,6 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
         }
         false
       }
-      addTextChangedListener(object : TextWatcher{
-        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
-
-        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
-
-        override fun afterTextChanged(s: Editable?) {
-          emitOnChange(context, s.toString())
-        }
-
-      })
     }
 
     keyboardView = CustomKeyboardView(context, editText).apply {
@@ -240,31 +165,33 @@ class InputCalculatorViewManager : SimpleViewManager<ReactEditText>(), NativeInp
     v.showSoftInputOnFocus = true
   }
 
-  private fun emitOnChange(context: Context, text: String) {
-    val reactContext = context as ReactContext
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
-    val payload =
-      Arguments.createMap().apply {
-        putString("text", text)
-      }
-    val event = OnChangeEvent(surfaceId, editText.id, payload)
+  override fun getCommandsMap(): Map<String, Int> = mapOf("blur" to 1, "focus" to 2)
 
-    eventDispatcher?.dispatchEvent(event)
+  override fun receiveCommand(reactEditText: ReactEditText, commandId: Int, args: ReadableArray?) {
+    when (commandId) {
+      1 -> blur()
+      2 -> focus()
+    }
   }
 
   override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
-    val base = super.getExportedCustomBubblingEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
+    val base = super.getExportedCustomBubblingEventTypeConstants().toMutableMap()
     base["onKeyPress"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onKeyPress"))
-    base["onChange"] = mapOf("phasedRegistrationNames" to mapOf("bubbled" to "onChange"))
     return base
   }
 
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
-    val base = super.getExportedCustomDirectEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
+    val base = super.getExportedCustomDirectEventTypeConstants().toMutableMap()
     base["onCustomKeyEvent"] = mapOf("registrationName" to "onCustomKeyEvent")
     return base
   }
 
+  private fun focus() {
+    UiThreadUtil.runOnUiThread { if (!editText.isFocused) editText.requestFocus() }
+  }
+
+  private fun blur() {
+    UiThreadUtil.runOnUiThread { if (editText.isFocused) editText.clearFocus() }
+  }
 }