@react-native-ohos/react-native-keyboard-controller 1.12.8 → 1.12.10-rc.1

package/harmony/keyboard_controller/src/main/cpp/KeyboardControllerViewComponentInstance.cpp

@@ -1,274 +1,837 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
- */
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "KeyboardControllerViewComponentInstance.h"
-#include <folly/dynamic.h>
-#include <iostream>
-#include <arkui/native_interface_focus.h>
-
-namespace rnoh {
-using KeyboardControllerStatus = rnoh::KeyboardControllerStatus;
-KeyboardControllerViewComponentInstance::KeyboardControllerViewComponentInstance(Context context)
-    : CppComponentInstance(std::move(context)), ArkTSMessageHub::Observer(m_deps->arkTSMessageHub) {
-    DLOG(INFO) << "KeyboardControllerViewComponentInstance";
-
-    m_customNode.setCustomNodeDelegate(this);
-}
-void KeyboardControllerViewComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
-                                                              std::size_t index) {
-    CppComponentInstance::onChildInserted(childComponentInstance, index);
-    m_customNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index + 1);
-    DLOG(INFO) << "###111" << childComponentInstance->getComponentName();
-    findTextInputComponents(childComponentInstance);
-}
-
-void KeyboardControllerViewComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
-    CppComponentInstance::onChildRemoved(childComponentInstance);
-    m_customNode.removeChild(childComponentInstance->getLocalRootArkUINode());
-}
-
-void KeyboardControllerViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
-    DLOG(INFO) << "###onPropsChanged" << props->enabled << props->statusBarTranslucent
-               << props->navigationBarTranslucent;
-    CppComponentInstance::onPropsChanged(props);
-    if (this->enabled != props->enabled) {
-        this->enabled = props->enabled;
-        this->startKeyboardObserver();
-    }
-    if (this->navigationBarTranslucent != props->navigationBarTranslucent) {
-        this->navigationBarTranslucent = props->navigationBarTranslucent;
-        this->setWindowSystemBarEnable();
-    }
-    if (this->statusBarTranslucent != props->statusBarTranslucent) {
-        this->statusBarTranslucent = props->statusBarTranslucent;
-        this->setWindowSystemBarEnable();
-    }
-}
-
-void KeyboardControllerViewComponentInstance::onCommandReceived(std::string const &commandName,
-                                                                folly::dynamic const &args) {
-    CppComponentInstance::onCommandReceived(commandName, args);
-}
-
-ArkUINode &KeyboardControllerViewComponentInstance::getLocalRootArkUINode() { return m_customNode; }
-void KeyboardControllerViewComponentInstance::onClick() {}
-void KeyboardControllerViewComponentInstance::onMessageReceived(ArkTSMessage const &message) {
-    DLOG(INFO) << "onMessageReceived";
-    if (message.name == "keyboardHeightChange") {
-        double height = message.payload.getDouble();
-        DLOG(INFO) << "keyboardHeightChange: " << height;
-        if (height > 0) {
-            this->keyboardStatus = KeyboardControllerStatus::SHOW;
-            this->keyboardHeight = height;
-            this->textInputVector.clear();
-            this->focusDidSet();
-            auto textInputVectorTemp = ViewHierarchyNavigator::getAllInputFields(this->shared_from_this());
-            for (size_t i = 0; i < textInputVectorTemp.size(); ++i) {
-                auto &input = textInputVectorTemp[i];
-                findTextInputComponents(input);
-            }
-        }
-        if (height == 0) {
-            this->keyboardStatus = KeyboardControllerStatus::HIDE;
-        }
-        this->keyboardHeightChangeHandle();
-    }
-    if (message.name == "setFocusTo") {
-        std::string direction = message.payload.getString();
-        this->setFocusTo(direction);
-    }
-}
-void KeyboardControllerViewComponentInstance::setWindowSystemBarEnable() {
-    auto rnInstancePtr = this->m_deps->rnInstance.lock();
-    if (rnInstancePtr != nullptr) {
-        auto turboModule = rnInstancePtr->getTurboModule("KeyboardController");
-        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
-        arkTsTurboModule->callSync("setWindowSystemBarEnable", {this->statusBarTranslucent, this->navigationBarTranslucent});
-    }
-}
-
-void KeyboardControllerViewComponentInstance::startKeyboardObserver() {
-    auto rnInstancePtr = this->m_deps->rnInstance.lock();
-    if (rnInstancePtr != nullptr) {
-        auto turboModule = rnInstancePtr->getTurboModule("KeyboardController");
-        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
-        arkTsTurboModule->callSync("startKeyboardObserver", {this->enabled});
-    }
-}
-
-void KeyboardControllerViewComponentInstance::keyboardHeightChangeHandle() {
-    auto rnInstancePtr = this->m_deps->rnInstance.lock();
-    if (rnInstancePtr != nullptr && this->enabled) {
-        if (this->keyboardStatus == KeyboardControllerStatus::HIDE) {
-            facebook::react::KeyboardControllerViewEventEmitter::MoveEvent start = {this->keyboardHeight, 0, 0, m_tag};
-            facebook::react::KeyboardControllerViewEventEmitter::MoveEvent end = {0, 0, 0, m_tag};
-            m_eventEmitter->onKeyboardMoveStart(start);
-              m_eventEmitter->onKeyboardMove(end);
-            m_eventEmitter->onKeyboardMoveEnd(end);
-        } else {
-            facebook::react::KeyboardControllerViewEventEmitter::MoveEvent start = {0, 0, 0, m_tag};
-            facebook::react::KeyboardControllerViewEventEmitter::MoveEvent end = {this->keyboardHeight, 1, 0, m_tag};
-            m_eventEmitter->onKeyboardMoveStart(start);
-             m_eventEmitter->onKeyboardMove(end);
-            m_eventEmitter->onKeyboardMoveEnd(end);
-        }
-    }
-}
-
-/**
- * 遍历查找TextInput
- * */
-void KeyboardControllerViewComponentInstance::findTextInputComponents(
-    ComponentInstance::Shared const &childComponentInstance) {
-    std::string name = childComponentInstance->getComponentName();
-    DLOG(INFO) << "###" << name;
-    if (name.find("TextInput") != std::string::npos || name.find("TextArea") != std::string::npos) {
-        auto input = std::dynamic_pointer_cast<TextInputComponentInstance>(childComponentInstance);
-        ArkUINode &node = input->getLocalRootArkUINode();
-        TextInputNode *inputNodePtr = dynamic_cast<TextInputNode *>(&node);
-        if (!inputNodePtr) {
-            TextAreaNode *textAreaNodePtr = dynamic_cast<TextAreaNode *>(&node);
-            textAreaNodePtr->setTextAreaNodeDelegate(this);
-        } else {
-            inputNodePtr->setTextInputNodeDelegate(this);
-        }
-        this->textInputVector.push_back(input);
-    }
-    auto childrenComponentInstances = childComponentInstance->getChildren();
-    if (childrenComponentInstances.empty()) {
-        return;
-    }
-
-    std::vector<ComponentInstance::Shared>::iterator it1;
-    for (it1 = childrenComponentInstances.begin(); it1 != childrenComponentInstances.end(); ++it1) {
-        ComponentInstance::Shared const &t = *it1;
-        findTextInputComponents(t);
-    }
-}
-
-void KeyboardControllerViewComponentInstance::onChange(std::string text) {
-    facebook::react::KeyboardControllerViewEventEmitter::TextChangeEvent event = {text};
-    if(this->enabled){
-        m_eventEmitter->onFocusedInputTextChanged(event);
-     }
-
-}
-
-void KeyboardControllerViewComponentInstance::onChange(std::string text, std::string extendStr) {
-    onChange(std::move(text));
-}
-
-void KeyboardControllerViewComponentInstance::onTextSelectionChange(int32_t location, int32_t length) {
-    DLOG(INFO) << " onKeyboardControllerView onTextSelectionChange";
-    // to do
-};
-
-void KeyboardControllerViewComponentInstance::focusDidSet() {
-    int currentIndex = -1;
-    this->textInputVector = ViewHierarchyNavigator::getAllInputFields(this->shared_from_this());
-    int count = static_cast<int>(this->textInputVector.size());
-    for (size_t i = 0; i < this->textInputVector.size(); ++i) {
-        auto& input = this->textInputVector[i];
-        ArkUINode& node = input->getLocalRootArkUINode();
-        if (node.isFocused()) {
-           currentIndex = static_cast<int>(i);
-           break;
-        }
-    }
-    this->textInputVector.clear();
-   // 发送 focusDidSet 事件到 JS 层
-    if (currentIndex >= 0 && this->enabled) {
-       auto rnInstancePtr = this->m_deps->rnInstance.lock();
-       if (rnInstancePtr != nullptr) {
-           folly::dynamic payload = folly::dynamic::object
-               ("current", currentIndex)
-               ("count", count);
-           rnInstancePtr->postMessageToArkTS("focusDidSet", payload);
-       }
-   }
-}
-
-void KeyboardControllerViewComponentInstance::onFocus() {
-    DLOG(INFO) << "onKeyboardControllerView onFocus";
-    this->focusDidSet();
-}
-
-void KeyboardControllerViewComponentInstance::onBlur() { DLOG(INFO) << " onKeyboardControllerView onBlur"; }
-
-/**
- * 设置焦点到指定方向的输入框
- * 实现逻辑仿照 iOS ViewHierarchyNavigator.swift
- * @param direction "next" | "prev"
- */
-void KeyboardControllerViewComponentInstance::setFocusTo(const std::string& direction) {
-    // 确定当前焦点组件
-    this->textInputVector = ViewHierarchyNavigator::getAllInputFields(this->shared_from_this());
-    ComponentInstance::Shared currentFocus = nullptr;
-    for (size_t i = 0; i < this->textInputVector.size(); ++i) {
-        auto& input = this->textInputVector[i];
-        ArkUINode& node = input->getLocalRootArkUINode();
-        if (node.isFocused()) {
-           currentFocus = input;
-           break;
-        }
-    }
-    if (!currentFocus) {
-        DLOG(INFO) << "no current focus available";
-        return;
-    }
-    // 使用 ViewHierarchyNavigator 查找目标输入框
-    auto targetInput = ViewHierarchyNavigator::setFocusTo(direction, currentFocus);
-    if (targetInput) {
-        DLOG(INFO) << "setFocusTo: found target, requesting focus, tag=" << targetInput->getTag();
-        // 获取 ArkUI_NodeHandle 并请求焦点
-        ArkUINode& node = targetInput->getLocalRootArkUINode();
-        ArkUI_NodeHandle nodeHandle = node.getArkUINodeHandle();
-        ArkUI_ErrorCode result = ARKUI_ERROR_CODE_NO_ERROR;
-        high_lib_handle = dlopen("libace_ndk.z.so", RTLD_LAZY);
-        if (high_lib_handle == NULL) {
-            DLOG(INFO) << "libace_ndk.z.so not existed";
-            dlclose(high_lib_handle);
-        } else {
-            focusRequestMethod = (ArkUI_ErrorCode(*)(ArkUI_NodeHandle node))dlsym(high_lib_handle, "OH_ArkUI_FocusRequest");
-            bool isFocusRequestMethodExisted = focusRequestMethod != NULL;
-            if (isFocusRequestMethodExisted) {
-                DLOG(INFO) << "OH_ArkUI_FocusRequest method existed";
-                result = focusRequestMethod(nodeHandle);
-            } else {
-                DLOG(INFO) << "OH_ArkUI_FocusRequest method not existed";
-            }
-            dlclose(high_lib_handle);
-        }
-        if (!(result == ARKUI_ERROR_CODE_NO_ERROR)) {
-            DLOG(WARNING) << "setFocusTo: focus request failed with error code: " << result;
-        }
-    } else {
-        DLOG(INFO) << "setFocusTo: no target input found in direction " << direction;
-    }
-    this->textInputVector.clear();
-}
-} // namespace rnoh
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "KeyboardControllerViewComponentInstance.h"
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <folly/dynamic.h>
+#include <iostream>
+#include <unordered_map>
+#include <arkui/native_interface_focus.h>
+#include "RNOH/RNInstance.h"
+#include "react/renderer/components/textinput/TextInputProps.h"
+
+namespace rnoh {
+using KeyboardControllerStatus = rnoh::KeyboardControllerStatus;
+
+namespace {
+constexpr int KBC_FOCUSED_INPUT_AREA_CHANGE_TARGET_ID = 0x4B4243;
+struct InputObserver {
+    using Instance = std::shared_ptr<KeyboardControllerViewComponentInstance>;
+
+    std::weak_ptr<TextInputComponentInstance> input;
+    bool areaEventRegistered = false;
+    std::unordered_map<KeyboardControllerViewComponentInstance *,
+                       std::weak_ptr<KeyboardControllerViewComponentInstance>> instances;
+
+    void addInstance(Instance const &target) {
+        instances[target.get()] = target;
+    }
+
+    void removeInstance(KeyboardControllerViewComponentInstance *target) {
+        instances.erase(target);
+        for (auto it = instances.begin(); it != instances.end();) {
+            if (it->second.expired()) {
+                it = instances.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+    std::vector<Instance> lockInstances() {
+        std::vector<Instance> result;
+        for (auto it = instances.begin(); it != instances.end();) {
+            auto instance = it->second.lock();
+            if (instance) {
+                result.push_back(instance);
+                ++it;
+            } else {
+                it = instances.erase(it);
+            }
+        }
+        return result;
+    }
+};
+std::unordered_map<ArkUI_NodeHandle, InputObserver> g_inputObservers;
+
+static std::string keyboardTypeToString(facebook::react::KeyboardType type) {
+    switch (type) {
+        case facebook::react::KeyboardType::Default: return "default";
+        case facebook::react::KeyboardType::EmailAddress: return "email-address";
+        case facebook::react::KeyboardType::Numeric: return "numeric";
+        case facebook::react::KeyboardType::PhonePad: return "phone-pad";
+        case facebook::react::KeyboardType::NumberPad: return "number-pad";
+        case facebook::react::KeyboardType::DecimalPad: return "decimal-pad";
+        case facebook::react::KeyboardType::ASCIICapable: return "ascii-capable";
+        case facebook::react::KeyboardType::NumbersAndPunctuation: return "numbers-and-punctuation";
+        case facebook::react::KeyboardType::URL: return "url";
+        case facebook::react::KeyboardType::NamePhonePad: return "name-phone-pad";
+        case facebook::react::KeyboardType::Twitter: return "twitter";
+        case facebook::react::KeyboardType::WebSearch: return "web-search";
+        case facebook::react::KeyboardType::ASCIICapableNumberPad: return "ascii-capable-number-pad";
+        case facebook::react::KeyboardType::VisiblePassword: return "visible-password";
+    }
+    return "default";
+}
+} // namespace
+
+KeyboardControllerViewComponentInstance::KeyboardControllerViewComponentInstance(Context context)
+    : CppComponentInstance(std::move(context)), ArkTSMessageHub::Observer(m_deps->arkTSMessageHub) {
+    DLOG(INFO) << "KeyboardControllerViewComponentInstance";
+
+    m_keyboardVsyncListener = std::make_shared<VSyncListener>("KeyboardControllerAnimation");
+    m_customNode.setCustomNodeDelegate(this);
+}
+
+KeyboardControllerViewComponentInstance::~KeyboardControllerViewComponentInstance() {
+    cancelKeyboardAnimation();
+    m_keyboardVsyncListener.reset();
+    clearFocusedInputLayoutObserver();
+    for (const auto &child : getChildren()) {
+        clearTextInputDelegates(child);
+    }
+    for (auto it = g_inputObservers.begin(); it != g_inputObservers.end();) {
+        auto handle = (it++)->first;
+        removeInputObserver(handle);
+    }
+}
+void KeyboardControllerViewComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                              std::size_t index) {
+    CppComponentInstance::onChildInserted(childComponentInstance, index);
+    m_customNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index + 1);
+    DLOG(INFO) << "###111" << childComponentInstance->getComponentName();
+    findTextInputComponents(childComponentInstance);
+}
+
+void KeyboardControllerViewComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    clearTextInputDelegates(childComponentInstance);
+    if (childComponentInstance->getLocalRootArkUINode().getArkUINodeHandle() == m_observedFocusedInputHandle) {
+        clearFocusedInputLayoutObserver();
+    }
+    CppComponentInstance::onChildRemoved(childComponentInstance);
+    m_customNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+}
+
+void KeyboardControllerViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    DLOG(INFO) << "###onPropsChanged" << props->enabled << props->statusBarTranslucent
+               << props->navigationBarTranslucent;
+    CppComponentInstance::onPropsChanged(props);
+    if (this->enabled != props->enabled) {
+        this->enabled = props->enabled;
+        this->startKeyboardObserver();
+    }
+    if (this->navigationBarTranslucent != props->navigationBarTranslucent) {
+        this->navigationBarTranslucent = props->navigationBarTranslucent;
+        this->setWindowSystemBarEnable();
+    }
+    if (this->statusBarTranslucent != props->statusBarTranslucent) {
+        this->statusBarTranslucent = props->statusBarTranslucent;
+        this->setWindowSystemBarEnable();
+    }
+}
+
+void KeyboardControllerViewComponentInstance::onCommandReceived(std::string const &commandName,
+                                                                folly::dynamic const &args) {
+    CppComponentInstance::onCommandReceived(commandName, args);
+    if (commandName == "synchronizeFocusedInputLayout") {
+        syncUpLayout();
+    }
+}
+
+ArkUINode &KeyboardControllerViewComponentInstance::getLocalRootArkUINode() { return m_customNode; }
+void KeyboardControllerViewComponentInstance::onClick() {}
+void KeyboardControllerViewComponentInstance::onMessageReceived(ArkTSMessage const &message) {
+    DLOG(INFO) << "onMessageReceived";
+    if (message.name == "keyboardHeightChange") {
+        double height = message.payload.getDouble();
+        double previousKeyboardHeight = this->keyboardHeight;
+        DLOG(INFO) << "keyboardHeightChange: " << height;
+        if (height > 0) {
+            this->keyboardStatus = KeyboardControllerStatus::SHOW;
+            this->keyboardHeight = height;
+            this->textInputVector.clear();
+            this->focusDidSet();
+            auto textInputVectorTemp = ViewHierarchyNavigator::getAllInputFields(this->shared_from_this());
+            for (size_t i = 0; i < textInputVectorTemp.size(); ++i) {
+                auto &input = textInputVectorTemp[i];
+                findTextInputComponents(input);
+            }
+        }
+        if (height == 0) {
+            this->keyboardStatus = KeyboardControllerStatus::HIDE;
+            this->keyboardHeight = previousKeyboardHeight > 0 ? previousKeyboardHeight : 0;
+            m_lastKeyboardEventTarget = -1;
+        }
+        m_isHandlingKeyboardHeightChange = true;
+        if (this->enabled) {
+            syncUpLayout();
+        }
+        this->keyboardHeightChangeHandle(previousKeyboardHeight);
+        m_isHandlingKeyboardHeightChange = false;
+        if (height == 0) {
+            this->keyboardHeight = 0;
+        }
+    }
+    if (message.name == "setFocusTo") {
+        std::string direction = message.payload.getString();
+        this->setFocusTo(direction);
+    }
+}
+void KeyboardControllerViewComponentInstance::setWindowSystemBarEnable() {
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr) {
+        auto turboModule = rnInstancePtr->getTurboModule("KeyboardController");
+        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+        arkTsTurboModule->callSync("setWindowSystemBarEnable", {this->statusBarTranslucent, this->navigationBarTranslucent});
+    }
+}
+
+void KeyboardControllerViewComponentInstance::startKeyboardObserver() {
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr) {
+        auto turboModule = rnInstancePtr->getTurboModule("KeyboardController");
+        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+        arkTsTurboModule->callSync("startKeyboardObserver", {this->enabled, true});
+    }
+}
+
+void KeyboardControllerViewComponentInstance::keyboardHeightChangeHandle(double previousKeyboardHeight) {
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr && this->enabled) {
+        int target = m_tag;
+        auto focusedInput = findFocusedTextInput();
+        if (focusedInput) {
+            target = static_cast<int>(focusedInput->getTag());
+            m_lastFocusedInputTag = target;
+        } else if (this->keyboardStatus == KeyboardControllerStatus::HIDE &&
+                   m_lastFocusedInputTag != -1) {
+            // On Harmony, NODE_ON_BLUR fires before the keyboard height change,
+            // so findFocusedTextInput() returns nullptr during keyboard hide.
+            // Use the cached tag so the JS layer receives the focused input's
+            // tag (e.g. 606) instead of m_tag (e.g. 8).
+            target = m_lastFocusedInputTag;
+        }
+        m_lastKeyboardEventTarget = target;
+        const bool willHide = this->keyboardStatus == KeyboardControllerStatus::HIDE;
+        startKeyboardAnimation(previousKeyboardHeight, willHide ? 0 : this->keyboardHeight, target);
+    }
+}
+
+TaskExecutor::Shared KeyboardControllerViewComponentInstance::getTaskExecutor() const {
+    auto rnInstance = m_deps->rnInstance.lock();
+    auto internalInstance = std::dynamic_pointer_cast<RNInstanceInternal>(rnInstance);
+    return internalInstance ? internalInstance->getTaskExecutor() : nullptr;
+}
+
+void KeyboardControllerViewComponentInstance::cancelKeyboardAnimation() {
+    ++m_keyboardAnimationGeneration;
+    auto taskExecutor = getTaskExecutor();
+    if (m_keyboardAnimationTask.has_value() && taskExecutor) {
+        taskExecutor->cancelDelayedTask(m_keyboardAnimationTask.value());
+    }
+    m_keyboardAnimationTask.reset();
+    m_keyboardAnimationStartTimestampNs.reset();
+}
+
+void KeyboardControllerViewComponentInstance::startKeyboardAnimation(double fromHeight, double toHeight, int target) {
+    cancelKeyboardAnimation();
+    const uint64_t generation = m_keyboardAnimationGeneration;
+    constexpr int durationMs = 150;
+    facebook::react::KeyboardControllerViewEventEmitter::MoveEvent start = {
+        toHeight > 0 ? toHeight : 0,
+        toHeight > 0 ? 1.0 : 0.0,
+        durationMs,
+        target};
+    m_eventEmitter->onKeyboardMoveStart(start);
+    requestKeyboardAnimationFrame(generation, fromHeight, toHeight, target);
+}
+
+void KeyboardControllerViewComponentInstance::requestKeyboardAnimationFrame(
+    uint64_t generation,
+    double fromHeight,
+    double toHeight,
+    int target) {
+    if (!m_keyboardVsyncListener || !m_eventEmitter || !this->enabled) {
+        return;
+    }
+    auto weakSelf = std::weak_ptr<KeyboardControllerViewComponentInstance>(
+        std::static_pointer_cast<KeyboardControllerViewComponentInstance>(shared_from_this()));
+    m_keyboardVsyncListener->requestFrame(
+        [weakSelf, generation, fromHeight, toHeight, target](long long timestampNs) {
+            auto self = weakSelf.lock();
+            if (!self || generation != self->m_keyboardAnimationGeneration) {
+                return;
+            }
+            auto taskExecutor = self->getTaskExecutor();
+            if (!taskExecutor) {
+                return;
+            }
+            auto frameTask = [weakSelf, generation, fromHeight, toHeight, target, timestampNs] {
+                auto self = weakSelf.lock();
+                if (!self) {
+                    return;
+                }
+                self->handleKeyboardAnimationFrame(
+                    generation, fromHeight, toHeight, target, static_cast<int64_t>(timestampNs));
+            };
+            if (taskExecutor->isOnTaskThread(TaskThread::MAIN)) {
+                frameTask();
+            } else {
+                taskExecutor->runTask(TaskThread::MAIN, std::move(frameTask));
+            }
+        });
+}
+
+void KeyboardControllerViewComponentInstance::handleKeyboardAnimationFrame(
+    uint64_t generation,
+    double fromHeight,
+    double toHeight,
+    int target,
+    int64_t timestampNs) {
+    if (generation != m_keyboardAnimationGeneration || !m_eventEmitter || !this->enabled) {
+        return;
+    }
+
+    if (!m_keyboardAnimationStartTimestampNs.has_value()) {
+        m_keyboardAnimationStartTimestampNs = timestampNs;
+    }
+
+    constexpr int durationMs = 150;
+    constexpr int64_t nanosecondsPerMillisecond = 1000000;
+    constexpr int64_t durationNs = durationMs * nanosecondsPerMillisecond;
+    const int64_t elapsedNs = std::max<int64_t>(0, timestampNs - m_keyboardAnimationStartTimestampNs.value());
+    const double animationFraction = std::clamp(
+        static_cast<double>(elapsedNs) / static_cast<double>(durationNs),
+        0.0,
+        1.0);
+    const double height = fromHeight + (toHeight - fromHeight) * animationFraction;
+    const double denominator = std::max(fromHeight, toHeight);
+    facebook::react::KeyboardControllerViewEventEmitter::MoveEvent move = {
+        height,
+        denominator > 0 ? std::abs(height / denominator) : 0.0,
+        durationMs,
+        target};
+    m_eventEmitter->onKeyboardMove(move);
+
+    if (animationFraction < 1.0) {
+        requestKeyboardAnimationFrame(generation, fromHeight, toHeight, target);
+        return;
+    }
+
+    constexpr int scrollSettleDelayMs = 16;
+    auto taskExecutor = getTaskExecutor();
+    if (!taskExecutor) {
+        return;
+    }
+    auto weakSelf = std::weak_ptr<KeyboardControllerViewComponentInstance>(
+        std::static_pointer_cast<KeyboardControllerViewComponentInstance>(shared_from_this()));
+    m_keyboardAnimationTask = taskExecutor->runDelayedTask(
+        TaskThread::MAIN,
+        [weakSelf, generation, toHeight, target] {
+            auto self = weakSelf.lock();
+            if (!self || generation != self->m_keyboardAnimationGeneration ||
+                !self->m_eventEmitter || !self->enabled) {
+                return;
+            }
+            constexpr int durationMs = 150;
+            facebook::react::KeyboardControllerViewEventEmitter::MoveEvent end = {
+                toHeight, toHeight > 0 ? 1.0 : 0.0, durationMs, target};
+            self->m_eventEmitter->onKeyboardMoveEnd(end);
+            self->m_keyboardAnimationTask.reset();
+            self->m_keyboardAnimationStartTimestampNs.reset();
+        },
+        scrollSettleDelayMs);
+}
+
+/**
+ * 遍历查找TextInput
+ * */
+void KeyboardControllerViewComponentInstance::findTextInputComponents(
+    ComponentInstance::Shared const &childComponentInstance) {
+    std::string name = childComponentInstance->getComponentName();
+    if (name.find("TextInput") != std::string::npos || name.find("TextArea") != std::string::npos) {
+        auto input = std::dynamic_pointer_cast<TextInputComponentInstance>(childComponentInstance);
+        if (!input) {
+            return;
+        }
+        ArkUINode &node = input->getLocalRootArkUINode();
+        auto handle = node.getArkUINodeHandle();
+        auto observerIt = g_inputObservers.find(handle);
+        if (observerIt != g_inputObservers.end() && observerIt->second.input.expired()) {
+            g_inputObservers.erase(observerIt);
+            observerIt = g_inputObservers.end();
+        }
+        if (handle && observerIt == g_inputObservers.end()) {
+            auto result = NativeNodeApi::getInstance()->addNodeEventReceiver(
+                handle, KeyboardControllerViewComponentInstance::textSelectionEventReceiver);
+            if (result == ARKUI_ERROR_CODE_NO_ERROR) {
+                InputObserver observer;
+                observer.input = input;
+                g_inputObservers.emplace(handle, std::move(observer));
+                observerIt = g_inputObservers.find(handle);
+            }
+        }
+        if (observerIt != g_inputObservers.end()) {
+            observerIt->second.input = input;
+            observerIt->second.addInstance(
+                std::dynamic_pointer_cast<KeyboardControllerViewComponentInstance>(shared_from_this()));
+        }
+        this->textInputVector.push_back(input);
+    }
+    auto childrenComponentInstances = childComponentInstance->getChildren();
+    if (childrenComponentInstances.empty()) {
+        return;
+    }
+
+    std::vector<ComponentInstance::Shared>::iterator it1;
+    for (it1 = childrenComponentInstances.begin(); it1 != childrenComponentInstances.end(); ++it1) {
+        ComponentInstance::Shared const &t = *it1;
+        findTextInputComponents(t);
+    }
+}
+
+void KeyboardControllerViewComponentInstance::clearTextInputDelegates(
+    ComponentInstance::Shared const &component) {
+    if (!component) {
+        return;
+    }
+    ArkUINode &node = component->getLocalRootArkUINode();
+    if (node.getArkUINodeHandle() == m_observedFocusedInputHandle) {
+        clearFocusedInputLayoutObserver();
+    }
+    removeInputObserver(node.getArkUINodeHandle());
+    for (const auto &child : component->getChildren()) {
+        clearTextInputDelegates(child);
+    }
+}
+
+void KeyboardControllerViewComponentInstance::removeInputObserver(ArkUI_NodeHandle handle) {
+    auto observerIt = g_inputObservers.find(handle);
+    if (observerIt == g_inputObservers.end()) {
+        return;
+    }
+    observerIt->second.removeInstance(this);
+    if (!observerIt->second.instances.empty()) {
+        return;
+    }
+    if (observerIt->second.input.lock()) {
+        if (observerIt->second.areaEventRegistered) {
+            NativeNodeApi::getInstance()->unregisterNodeEvent(handle, NODE_EVENT_ON_AREA_CHANGE);
+        }
+        NativeNodeApi::getInstance()->removeNodeEventReceiver(
+            handle, KeyboardControllerViewComponentInstance::textSelectionEventReceiver);
+    }
+    g_inputObservers.erase(observerIt);
+}
+
+void KeyboardControllerViewComponentInstance::onChange(std::string text) {
+    onChange(std::move(text), findFocusedTextInput());
+}
+
+void KeyboardControllerViewComponentInstance::onChange(
+    std::string text,
+    TextInputComponentInstance::Shared const &focusedInput) {
+    facebook::react::KeyboardControllerViewEventEmitter::TextChangeEvent event = {text};
+    if (this->enabled && m_eventEmitter) {
+        syncUpLayout(focusedInput);
+        m_eventEmitter->onFocusedInputTextChanged(event);
+    }
+}
+
+void KeyboardControllerViewComponentInstance::onChange(std::string text, std::string extendStr) {
+    onChange(std::move(text));
+}
+
+void KeyboardControllerViewComponentInstance::onTextSelectionChange(int32_t location, int32_t length) {
+    if (!this->enabled) {
+        return;
+    }
+    auto focusedInput = findFocusedTextInput();
+    if (!focusedInput) {
+        return;
+    }
+    syncUpLayout();
+    dispatchSelectionToJS(
+        static_cast<int>(focusedInput->getTag()),
+        location,
+        location + length);
+}
+
+void KeyboardControllerViewComponentInstance::dispatchSelectionToJS(
+    int target, int32_t startPos, int32_t endPos) {
+    if (!m_eventEmitter || !this->enabled) {
+        return;
+    }
+    facebook::react::KeyboardControllerViewEventEmitter::InputSectionEvent event = {};
+    event.target = target;
+    event.selection.start.x = 0;
+    event.selection.start.y = 0;
+    event.selection.start.position = startPos;
+    event.selection.end.x = 0;
+    event.selection.end.y = 0;
+    event.selection.end.position = endPos;
+    m_eventEmitter->onFocusedInputSelectionChanged(event);
+}
+
+void KeyboardControllerViewComponentInstance::focusDidSet() {
+    auto focused = findFocusedTextInput();
+    if (!focused || !this->enabled) {
+        this->textInputVector.clear();
+        return;
+    }
+    this->textInputVector = ViewHierarchyNavigator::getAllInputFields(this->shared_from_this());
+    int count = static_cast<int>(this->textInputVector.size());
+    int currentIndex = -1;
+    for (size_t i = 0; i < this->textInputVector.size(); ++i) {
+        auto& input = this->textInputVector[i];
+        if (input && input->getTag() == focused->getTag()) {
+            currentIndex = static_cast<int>(i);
+            break;
+        }
+    }
+    this->textInputVector.clear();
+   // 发送 focusDidSet 事件到 JS 层
+    if (currentIndex >= 0) {
+       auto rnInstancePtr = this->m_deps->rnInstance.lock();
+       if (rnInstancePtr != nullptr) {
+           folly::dynamic payload = folly::dynamic::object
+               ("current", currentIndex)
+               ("count", count);
+           rnInstancePtr->postMessageToArkTS("focusDidSet", payload);
+       }
+   }
+}
+
+void KeyboardControllerViewComponentInstance::onFocus() {
+    postFocusedInputChanged();
+    this->focusDidSet();
+    syncUpLayout();
+}
+
+void KeyboardControllerViewComponentInstance::onBlur() {
+    // Cache the tag of the input that is losing focus. On Harmony, NODE_ON_BLUR
+    // fires before the keyboard height change arrives, so findFocusedTextInput()
+    // will return nullptr when keyboardHeightChangeHandle runs. This cache lets
+    // us send the correct target (the focused input's tag, not m_tag) during
+    // keyboard hide.
+    auto focusedInput = findFocusedTextInput();
+    if (focusedInput) {
+        m_lastFocusedInputTag = static_cast<int>(focusedInput->getTag());
+    }
+    clearFocusedInputLayoutObserver();
+    m_lastLayoutEvent = FocusedInputLayoutData{};
+    if (m_eventEmitter && this->enabled) {
+        facebook::react::KeyboardControllerViewEventEmitter::InputLayoutEvent payload = {};
+        payload.target = -1;
+        payload.parentScrollViewTarget = -1;
+        m_eventEmitter->onFocusedInputLayoutChanged(payload);
+    }
+}
+
+/**
+ * 设置焦点到指定方向的输入框
+ * 实现逻辑仿照 iOS ViewHierarchyNavigator.swift
+ * @param direction "next" | "prev"
+ */
+void KeyboardControllerViewComponentInstance::setFocusTo(const std::string& direction) {
+    if (direction != "next" && direction != "prev") {
+        DLOG(WARNING) << "setFocusTo: invalid direction, must be 'next' or 'prev'";
+ 	    return;
+    }
+    auto currentFocus = this->findFocusedTextInput();
+    if (!currentFocus) {
+        DLOG(INFO) << "no current focus available";
+        return;
+    }
+    // 使用 ViewHierarchyNavigator 查找目标输入框
+    auto targetInput = ViewHierarchyNavigator::setFocusTo(direction, currentFocus);
+    if (targetInput) {
+        DLOG(INFO) << "setFocusTo: found target, requesting focus, tag=" << targetInput->getTag();
+        // 获取 ArkUI_NodeHandle 并请求焦点
+        ArkUINode& node = targetInput->getLocalRootArkUINode();
+        ArkUI_NodeHandle nodeHandle = node.getArkUINodeHandle();
+        ArkUI_ErrorCode result = ARKUI_ERROR_CODE_NO_ERROR;
+        high_lib_handle = dlopen("libace_ndk.z.so", RTLD_LAZY);
+        if (high_lib_handle == NULL) {
+            DLOG(INFO) << "libace_ndk.z.so not existed";
+        } else {
+            focusRequestMethod = (ArkUI_ErrorCode(*)(ArkUI_NodeHandle node))dlsym(high_lib_handle, "OH_ArkUI_FocusRequest");
+            bool isFocusRequestMethodExisted = focusRequestMethod != NULL;
+            if (isFocusRequestMethodExisted) {
+                DLOG(INFO) << "OH_ArkUI_FocusRequest method existed";
+                result = focusRequestMethod(nodeHandle);
+            } else {
+                DLOG(INFO) << "OH_ArkUI_FocusRequest method not existed";
+            }
+            dlclose(high_lib_handle);
+        }
+        if (!(result == ARKUI_ERROR_CODE_NO_ERROR)) {
+            DLOG(WARNING) << "setFocusTo: focus request failed with error code: " << result;
+        }
+    } else {
+        DLOG(INFO) << "setFocusTo: no target input found in direction " << direction;
+    }
+    this->textInputVector.clear();
+}
+
+TextInputComponentInstance::Shared KeyboardControllerViewComponentInstance::findFocusedTextInput() {
+    std::function<TextInputComponentInstance::Shared(ComponentInstance::Shared)> findFocused;
+    findFocused = [&](ComponentInstance::Shared component) -> TextInputComponentInstance::Shared {
+        if (!component) {
+            return nullptr;
+        }
+        if (auto input = std::dynamic_pointer_cast<TextInputComponentInstance>(component)) {
+            if (input->getLocalRootArkUINode().isFocused()) {
+                return input;
+            }
+        }
+        for (const auto &child : component->getChildren()) {
+            if (auto input = findFocused(child)) {
+                return input;
+            }
+        }
+        return nullptr;
+    };
+    return findFocused(this->shared_from_this());
+}
+
+int KeyboardControllerViewComponentInstance::findParentScrollViewTarget(ComponentInstance::Shared const &input) {
+    auto parent = input->getParent().lock();
+    while (parent != nullptr) {
+        if (parent->getComponentName().find("ScrollView") != std::string::npos) {
+            return static_cast<int>(parent->getTag());
+        }
+        parent = parent->getParent().lock();
+    }
+    return -1;
+}
+
+double KeyboardControllerViewComponentInstance::pxToVp(double px) const {
+    auto pointScaleFactor = this->getLayoutMetrics().pointScaleFactor;
+    return pointScaleFactor == 0.0 ? px : px / pointScaleFactor;
+}
+
+void KeyboardControllerViewComponentInstance::textSelectionEventReceiver(ArkUI_NodeEvent *event) {
+    if (event == nullptr) {
+        return;
+    }
+    auto eventType = OH_ArkUI_NodeEvent_GetEventType(event);
+    auto handle = OH_ArkUI_NodeEvent_GetNodeHandle(event);
+    auto observerIt = g_inputObservers.find(handle);
+    if (observerIt == g_inputObservers.end()) {
+        return;
+    }
+    auto input = observerIt->second.input.lock();
+    if (!input) {
+        return;
+    }
+    auto instances = observerIt->second.lockInstances();
+    instances.erase(
+        std::remove_if(
+            instances.begin(),
+            instances.end(),
+            [](auto const &instance) { return !instance->enabled; }),
+        instances.end());
+
+    if (eventType == NODE_EVENT_ON_AREA_CHANGE &&
+        OH_ArkUI_NodeEvent_GetTargetId(event) == KBC_FOCUSED_INPUT_AREA_CHANGE_TARGET_ID) {
+        for (auto const &instance : instances) {
+            if (instance->m_observedFocusedInputHandle == handle) {
+                instance->syncUpLayout(input);
+            }
+        }
+        return;
+    }
+    if (eventType == NODE_ON_BLUR) {
+        for (auto const &instance : instances) {
+            if (instance->m_observedFocusedInputHandle == nullptr ||
+                instance->m_observedFocusedInputHandle == handle) {
+                instance->onBlur();
+            }
+        }
+        return;
+    }
+    if (eventType == NODE_ON_FOCUS) {
+        for (auto const &instance : instances) {
+            instance->postFocusedInputChanged();
+            instance->focusDidSet();
+            instance->syncUpLayout(input);
+        }
+        return;
+    }
+
+    const auto *focusStatus = NativeNodeApi::getInstance()->getAttribute(handle, NODE_FOCUS_STATUS);
+    if (focusStatus == nullptr || focusStatus->value == nullptr ||
+        focusStatus->size < 1 || focusStatus->value[0].i32 == 0) {
+        return;
+    }
+
+    if (eventType == NODE_TEXT_INPUT_ON_CHANGE ||
+        eventType == NODE_TEXT_INPUT_ON_CHANGE_WITH_PREVIEW_TEXT ||
+        eventType == NODE_TEXT_AREA_ON_CHANGE ||
+        eventType == NODE_TEXT_AREA_ON_CHANGE_WITH_PREVIEW_TEXT) {
+        auto textAttribute = eventType == NODE_TEXT_INPUT_ON_CHANGE ||
+                eventType == NODE_TEXT_INPUT_ON_CHANGE_WITH_PREVIEW_TEXT
+            ? NODE_TEXT_INPUT_TEXT
+            : NODE_TEXT_AREA_TEXT;
+        const auto *text = NativeNodeApi::getInstance()->getAttribute(handle, textAttribute);
+        if (text != nullptr && text->string != nullptr) {
+            for (auto const &instance : instances) {
+                instance->onChange(std::string(text->string), input);
+            }
+        }
+        return;
+    }
+
+    if (eventType != NODE_TEXT_INPUT_ON_TEXT_SELECTION_CHANGE &&
+        eventType != NODE_TEXT_AREA_ON_TEXT_SELECTION_CHANGE) {
+        return;
+    }
+    auto componentEvent = OH_ArkUI_NodeEvent_GetNodeComponentEvent(event);
+    if (componentEvent == nullptr) {
+        return;
+    }
+    for (auto const &instance : instances) {
+        instance->syncUpLayout(input);
+        instance->dispatchSelectionToJS(
+            static_cast<int>(input->getTag()),
+            componentEvent->data[0].i32,
+            componentEvent->data[1].i32);
+    }
+}
+
+void KeyboardControllerViewComponentInstance::clearFocusedInputLayoutObserver() {
+    m_observedFocusedInputHandle = nullptr;
+}
+
+void KeyboardControllerViewComponentInstance::updateFocusedInputLayoutObserver(
+    TextInputComponentInstance::Shared const &focusedInput) {
+    ArkUI_NodeHandle handle = focusedInput
+        ? focusedInput->getLocalRootArkUINode().getArkUINodeHandle()
+        : nullptr;
+    if (handle == m_observedFocusedInputHandle) {
+        return;
+    }
+    clearFocusedInputLayoutObserver();
+    if (handle == nullptr) {
+        return;
+    }
+    auto observerIt = g_inputObservers.find(handle);
+    if (observerIt == g_inputObservers.end()) {
+        findTextInputComponents(focusedInput);
+        observerIt = g_inputObservers.find(handle);
+    }
+    if (observerIt == g_inputObservers.end()) {
+        return;
+    }
+    auto *nodeApi = NativeNodeApi::getInstance();
+    auto registerRet = observerIt->second.areaEventRegistered
+        ? ARKUI_ERROR_CODE_NO_ERROR
+        : nodeApi->registerNodeEvent(
+              handle, NODE_EVENT_ON_AREA_CHANGE, KBC_FOCUSED_INPUT_AREA_CHANGE_TARGET_ID, nullptr);
+    if (registerRet != ARKUI_ERROR_CODE_NO_ERROR) {
+        return;
+    }
+    observerIt->second.areaEventRegistered = true;
+    m_observedFocusedInputHandle = handle;
+}
+
+void KeyboardControllerViewComponentInstance::syncUpLayout() {
+    auto focusedInput = findFocusedTextInput();
+    syncUpLayout(focusedInput);
+}
+
+void KeyboardControllerViewComponentInstance::syncUpLayout(
+    TextInputComponentInstance::Shared const &focusedInput) {
+    if (!focusedInput) {
+        clearFocusedInputLayoutObserver();
+        return;
+    }
+    updateFocusedInputLayoutObserver(focusedInput);
+    ArkUI_NodeHandle handle = focusedInput->getLocalRootArkUINode().getArkUINodeHandle();
+    ArkUI_IntOffset windowOffset{};
+    ArkUI_IntOffset localOffset{};
+    ArkUI_IntSize size{};
+    if (handle == nullptr ||
+        OH_ArkUI_NodeUtils_GetLayoutPositionInWindow(handle, &windowOffset) != ARKUI_ERROR_CODE_NO_ERROR ||
+        OH_ArkUI_NodeUtils_GetLayoutPosition(handle, &localOffset) != ARKUI_ERROR_CODE_NO_ERROR ||
+        OH_ArkUI_NodeUtils_GetLayoutSize(handle, &size) != ARKUI_ERROR_CODE_NO_ERROR) {
+        return;
+    }
+    FocusedInputLayoutData event;
+    event.absoluteX = pxToVp(windowOffset.x);
+    event.absoluteY = pxToVp(windowOffset.y);
+    event.x = pxToVp(localOffset.x);
+    event.y = pxToVp(localOffset.y);
+    event.width = pxToVp(size.width);
+    event.height = pxToVp(size.height);
+    event.target = static_cast<int>(focusedInput->getTag());
+    event.parentScrollViewTarget = findParentScrollViewTarget(focusedInput);
+    dispatchLayoutToJS(event);
+    dispatchKeyboardFocusChangedIfNeeded(focusedInput);
+}
+
+void KeyboardControllerViewComponentInstance::dispatchLayoutToJS(FocusedInputLayoutData const &event) {
+    if (event == m_lastLayoutEvent) {
+        return;
+    }
+    m_lastLayoutEvent = event;
+    if (!m_eventEmitter || !this->enabled) {
+        return;
+    }
+    facebook::react::KeyboardControllerViewEventEmitter::InputLayoutEvent payload = {};
+    payload.target = event.target;
+    payload.parentScrollViewTarget = event.parentScrollViewTarget;
+    payload.layout.absoluteX = event.absoluteX;
+    payload.layout.absoluteY = event.absoluteY;
+    payload.layout.x = event.x;
+    payload.layout.y = event.y;
+    payload.layout.width = event.width;
+    payload.layout.height = event.height;
+    m_eventEmitter->onFocusedInputLayoutChanged(payload);
+}
+
+void KeyboardControllerViewComponentInstance::dispatchKeyboardFocusChangedIfNeeded(
+    TextInputComponentInstance::Shared const &focusedInput) {
+    if (m_isHandlingKeyboardHeightChange) {
+        return;
+    }
+
+    if (!this->enabled || !m_eventEmitter || this->keyboardHeight <= 0) {
+        return;
+    }
+    int target = static_cast<int>(focusedInput->getTag());
+    if (m_lastKeyboardEventTarget == -1 || target == m_lastKeyboardEventTarget) {
+        return;
+    }
+    cancelKeyboardAnimation();
+    facebook::react::KeyboardControllerViewEventEmitter::MoveEvent event = {
+        this->keyboardHeight, 1.0, 0, target};
+    m_lastKeyboardEventTarget = target;
+    m_eventEmitter->onKeyboardMoveStart(event);
+    m_eventEmitter->onKeyboardMoveEnd(event);
+}
+
+void KeyboardControllerViewComponentInstance::postFocusedInputChanged() {
+    auto focusedInput = findFocusedTextInput();
+    int target = -1;
+    std::string type = "default";
+    if (focusedInput) {
+        target = static_cast<int>(focusedInput->getTag());
+        auto props = std::dynamic_pointer_cast<const facebook::react::TextInputProps>(focusedInput->getProps());
+        if (props) {
+            type = keyboardTypeToString(props->traits.keyboardType);
+        }
+    }
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr) {
+        folly::dynamic payload = folly::dynamic::object("target", target)("type", type);
+        rnInstancePtr->postMessageToArkTS("focusedInputChanged", std::move(payload));
+    }
+}
+} // namespace rnoh