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

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

@@ -0,0 +1,76 @@
+/*
+ * 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 KEYBOARDCONTROLLERVIEWCOMPONENTINSTANCE_H
+#define KEYBOARDCONTROLLERVIEWCOMPONENTINSTANCE_H
+
+#ifndef TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERVIEWCOMPONENTINSTANCE_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERVIEWCOMPONENTINSTANCE_H
+
+#include <any>
+#include "RNOH/CppComponentInstance.h"
+#include "KeyboardControllerViewComponentDescriptor.h"
+#include "RNOHCorePackage/ComponentInstances/TextInputComponentInstance.h"
+#include "RNOH/arkui/CustomNode.h"
+#include "RNOH/ArkTSMessageHub.h"
+#include "RNOH/arkui/TextInputNode.h"
+#include "RNOH/arkui/TextAreaNode.h"
+
+namespace rnoh {
+enum KeyboardControllerStatus { HIDE = 0, SHOW = 1 };
+class KeyboardControllerViewComponentInstance
+    : public CppComponentInstance<facebook::react::KeyboardControllerViewShadowNode>,
+      public CustomNodeDelegate,
+      public TextAreaNodeDelegate,
+      public TextInputNodeDelegate,
+      public ArkTSMessageHub::Observer {
+public:
+    KeyboardControllerViewComponentInstance(Context context);
+    void onKeyboardMoveStart();
+    void onKeyboardMove();
+    void onKeyboardMoveEnd();
+    void onKeyboardMoveInteractive();
+    void onFocusedInputLayoutChanged();
+    void onFocusedInputTextChanged();
+    void onFocusedInputSelectionChanged();
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+    void onPropsChanged(SharedConcreteProps const &props) override;
+    void onCommandReceived(std::string const &commandName, folly::dynamic const &args) override;
+    void onMessageReceived(ArkTSMessage const &message) override;
+    ArkUINode &getLocalRootArkUINode() override;
+    void onClick() override;
+    // textArea textInput delegate
+    void onChange(std::string text) override;
+    void onBlur() override;
+    void onFocus() override;
+    void onTextSelectionChange(int32_t location, int32_t length) override;
+
+protected:
+private:
+    bool enabled;
+    bool statusBarTranslucent;
+    bool navigationBarTranslucent;
+    bool preserveEdgeToEdge = true;
+    double keyboardHeight;
+    std::map<std::string, std::any> dictionary;
+    int keyboardStatus;
+    std::vector<TextInputComponentInstance::Shared> textInputVector{};
+    CustomNode m_customNode{};
+    ComponentInstance::Shared currentResponder;
+    void findTextInputComponents(ComponentInstance::Shared const &parentComponentInstance);
+    void setWindowSystemBarEnable();
+    void startKeyboardObserver();
+    void closeKeyboardObserver();
+    void keyboardHeightChangeHandle();
+    void setWindowLayoutFullScreen();
+};
+} // namespace rnoh
+
+#endif
+
+#endif

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

@@ -0,0 +1,44 @@
+/*
+ * 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_KEYBOARDCONTROLLERVIEWJSIBINDER_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERVIEWJSIBINDER_H
+
+#pragma once
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+namespace rnoh {
+class KeyboardControllerViewJSIBinder : public ViewComponentJSIBinder {
+protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "enabled", "bool");
+        object.setProperty(rt, "statusBarTranslucent", "bool");
+        object.setProperty(rt, "navigationBarTranslucent", "bool");
+        object.setProperty(rt, "preserveEdgeToEdge", "bool");
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topKeyboardMoveStart", createDirectEvent(rt, "onKeyboardMoveStart"));
+        events.setProperty(rt, "topKeyboardMove", createDirectEvent(rt, "onKeyboardMove"));
+        events.setProperty(rt, "topKeyboardMoveEnd", createDirectEvent(rt, "onKeyboardMoveEnd"));
+        events.setProperty(rt, "topKeyboardMoveInteractive", createDirectEvent(rt, "onKeyboardMoveInteractive"));
+        events.setProperty(rt, "topFocusedInputLayoutChanged", createDirectEvent(rt, "onFocusedInputLayoutChanged"));
+        events.setProperty(rt, "topFocusedInputTextChanged", createDirectEvent(rt, "onFocusedInputTextChanged"));
+        events.setProperty(rt, "topFocusedInputSelectionChanged",
+                           createDirectEvent(rt, "onFocusedInputSelectionChanged"));
+        return events;
+    }
+};
+} // namespace rnoh
+
+#endif

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

@@ -0,0 +1,58 @@
+/*
+ * 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_KEYBOARDGESTUREAREACOMPONENTDESCRIPTOR_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDGESTUREAREACOMPONENTDESCRIPTOR_H
+
+#ifndef KEYBOARDGESTUREAREACOMPONENTDESCRIPTOR_H
+#define KEYBOARDGESTUREAREACOMPONENTDESCRIPTOR_H
+
+
+#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 KeyboardGestureAreaComponentName[] = "RNKeyboardGestureArea";
+
+class KeyboardGestureAreaProps : public ViewProps {
+public:
+    bool showOnSwipeUp;
+    bool enableSwipeToDismiss;
+    std::string interpolator;
+    KeyboardGestureAreaProps() = default;
+
+    KeyboardGestureAreaProps(const PropsParserContext &context, const KeyboardGestureAreaProps &sourceProps,
+                             const RawProps &rawProps)
+        : ViewProps(context, sourceProps, rawProps),
+          showOnSwipeUp(convertRawProp(context, rawProps, "showOnSwipeUp", sourceProps.showOnSwipeUp, {false})),
+          enableSwipeToDismiss(convertRawProp(context, rawProps, "enableSwipeToDismiss",
+                                                    sourceProps.enableSwipeToDismiss, {false})),
+          interpolator(convertRawProp(context, rawProps, "interpolator", sourceProps.interpolator, {"linear"})) {}
+};
+
+using KeyboardGestureAreaShadowNode =
+    ConcreteViewShadowNode<KeyboardGestureAreaComponentName, KeyboardGestureAreaProps, ViewEventEmitter>;
+
+class KeyboardGestureAreaComponentDescriptor final : public ConcreteComponentDescriptor<KeyboardGestureAreaShadowNode> {
+public:
+    KeyboardGestureAreaComponentDescriptor(ComponentDescriptorParameters const &parameters)
+        : ConcreteComponentDescriptor(parameters) {}
+};
+
+} // namespace react
+} // namespace facebook
+
+#endif
+
+#endif

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

@@ -0,0 +1,87 @@
+/*
+ * 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 "KeyboardGestureAreaComponentInstance.h"
+#include <folly/dynamic.h>
+
+
+namespace rnoh {
+KeyboardGestureAreaComponentInstance::KeyboardGestureAreaComponentInstance(Context context)
+    : CppComponentInstance(std::move(context)) {
+    DLOG(INFO) << "KeyboardGestureAreaComponentInstance";
+    ArkUINodeRegistry::getInstance().registerTouchHandler(&m_stackNode, this);
+}
+void KeyboardGestureAreaComponentInstance::onTouchEvent(ArkUI_UIInputEvent *e) {
+    auto action = OH_ArkUI_UIInputEvent_GetAction(e);
+    DLOG(INFO) << "KeyboardGestureAreaComponentInstance onTouchEvent" << action;
+    if (action == UI_TOUCH_EVENT_ACTION_DOWN) {
+        this->swipeToDismiss();
+    }
+    if (action == UI_TOUCH_EVENT_ACTION_UP) {
+        this->swipeToUp();
+    }
+}
+void KeyboardGestureAreaComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                           std::size_t index) {
+    CppComponentInstance::onChildInserted(childComponentInstance, index);
+    m_stackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index + 1);
+}
+
+void KeyboardGestureAreaComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    CppComponentInstance::onChildRemoved(childComponentInstance);
+    m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+}
+ArkUINode &KeyboardGestureAreaComponentInstance::getLocalRootArkUINode() { return m_stackNode; }
+void KeyboardGestureAreaComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    DLOG(INFO) << "###onPropsChanged";
+    CppComponentInstance::onPropsChanged(props);
+    this->showOnSwipeUp = props->showOnSwipeUp;
+    this->enableSwipeToDismiss = props->enableSwipeToDismiss;
+    this->interpolator = props->interpolator;
+}
+
+void KeyboardGestureAreaComponentInstance::onCommandReceived(std::string const &commandName,
+                                                             folly::dynamic const &args) {
+    CppComponentInstance::onCommandReceived(commandName, args);
+}
+
+void KeyboardGestureAreaComponentInstance::handleTouchEvent(ArkUI_UIInputEvent *e) {
+    auto action = OH_ArkUI_UIInputEvent_GetAction(e);
+    if (action == UI_TOUCH_EVENT_ACTION_DOWN) {
+        this->swipeToDismiss();
+    }
+    if (action == UI_TOUCH_EVENT_ACTION_UP) {
+        this->swipeToUp();
+    }
+}
+void KeyboardGestureAreaComponentInstance::swipeToDismiss() {
+    if (!this->enableSwipeToDismiss) {
+        return;
+    }
+    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("dismiss", {false});
+    }
+}
+void KeyboardGestureAreaComponentInstance::swipeToUp() {
+    if (!this->showOnSwipeUp) {
+        return;
+    }
+    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("show", {});
+    }
+}
+void KeyboardGestureAreaComponentInstance::executeInterpolator() {
+    // to do
+}
+
+} // namespace rnoh
+// namespace rnoh

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

@@ -0,0 +1,62 @@
+/*
+ * 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 KEYBOARDGESTUREAREACOMPONENTINSTANCE_H
+#define KEYBOARDGESTUREAREACOMPONENTINSTANCE_H
+
+#ifndef TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDGESTUREAREACOMPONENTINSTANCE_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDGESTUREAREACOMPONENTINSTANCE_H
+
+#include <iostream>
+#include <deque>
+#include  "RNOH/CppComponentInstance.h"
+#include "KeyboardGestureAreaComponentDescriptor.h"
+#include "RNOH/arkui/StackNode.h"
+#include "RNOH/arkui/ArkUINodeRegistry.h"
+namespace rnoh {
+
+class KeyboardGestureAreaComponentInstance
+    : public CppComponentInstance<facebook::react::KeyboardGestureAreaShadowNode>,
+      public TouchEventHandler {
+public:
+    KeyboardGestureAreaComponentInstance(Context context);
+    ~KeyboardGestureAreaComponentInstance()
+    {
+        // Clean-up code here
+        std::cout << "KeyboardGestureAreaComponentInstance destroyed." << std::endl;
+        ArkUINodeRegistry::getInstance().unregisterTouchHandler(&m_stackNode);
+    }
+    void onTouchEvent(ArkUI_UIInputEvent *e) override;
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+    void onPropsChanged(SharedConcreteProps const &props) override;
+    void onCommandReceived(std::string const &commandName, folly::dynamic const &args) override;
+    ArkUINode &getLocalRootArkUINode() override;
+protected:
+private:
+    bool showOnSwipeUp;
+    bool enableSwipeToDismiss;
+    std::string interpolator;
+    double keyboardHeight;
+    size_t maxSize;
+    std::deque<folly::dynamic> buffer;
+    StackNode m_stackNode;
+    struct TouchPoint {
+        facebook::react::Float pointerId;
+        facebook::react::Float windowX;
+        facebook::react::Float windowY;
+    };
+    folly::dynamic convertNodeTouchPointToDynamic(ArkUI_UIInputEvent *e, int32_t index);
+    void swipeToUp();
+    void swipeToDismiss();
+    void executeInterpolator();
+    void handleTouchEvent(ArkUI_UIInputEvent *e);
+};
+} // namespace rnoh
+
+#endif
+
+#endif

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

@@ -0,0 +1,39 @@
+/*
+ * 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_KEYBOARDGESTUREAREAJSIBINDER_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDGESTUREAREAJSIBINDER_H
+
+#pragma once
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class KeyboardGestureAreaJSIBinder : public ViewComponentJSIBinder {
+protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override
+    {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "interpolator", "String");
+        object.setProperty(rt, "showOnSwipeUp", "bool");
+        object.setProperty(rt, "enableSwipeToDismiss", "bool");
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+} // namespace rnoh
+
+#endif

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

@@ -0,0 +1,25 @@
+/*
+ * 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 "RNKeyboardController.h"
+
+namespace rnoh {
+using namespace facebook;
+KeyboardController::KeyboardController(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = {
+        ARK_METHOD_METADATA(getConstants, 0),
+        ARK_METHOD_METADATA(setInputMode, 1),
+        ARK_METHOD_METADATA(setDefaultMode, 0),
+        ARK_METHOD_METADATA(dismiss, 1),
+        ARK_METHOD_METADATA(setFocusTo, 1),
+        ARK_METHOD_METADATA(addListener, 1),
+        ARK_METHOD_METADATA(removeListeners, 1),
+    };
+}
+
+} // namespace rnoh

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

@@ -0,0 +1,27 @@
+/*
+ * 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_RNKEYBOARDCONTROLLER_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_RNKEYBOARDCONTROLLER_H
+
+#ifndef RNKEYBOARDCONTROLLER_H
+#define RNKEYBOARDCONTROLLER_H
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT KeyboardController : public ArkTSTurboModule {
+  public:
+    KeyboardController(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+
+} // namespace rnoh
+
+#endif
+
+#endif

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

@@ -0,0 +1,24 @@
+/*
+ * 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 "RNStatusBarManagerCompat.h"
+
+namespace rnoh {
+using namespace facebook;
+
+StatusBarManagerCompat::StatusBarManagerCompat(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = {
+        ARK_METHOD_METADATA(getConstants, 0),
+        ARK_METHOD_METADATA(setHidden, 1),
+        ARK_METHOD_METADATA(setColor, 2),
+        ARK_METHOD_METADATA(setTranslucent, 1),
+        ARK_METHOD_METADATA(setStyle, 1),
+    };
+}
+
+} // namespace rnoh

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

@@ -0,0 +1,28 @@
+/*
+ * 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_RNSTATUSBARMANAGERCOMPAT_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_RNSTATUSBARMANAGERCOMPAT_H
+
+#ifndef RNSTATUSBARMANAGERCOMPAT_H
+#define RNSTATUSBARMANAGERCOMPAT_H
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT StatusBarManagerCompat : public ArkTSTurboModule {
+  public:
+    StatusBarManagerCompat(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+
+} // namespace rnoh
+
+#endif
+
+#endif

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

@@ -0,0 +1,43 @@
+/*
+ * 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 "keyboardControllerPackage.h"
+#include "KeyboardControllerViewJSIBinder.h"
+#include "KeyboardGestureAreaJSIBinder.h"
+
+
+using namespace facebook;
+using namespace rnoh;
+
+std::vector<facebook::react::ComponentDescriptorProvider>
+KeyboardControllerPackage::createComponentDescriptorProviders() {
+    return {facebook::react::concreteComponentDescriptorProvider<
+                facebook::react::KeyboardControllerViewComponentDescriptor>(),
+            facebook::react::concreteComponentDescriptorProvider<
+                facebook::react::KeyboardGestureAreaComponentDescriptor>()};
+}
+ComponentJSIBinderByString KeyboardControllerPackage::createComponentJSIBinderByName() {
+    return {{"RNKeyboardControllerView", std::make_shared<KeyboardControllerViewJSIBinder>()},
+            {"RNKeyboardGestureArea", std::make_shared<KeyboardGestureAreaJSIBinder>()}};
+}
+
+std::unique_ptr<TurboModuleFactoryDelegate> KeyboardControllerPackage::createTurboModuleFactoryDelegate() {
+    return std::make_unique<KeyboardControllerTurboModuleFactoryDelegate>();
+}
+
+ComponentInstanceFactoryDelegate::Shared KeyboardControllerPackage::createComponentInstanceFactoryDelegate() {
+    return std::make_shared<KeyboardControllerComponentInstanceFactoryDelegate>();
+};
+
+ComponentInstance::Shared KeyboardControllerPackage::createComponentInstance(const ComponentInstance::Context &ctx) {
+    if (ctx.componentName == "RNKeyboardControllerView") {
+        return std::make_shared<KeyboardControllerViewComponentInstance>(ctx);
+    }
+    if (ctx.componentName == "RNKeyboardGestureArea") {
+        return std::make_shared<KeyboardGestureAreaComponentInstance>(ctx);
+    }
+    return nullptr;
+};

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

@@ -0,0 +1,56 @@
+/*
+ * 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_KEYBOARDCONTROLLERPACKAGE_H
+#define TESTER_HARMONY_KEYBOARD_CONTROLLER_SRC_MAIN_CPP_KEYBOARDCONTROLLERPACKAGE_H
+
+#ifndef KEYBOARDCONTROLLERPACKAGE_H
+#define KEYBOARDCONTROLLERPACKAGE_H
+
+#include "KeyboardGestureAreaComponentInstance.h"
+#include "RNOH/Package.h"
+#include "RNKeyboardController.h"
+#include "RNStatusBarManagerCompat.h"
+#include "KeyboardControllerViewComponentInstance.h"
+namespace rnoh {
+ class KeyboardControllerComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
+ public:
+        ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+            if (ctx.componentName == "RNKeyboardControllerView") {
+                return std::make_shared<KeyboardControllerViewComponentInstance>(ctx);
+            }
+         if (ctx.componentName == "RNKeyboardGestureArea") {
+                return std::make_shared<KeyboardGestureAreaComponentInstance>(ctx);
+            }
+            return nullptr;
+        }
+    };
+class KeyboardControllerTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+        if (name == "KeyboardController") {
+            return std::make_shared<KeyboardController>(ctx, name);
+        }
+          if (name == "StatusBarManagerCompat") {
+            return std::make_shared<StatusBarManagerCompat>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+class KeyboardControllerPackage : public Package{
+public:
+    KeyboardControllerPackage(Package::Context ctx) : Package(ctx) {}
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;
+    ComponentJSIBinderByString createComponentJSIBinderByName() override;
+    ComponentInstance::Shared createComponentInstance(const ComponentInstance::Context &ctx) override;
+    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override;
+};
+} // namespace rnoh
+
+#endif
+
+#endif

package/harmony/keyboard_controller/src/main/ets/Logger.ts

@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+import hilog from '@ohos.hilog';
+
+class Logger {
+  private domain: number;
+  private prefix: string;
+  private format: string = '%{public}s, %{public}s';
+  private isDebug: boolean;
+
+  /**
+   * constructor.
+   *
+   * @param Prefix Identifies the log tag.
+   * @param domain Domain Indicates the service domain, which is a hexadecimal integer ranging from 0x0 to 0xFFFFF.
+   */
+  constructor(prefix: string = 'MyApp', domain: number = 0xFF00, isDebug = false) {
+    this.prefix = prefix;
+    this.domain = domain;
+    this.isDebug = isDebug;
+  }
+
+  debug(...args: string[]): void {
+    if(this.isDebug) {
+      hilog.debug(this.domain, this.prefix, this.format, args);
+    }
+  }
+
+  info(...args: string[]): void {
+    hilog.info(this.domain, this.prefix, this.format, args);
+  }
+
+  warn(...args: string[]): void {
+    hilog.warn(this.domain, this.prefix, this.format, args);
+  }
+
+  error(...args: string[]): void {
+    hilog.error(this.domain, this.prefix, this.format, args);
+  }
+}
+
+export default new Logger('KeyboardController', 0xFF00, false)

package/harmony/keyboard_controller/src/main/ets/RNKeyboardControllerPackage.ts

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+import {RNPackage,TurboModulesFactory} from  '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext, } from '@rnoh/react-native-openharmony/ts';
+import {RNKeyboardControllerTurboModule} from  './RNKeyboardControllerTurboModule';
+import {RNStatusBarManagerCompatTurboModule} from './RNStatusBarManagerCompatTurboModule';
+
+class RNKeyboardControllerTurboModuleFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (this.hasTurboModule(name)) {
+      return new RNKeyboardControllerTurboModule(this.ctx);
+    }
+    return null;
+  }
+  hasTurboModule(name: string): boolean {
+    return name === 'KeyboardController';
+  }
+
+}
+class RNStatusBarManagerCompatTurboModuleFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if(this.hasTurboModule(name)){
+      return new RNStatusBarManagerCompatTurboModule(this.ctx);
+    }
+    return null;
+  }
+  hasTurboModule(name: string): boolean {
+    return name === 'StatusBarManagerCompat';
+  }
+}
+
+export  class  RNKeyboardControllerPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+     return new RNKeyboardControllerTurboModuleFactory(ctx);
+  }
+}
+export  class  RNStatusBarManagerCompatPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new RNStatusBarManagerCompatTurboModuleFactory(ctx);
+  }
+}