@react-native-ohos/react-native-keyboard-controller 1.16.6-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Kiryl Ziusko
+
+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.

package/README.OpenSource

@@ -0,0 +1,11 @@
+[
+    {
+        "Name": "react-native-keyboard-controller",
+        "License": "MIT License",
+        "License File": "https://github.com/kirillzyusko/react-native-keyboard-controller/blob/main/LICENSE",
+        "Version Number": "1.16.5",
+        "Owner" : "xiafeng@huawei.com",
+        "Upstream URL": "https://github.com/kirillzyusko/react-native-keyboard-controller",
+        "Description": "Keyboard manager which works in identical way on  iOS and Android and harmony"
+    }
+]

package/README.md

@@ -0,0 +1,19 @@
+# @react-native-ohos/react-native-keyboard-controller
+
+本项目基于 [react-native-keyboard-controller (原库NPM包名)](https://github.com/kirillzyusko/react-native-keyboard-controller)
+
+## 文档地址 / Documentation URL 
+
+[中文 / Chinese](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-cn/react-native-keyboard-controller.md)
+
+[英文 / English](https://gitee.com/react-native-oh-library/usage-docs/blob/master/en/react-native-keyboard-controller.md)
+
+## Codegen
+
+该库已接入 codegen，具体请查阅文档。
+
+The library has been integrated with codegen. Please refer to the documentation for details.
+
+## 请悉知 / Acknowledgements
+
+本项目基于 [The MIT License (MIT)](https://github.com/kirillzyusko/react-native-keyboard-controller/blob/main/LICENSE) ，请自由地享受和参与开源。

package/harmony/keyboard_controller/BuildProfile.ets

@@ -0,0 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '1.16.6-rc.1';
+export const BUILD_MODE_NAME = 'debug';
+export const DEBUG = true;
+export const TARGET_NAME = 'default';
+
+/**
+ * BuildProfile Class is used only for compatibility purposes.
+ */
+export default class BuildProfile { 
+	static readonly HAR_VERSION = HAR_VERSION;
+	static readonly BUILD_MODE_NAME = BUILD_MODE_NAME;
+	static readonly DEBUG = DEBUG;
+	static readonly TARGET_NAME = TARGET_NAME;
+}

package/harmony/keyboard_controller/Index.ets

@@ -0,0 +1,7 @@
+/*
+ * 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.
+ */
+
+export * from './ts';

package/harmony/keyboard_controller/ResourceTable.txt

@@ -0,0 +1 @@
+string page_show 0x03000000

package/harmony/keyboard_controller/build-profile.json5

@@ -0,0 +1,31 @@
+{
+  "apiType": "stageMode",
+  "buildOption": {
+  },
+  "buildOptionSet": [
+    {
+      "name": "release",
+      "arkOptions": {
+        "obfuscation": {
+          "ruleOptions": {
+            "enable": true,
+            "files": [
+              "./obfuscation-rules.txt"
+            ]
+          },
+          "consumerFiles": [
+            "./consumer-rules.txt"
+          ]
+        }
+      },
+    },
+  ],
+  "targets": [
+    {
+      "name": "default"
+    },
+    {
+      "name": "ohosTest"
+    }
+  ]
+}

package/harmony/keyboard_controller/hvigorfile.ts

@@ -0,0 +1,6 @@
+import { harTasks } from '@ohos/hvigor-ohos-plugin';
+
+export default {
+    system: harTasks,  /* Built-in plugin of Hvigor. It cannot be modified. */
+    plugins:[]         /* Custom plugin to extend the functionality of Hvigor. */
+}

package/harmony/keyboard_controller/obfuscation-rules.txt

@@ -0,0 +1,18 @@
+# Define project specific obfuscation rules here.
+# You can include the obfuscation configuration files in the current module's build-profile.json5.
+#
+# For more details, see
+#   https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V5/source-obfuscation-V5
+
+# Obfuscation options:
+# -disable-obfuscation: disable all obfuscations
+# -enable-property-obfuscation: obfuscate the property names
+# -enable-toplevel-obfuscation: obfuscate the names in the global scope
+# -compact: remove unnecessary blank spaces and all line feeds
+# -remove-log: remove all console.* statements
+# -print-namecache: print the name cache that contains the mapping from the old names to new names
+# -apply-namecache: reuse the given cache file
+
+# Keep options:
+# -keep-property-name: specifies property names that you want to keep
+# -keep-global-name: specifies names that you want to keep in the global scope

package/harmony/keyboard_controller/oh-package.json5

@@ -0,0 +1,11 @@
+{
+  "name": "@react-native-ohos/react-native-keyboard-controller",
+  "version": "1.16.6-rc.1",
+  "description": " control keyboard show or hide",
+  "main": "Index.ets",
+  "author": "",
+  "license": "MIT License",
+  "dependencies": {
+    "@rnoh/react-native-openharmony": "file:../react_native_openharmony",
+  }
+}

package/harmony/keyboard_controller/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB rnoh_keyboard_controller_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_keyboard_controller SHARED ${rnoh_keyboard_controller_SRC})
+target_include_directories(rnoh_keyboard_controller PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(rnoh_keyboard_controller PUBLIC rnoh)

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

@@ -0,0 +1,96 @@
+/*
+ * 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 <glog/logging.h>
+#include "EventEmitters.h"
+
+namespace facebook {
+namespace react {
+
+void KeyboardControllerViewEventEmitter::onKeyboardMoveStart(MoveEvent event) const {
+    dispatchEvent("KeyboardMoveStart", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "height", event.height);
+        payload.setProperty(runtime, "target", event.target);
+        payload.setProperty(runtime, "duration", event.duration);
+        payload.setProperty(runtime, "progress", event.progress);
+        return payload;
+    });
+}
+
+void KeyboardControllerViewEventEmitter::onKeyboardMove(MoveEvent event) const {
+    dispatchEvent("KeyboardMove", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "height", event.height);
+        payload.setProperty(runtime, "target", event.target);
+        payload.setProperty(runtime, "duration", event.duration);
+        payload.setProperty(runtime, "progress", event.progress);
+        return payload;
+    });
+}
+void KeyboardControllerViewEventEmitter::onKeyboardMoveEnd(MoveEvent event) const {
+    dispatchEvent("KeyboardMoveEnd", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "height", event.height);
+        payload.setProperty(runtime, "target", event.target);
+        payload.setProperty(runtime, "duration", event.duration);
+        payload.setProperty(runtime, "progress", event.progress);
+        return payload;
+    });
+}
+void KeyboardControllerViewEventEmitter::onKeyboardMoveInteractive(MoveEvent event) const {
+    dispatchEvent("KeyboardMoveInteractive", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "height", event.height);
+        payload.setProperty(runtime, "target", event.target);
+        payload.setProperty(runtime, "duration", event.duration);
+        payload.setProperty(runtime, "progress", event.progress);
+        return payload;
+    });
+}
+void KeyboardControllerViewEventEmitter::onFocusedInputLayoutChanged(InputLayoutEvent event) const {
+    dispatchEvent("FocusedInputLayoutChanged", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        return payload;
+    });
+}
+void KeyboardControllerViewEventEmitter::onFocusedInputTextChanged(TextChangeEvent event) const {
+    dispatchEvent("FocusedInputTextChanged", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "text", event.text);
+        return payload;
+    });
+}
+void KeyboardControllerViewEventEmitter::onFocusedInputSelectionChanged(InputSectionEvent event) const {
+    dispatchEvent("FocusedInputSelectionChanged", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        return payload;
+    });
+}
+
+} // namespace react
+} // namespace facebook

package/harmony/keyboard_controller/src/main/cpp/EventEmitters.h

@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+
+#ifndef TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_EVENTEMITTERS_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_EVENTEMITTERS_H
+
+#ifndef EVENTEMITTERS_H
+#define EVENTEMITTERS_H
+
+#pragma once
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+class JSI_EXPORT KeyboardController : public EventEmitter {
+public:
+    using EventEmitter::EventEmitter;
+    struct KeyboardEvent {
+        double height;
+        float duration;
+        double timestamp;
+        int target;
+    };
+    void keyboardWillShow(KeyboardEvent value) const;
+    void keyboardDidShow(KeyboardEvent value) const;
+    void keyboardWillHide(KeyboardEvent value) const;
+    void keyboardDidHide(KeyboardEvent value) const;
+    void focusDidSet(KeyboardEvent value) const;
+};
+class JSI_EXPORT KeyboardControllerViewEventEmitter : public ViewEventEmitter {
+public:
+    using ViewEventEmitter::ViewEventEmitter;
+
+    struct MoveEvent {
+        double height;
+        double progress;
+        float duration;
+        int target;
+    };
+
+    struct InputLayoutEvent {
+        int parentScrollViewTarget;
+        int target;
+        struct layout {
+            double absoluteX;
+            double absoluteY;
+            double x;
+            double y;
+            double width;
+            double height;
+        };
+    };
+    struct TextChangeEvent {
+        std::string text;
+    };
+    struct InputSectionEvent {
+        int target;
+        struct selection {
+            struct start {
+                double x;
+                double y;
+                int position;
+            };
+            struct end {
+                double x;
+                double y;
+                int position;
+            };
+        };
+    };
+
+    void onKeyboardMoveStart(MoveEvent value) const;
+    void onKeyboardMove(MoveEvent value) const;
+    void onKeyboardMoveEnd(MoveEvent value) const;
+    void onKeyboardMoveInteractive(MoveEvent value) const;
+    void onFocusedInputLayoutChanged(InputLayoutEvent value) const;
+    void onFocusedInputTextChanged(TextChangeEvent value) const;
+    void onFocusedInputSelectionChanged(InputSectionEvent value) const;
+};
+} // namespace react
+} // namespace facebook
+
+#endif
+
+#endif

package/harmony/keyboard_controller/src/main/cpp/KeyboardControllerViewComponentDescriptor.h

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+ 
+#ifndef TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERVIEWCOMPONENTDESCRIPTOR_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERVIEWCOMPONENTDESCRIPTOR_H
+
+#ifndef KEYBOARDCONTROLLERVIEWCOMPONENTDESCRIPTOR_H
+#define KEYBOARDCONTROLLERVIEWCOMPONENTDESCRIPTOR_H
+
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
+ */
+
+/**
+ * This code was generated by "react-native codegen-harmony"
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be
+ * lost once the code is regenerated.
+ *
+ * @generatorVersion: 1
+ */
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewShadowNode.h>
+#include <react/renderer/core/propsConversions.h>
+#include "EventEmitters.h"
+
+namespace facebook {
+namespace react {
+
+inline const char KeyboardControllerViewName[] = "RNKeyboardControllerView";
+
+class KeyboardControllerViewProps : public ViewProps {
+public:
+    bool enabled;
+    bool statusBarTranslucent;
+    bool navigationBarTranslucent;
+    bool preserveEdgeToEdge;
+    KeyboardControllerViewProps() = default;
+
+    KeyboardControllerViewProps(const PropsParserContext &context, const KeyboardControllerViewProps &sourceProps,
+                                const RawProps &rawProps)
+        : ViewProps(context, sourceProps, rawProps),
+          enabled(convertRawProp(context, rawProps, "enabled", sourceProps.enabled, {false})),
+          statusBarTranslucent(convertRawProp(context, rawProps, "statusBarTranslucent",
+                                                    sourceProps.statusBarTranslucent, {false})),
+          navigationBarTranslucent(convertRawProp(context, rawProps, "navigationBarTranslucent",
+                                                        sourceProps.navigationBarTranslucent, {false})),
+          preserveEdgeToEdge(convertRawProp(context, rawProps, "preserveEdgeToEdge", sourceProps.preserveEdgeToEdge, {true})){}
+};
+
+using KeyboardControllerViewShadowNode =
+    ConcreteViewShadowNode<KeyboardControllerViewName, KeyboardControllerViewProps, KeyboardControllerViewEventEmitter>;
+
+class KeyboardControllerViewComponentDescriptor final
+    : public ConcreteComponentDescriptor<KeyboardControllerViewShadowNode> {
+public:
+    KeyboardControllerViewComponentDescriptor(ComponentDescriptorParameters const &parameters)
+        : ConcreteComponentDescriptor(parameters) {}
+};
+
+
+} // namespace react
+} // namespace facebook
+
+#endif
+
+#endif

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

@@ -0,0 +1,172 @@
+/*
+ * 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 <folly/dynamic.h>
+#include <iostream>
+
+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 << props->preserveEdgeToEdge;
+    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();
+    }
+    if (this->preserveEdgeToEdge != props->preserveEdgeToEdge) {
+        this->preserveEdgeToEdge = props->preserveEdgeToEdge;
+        this->setWindowLayoutFullScreen();
+    }
+}
+
+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;
+        }
+        if (height == 0) {
+            this->keyboardStatus = KeyboardControllerStatus::HIDE;
+        }
+        this->keyboardHeightChangeHandle();
+    }
+    if (message.name == "setFocusTo") {
+        // to do
+    }
+}
+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);
+        }
+    }
+}
+
+void KeyboardControllerViewComponentInstance::setWindowLayoutFullScreen() {
+    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("setWindowLayoutFullScreen", {this->preserveEdgeToEdge});
+    }
+}
+
+/**
+ * 遍历查找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::onTextSelectionChange(int32_t location, int32_t length) {
+    DLOG(INFO) << " onKeyboardControllerView onTextSelectionChange";
+    // to do
+};
+void KeyboardControllerViewComponentInstance::onFocus() { DLOG(INFO) << " onKeyboardControllerView onFocus"; }
+void KeyboardControllerViewComponentInstance::onBlur() { DLOG(INFO) << " onKeyboardControllerView onBlur"; }
+
+
+} // namespace rnoh