@react-native-oh-tpl/react-native-gesture-handler 2.12.6-1 → 2.12.9

package/harmony/gesture_handler/src/main/ets/{RNGHRootTouchHandler.ets → RNGHRootTouchHandlerArkTS.ts}

@@ -1,58 +1,60 @@
-import { Tag } from "rnoh"
-import { GestureHandlerRegistry } from "./GestureHandlerRegistry"
-import { GestureHandlerArkUIAdapter } from "./GestureHandlerArkUIAdapter"
-import { ViewRegistry } from "./ViewRegistry"
-import { RNGHLogger } from './RNGHLogger'
-
-
-export class RNGHRootTouchHandler {
-  private adapterByViewTag: Map<number, GestureHandlerArkUIAdapter> = new Map() // TODO: remove an adapter when a view or gesture handler is removed
-  private activeViewTags: number[] = []
-  private viewRegistry: ViewRegistry
-  private gestureHandlerRegistry: GestureHandlerRegistry
-  private logger: RNGHLogger
-  private rootTag: Tag
-
-  constructor(rootTag: Tag, viewRegistry: ViewRegistry, gestureHandlerRegistry: GestureHandlerRegistry, logger: RNGHLogger) {
-    this.rootTag = rootTag
-    this.viewRegistry = viewRegistry
-    this.gestureHandlerRegistry = gestureHandlerRegistry
-    this.logger = logger
-  }
-
-  public handleTouch(e: TouchEvent) {
-    if (e.type === TouchType.Down) {
-      this.activeViewTags = []
-    }
-    for (const changedTouch of e.changedTouches) {
-      const views = this.viewRegistry.getTouchableViewsAt({
-        x: changedTouch.windowX,
-        y: changedTouch.windowY
-      }, this.rootTag)
-      for (const view of views) {
-        for (const handler of this.gestureHandlerRegistry.getGestureHandlersByViewTag(view.getTag())) {
-          this.logger.info(`Found GestureHandler ${handler.getTag()} for view ${view.getTag()}`)
-          if (!this.adapterByViewTag.has(view.getTag()))
-            this.adapterByViewTag.set(view.getTag(), new GestureHandlerArkUIAdapter(handler, view, this.logger.cloneWithPrefix("ArkUIAdapter")))
-          if (!this.activeViewTags.includes(view.getTag())) {
-            const adapter = this.adapterByViewTag.get(view.getTag())
-            if (adapter) {
-              adapter.handleTouch(e)
-            } else {
-              console.warn("RNGH: Couldn't find adapter")
-            }
-          }
-          if (e.type === TouchType.Down) {
-            this.activeViewTags.push(view.getTag())
-          }
-        }
-      }
-      for (const viewTag of this.activeViewTags) {
-        const adapter = this.adapterByViewTag.get(viewTag)
-        if (adapter) {
-          adapter.handleTouch(e)
-        }
-      }
-    }
-  }
+import { Tag } from "@rnoh/react-native-openharmony/ts"
+import { GestureHandlerRegistry } from "./GestureHandlerRegistry"
+import { GestureHandlerArkUIAdapter } from "./GestureHandlerArkUIAdapter"
+import { ViewRegistry } from "./ViewRegistry"
+import { RNGHLogger } from './RNGHLogger'
+import { TouchEvent, TouchType } from "./types"
+
+
+export class RNGHRootTouchHandlerArkTS {
+  private adapterByViewTag: Map<number, GestureHandlerArkUIAdapter> = new Map() // TODO: remove an adapter when a view or gesture handler is removed
+  private activeViewTags: number[] = []
+  private viewRegistry: ViewRegistry
+  private gestureHandlerRegistry: GestureHandlerRegistry
+  private logger: RNGHLogger
+  private rootTag: Tag
+
+  constructor(rootTag: Tag, viewRegistry: ViewRegistry, gestureHandlerRegistry: GestureHandlerRegistry, logger: RNGHLogger) {
+    this.rootTag = rootTag
+    this.viewRegistry = viewRegistry
+    this.gestureHandlerRegistry = gestureHandlerRegistry
+    this.logger = logger
+  }
+
+  public handleTouch(touchEvent: any) {
+    const e = touchEvent as TouchEvent
+    if (e.type === TouchType.Down) {
+      this.activeViewTags = []
+    }
+    for (const changedTouch of e.changedTouches) {
+      const views = this.viewRegistry.getTouchableViewsAt({
+        x: changedTouch.windowX,
+        y: changedTouch.windowY
+      }, this.rootTag)
+      for (const view of views) {
+        for (const handler of this.gestureHandlerRegistry.getGestureHandlersByViewTag(view.getTag())) {
+          this.logger.info(`Found GestureHandler ${handler.getTag()} for view ${view.getTag()}`)
+          if (!this.adapterByViewTag.has(view.getTag()))
+            this.adapterByViewTag.set(view.getTag(), new GestureHandlerArkUIAdapter(handler, view, this.logger.cloneWithPrefix("ArkUIAdapter")))
+          if (!this.activeViewTags.includes(view.getTag())) {
+            const adapter = this.adapterByViewTag.get(view.getTag())
+            if (adapter) {
+              adapter.handleTouch(e)
+            } else {
+              console.warn("RNGH: Couldn't find adapter")
+            }
+          }
+          if (e.type === TouchType.Down) {
+            this.activeViewTags.push(view.getTag())
+          }
+        }
+      }
+      for (const viewTag of this.activeViewTags) {
+        const adapter = this.adapterByViewTag.get(viewTag)
+        if (adapter) {
+          adapter.handleTouch(e)
+        }
+      }
+    }
+  }
 }

package/harmony/gesture_handler/src/main/ets/RNGHRootTouchHandlerCAPI.ts

@@ -0,0 +1,87 @@
+import { RNGHRootTouchHandlerArkTS } from "./RNGHRootTouchHandlerArkTS"
+import { TouchEvent as TouchEventArkTS, TouchType, TouchObject } from "./types"
+import { RNGHLogger } from "./RNGHLogger"
+
+type RawTouchPoint = {
+  contactAreaHeight: number
+  contactAreaWidth: number
+  id: number
+  nodeX: number
+  nodeY: number
+  pressedTime: number
+  pressure: number
+  rawX: number
+  rawY: number
+  screenX: number
+  screenY: number
+  tiltX: number
+  tiltY: number
+  toolHeight: number
+  toolType: number
+  toolWidth: number
+  toolX: number
+  toolY: number
+  windowX: number
+  windowY: number
+}
+
+export type RawTouchEvent = {
+  action: number,
+  actionTouch: RawTouchPoint,
+  touchPoints: RawTouchPoint[],
+  sourceType: number,
+  timestamp: number
+}
+
+class TouchEvent {
+  constructor(private raw: RawTouchEvent) {
+  }
+
+  asTouchEventArkTS(): TouchEventArkTS {
+    const touchType = this.touchTypeFromAction(this.raw.action)
+    return {
+      type: this.touchTypeFromAction(this.raw.action),
+      touches: this.raw.touchPoints.map(tp => this.touchObjectFromTouchPoint(tp, touchType)),
+      changedTouches: [this.touchObjectFromTouchPoint(this.raw.actionTouch, touchType)],
+      timestamp: this.raw.timestamp
+    }
+  }
+
+  private touchTypeFromAction(action: number): TouchType {
+    switch (action) {
+      case 1:
+        return TouchType.Down
+      case 2:
+        return TouchType.Move
+      case 3:
+        return TouchType.Up
+      default:
+        return TouchType.Cancel
+    }
+  }
+
+  private touchObjectFromTouchPoint(touchPoint: RawTouchPoint, touchType: TouchType): TouchObject {
+    return {
+      id: touchPoint.id,
+      windowX: touchPoint.windowX,
+      windowY: touchPoint.windowY,
+      x: touchPoint.windowX,
+      y: touchPoint.windowY,
+      type: touchType
+    }
+  }
+}
+
+export class RNGHRootTouchHandlerCAPI {
+  private logger: RNGHLogger
+
+  constructor(logger: RNGHLogger, private touchHandlerArkTS: RNGHRootTouchHandlerArkTS) {
+    this.logger = logger.cloneWithPrefix("RNGHRootTouchHandlerCAPI")
+  }
+
+  handleTouch(rawTouchEvent: RawTouchEvent) {
+    this.logger.cloneWithPrefix("handleTouch").debug(JSON.stringify(rawTouchEvent))
+    this.touchHandlerArkTS.handleTouch(new TouchEvent(rawTouchEvent).asTouchEventArkTS())
+  }
+}
+

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerButton.ets

@@ -1,37 +1,38 @@
-import { Descriptor, RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "rnoh"
-
-export type RNGestureHandlerButtonDescriptor = Descriptor<"RNGestureHandlerButton">
-
-@Component
-export struct RNGestureHandlerButton {
-  static readonly DESCRIPTOR_TYPE = "RNGestureHandlerButton"
-  public ctx!: RNOHContext
-  public tag: number = -1
-  @BuilderParam public buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void
-
-  @State private descriptor: RNGestureHandlerButtonDescriptor = {} as RNGestureHandlerButtonDescriptor
-  private unsubscribes: (() => void)[] = []
-
-  aboutToAppear() {
-    this.handleDescriptorChange(this.ctx.descriptorRegistry.getDescriptor<RNGestureHandlerButtonDescriptor>(this.tag))
-    this.unsubscribes.push(this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag, (d) => {
-      this.handleDescriptorChange(d as RNGestureHandlerButtonDescriptor)
-    }))
-  }
-
-  aboutToDisappear() {
-    this.unsubscribes.forEach(unsubscribe => unsubscribe())
-  }
-
-  handleDescriptorChange(newDescriptor: RNGestureHandlerButtonDescriptor) {
-    this.descriptor = newDescriptor
-  }
-
-  build() {
-    RNViewBase({ ctx: this.ctx, tag: this.tag }) {
-      ForEach(this.descriptor.childrenTags, (childrenTag: Tag) => {
-        RNComponentFactory({ ctx: this.ctx, tag: childrenTag, buildCustomComponent: this.buildCustomComponent })
-      })
-    }
-  }
+import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
+import { RNGestureHandlerButton as RNC } from "./namespace/RNGestureHandlerButton"
+
+export type RNGestureHandlerButtonDescriptor = RNC.Descriptor
+
+@Component
+export struct RNGestureHandlerButton {
+  static readonly NAME = RNC.NAME
+  public ctx!: RNOHContext
+  public tag: number = -1
+  @BuilderParam public buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void
+
+  @State private descriptor: RNGestureHandlerButtonDescriptor = {} as RNGestureHandlerButtonDescriptor
+  private unsubscribes: (() => void)[] = []
+
+  aboutToAppear() {
+    this.handleDescriptorChange(this.ctx.descriptorRegistry.getDescriptor<RNGestureHandlerButtonDescriptor>(this.tag))
+    this.unsubscribes.push(this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag, (d) => {
+      this.handleDescriptorChange(d as RNGestureHandlerButtonDescriptor)
+    }))
+  }
+
+  aboutToDisappear() {
+    this.unsubscribes.forEach(unsubscribe => unsubscribe())
+  }
+
+  handleDescriptorChange(newDescriptor: RNGestureHandlerButtonDescriptor) {
+    this.descriptor = newDescriptor
+  }
+
+  build() {
+    RNViewBase({ ctx: this.ctx, tag: this.tag }) {
+      ForEach(this.descriptor.childrenTags, (childrenTag: Tag) => {
+        RNComponentFactory({ ctx: this.ctx, tag: childrenTag, buildCustomComponent: this.buildCustomComponent })
+      })
+    }
+  }
 }

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerModule.ts

@@ -1,125 +1,183 @@
-import { TurboModule, TurboModuleContext } from 'rnoh/ts';
-import { GestureHandlerRegistry } from './GestureHandlerRegistry';
-import { GestureHandlerFactory } from "./GestureHandlerFactory"
-import { ViewRegistry } from './ViewRegistry';
-import { RNGHLogger, StandardRNGHLogger, FakeRNGHLogger } from './RNGHLogger';
-import { EventDispatcher, JSEventDispatcher, AnimatedEventDispatcher } from './EventDispatcher'
-import { RNOHScrollLocker } from "./RNOHScrollLocker"
-
-export enum ActionType {
-  REANIMATED_WORKLET = 1,
-  NATIVE_ANIMATED_EVENT = 2,
-  JS_FUNCTION_OLD_API = 3,
-  JS_FUNCTION_NEW_API = 4,
-}
-
-
-export class RNGestureHandlerModule extends TurboModule {
-  static NAME = "RNGestureHandlerModule"
-
-  private gestureHandlerRegistry = new GestureHandlerRegistry()
-  private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
-  private viewRegistry: ViewRegistry | undefined = undefined
-  private logger: RNGHLogger
-
-  constructor(ctx: TurboModuleContext) {
-    super(ctx)
-    const debug = false
-    this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
-  }
-
-  public install() {
-    this.viewRegistry = new ViewRegistry(this.ctx.descriptorRegistry, this.ctx.componentManagerRegistry)
-    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, new RNOHScrollLocker(this.ctx.rnInstance))
-  }
-
-  public createGestureHandler(
-    handlerName: string,
-    handlerTag: number,
-    config: Readonly<Record<string, unknown>>
-  ) {
-    if (!this.gestureHandlerFactory) {
-      this.ctx.logger.error("Trying to create a gesture handler before creating gesture handler factory")
-      return
-    }
-    const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
-    this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
-    gestureHandler.updateGestureConfig(config)
-  }
-
-  public attachGestureHandler(
-    handlerTag: number,
-    viewTag: number,
-    actionType: ActionType
-  ) {
-    const eventDispatcher = this.createEventDispatcher(actionType, viewTag)
-    if (!eventDispatcher) {
-      this.ctx.logger.error("RNGH: Couldn't create EventDispatcher")
-      return
-    }
-    const view = this.viewRegistry.getViewByTag(viewTag)
-    if (!view) {
-      this.ctx.logger.error(`RNGH: Couldn't attachGestureHandler to view ${viewTag}`)
-      return;
-    }
-    this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
-    this.gestureHandlerRegistry
-      .getGestureHandlerByHandlerTag(handlerTag)
-      .setEventDispatcher(eventDispatcher)
-  }
-
-  private createEventDispatcher(actionType: ActionType, viewTag: number): EventDispatcher | null {
-    switch (actionType) {
-      case ActionType.REANIMATED_WORKLET:
-        this.ctx.logger.error("RNGH: Reanimated Worklets are not supported")
-        break;
-      case ActionType.NATIVE_ANIMATED_EVENT:
-        return new AnimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('AnimatedEventDispatcher'), viewTag)
-      case ActionType.JS_FUNCTION_OLD_API:
-      case ActionType.JS_FUNCTION_NEW_API:
-        return new JSEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('JSEventDispatcher'));
-    }
-    return null
-  }
-
-  public updateGestureHandler(
-    handlerTag: number,
-    newConfig: Readonly<Record<string, unknown>>
-  ) {
-    const gestureHandler = this.gestureHandlerRegistry.getGestureHandlerByHandlerTag(handlerTag)
-    gestureHandler.updateGestureConfig(newConfig)
-  }
-
-  public dropGestureHandler(handlerTag: number) {
-    this.warn("dropGestureHandler is not implemented")
-  }
-
-  public handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
-    this.warn("handleSetJSResponder is not implemented")
-  }
-
-  public handleClearJSResponder() {
-    this.warn("handleClearJSResponder is not implemented")
-  }
-
-  public flushOperations() {
-    this.warn("flushOperations is not implemented")
-  }
-
-  // -------------------------------------------------------------------------------------------------------------------
-  protected warn(message: string) {
-    this.ctx.logger.warn("RNGH: " + message)
-  }
-
-  public getGestureHandlerRegistry() {
-    return this.gestureHandlerRegistry
-  }
-
-  public getLogger() {
-    return this.logger
-  }
-
-  public getViewRegistry() {
-    return this.viewRegistry
-  }
-}
+import { TurboModule, TurboModuleContext, Tag } from '@rnoh/react-native-openharmony/ts';
+// import { TM } from "rnoh/generated/ts"
+import { GestureHandlerRegistry } from './GestureHandlerRegistry';
+import { GestureHandlerFactory } from "./GestureHandlerFactory"
+import { ViewRegistry } from './ViewRegistry';
+import { RNGHLogger, StandardRNGHLogger, FakeRNGHLogger } from './RNGHLogger';
+import {
+  EventDispatcher,
+  JSEventDispatcher,
+  AnimatedEventDispatcher,
+  ReanimatedEventDispatcher
+} from './EventDispatcher'
+import { RNOHScrollLockerArkTS, RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
+import { State } from './State';
+import { RNGHRootTouchHandlerCAPI, RawTouchEvent } from "./RNGHRootTouchHandlerCAPI"
+import { RNGHRootTouchHandlerArkTS } from './RNGHRootTouchHandlerArkTS';
+
+export enum ActionType {
+  REANIMATED_WORKLET = 1,
+  NATIVE_ANIMATED_EVENT = 2,
+  JS_FUNCTION_OLD_API = 3,
+  JS_FUNCTION_NEW_API = 4,
+}
+
+
+export class RNGestureHandlerModule extends TurboModule {
+// implements TM.RNGestureHandlerModule.Spec {
+  static NAME = "RNGestureHandlerModule"
+
+  private gestureHandlerRegistry = new GestureHandlerRegistry()
+  private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
+  private viewRegistry: ViewRegistry | undefined = undefined
+  private logger: RNGHLogger
+  private touchHandlerByRootTag = new Map<Tag, RNGHRootTouchHandlerCAPI>()
+
+  constructor(ctx: TurboModuleContext) {
+    super(ctx)
+    const debug = false
+    this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
+    if (this.ctx.rnInstance.getArchitecture() === "C_API") {
+      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::TOUCH_EVENT", (e: any) => {
+        this.onTouch(e)
+      })
+      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::ROOT_CREATED", (rootTag: any) => {
+        this.onGHRootCreated(rootTag)
+      })
+    }
+  }
+
+  private onGHRootCreated(rootTag: Tag) {
+    this.touchHandlerByRootTag.set(rootTag, new RNGHRootTouchHandlerCAPI(this.logger, new RNGHRootTouchHandlerArkTS(rootTag, this.viewRegistry, this.gestureHandlerRegistry, this.logger)));
+  }
+
+  private onTouch(e: RawTouchEvent & { rootTag: Tag }) {
+    const touchHandler = this.touchHandlerByRootTag.get(e.rootTag)
+    if (touchHandler) {
+      touchHandler.handleTouch(e);
+    } else {
+      this.logger.info(`Couldn't find touch handler for root tag: ${e.rootTag}`)
+    }
+
+  }
+
+  public install() {
+    this.viewRegistry = new ViewRegistry(this.ctx.descriptorRegistry, this.ctx.componentManagerRegistry)
+    const scrollLocker = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new RNOHScrollLockerArkTS(this.ctx.rnInstance) : new RNOHScrollLockerCAPI(this.ctx.rnInstance);
+    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, scrollLocker)
+    return true
+  }
+
+  public createGestureHandler(
+    handlerName: string,
+    handlerTag: number,
+    config: Readonly<Record<string, unknown>>
+  ) {
+    if (!this.gestureHandlerFactory) {
+      this.ctx.logger.error("Trying to create a gesture handler before creating gesture handler factory")
+      return
+    }
+    const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
+    this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
+    gestureHandler.updateGestureConfig(config)
+  }
+
+  public attachGestureHandler(
+    handlerTag: number,
+    viewTag: number,
+    actionType: ActionType
+  ) {
+    const eventDispatcher = this.createEventDispatcher(actionType, viewTag)
+    if (!eventDispatcher) {
+      this.ctx.logger.error("RNGH: Couldn't create EventDispatcher")
+      return
+    }
+    const view = this.viewRegistry.getViewByTag(viewTag)
+    if (!view) {
+      this.ctx.logger.error(`RNGH: Couldn't attachGestureHandler to view ${viewTag}`)
+      return;
+    }
+    this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
+    this.gestureHandlerRegistry
+      .getGestureHandlerByHandlerTag(handlerTag)
+      .setEventDispatcher(eventDispatcher)
+  }
+
+  private createEventDispatcher(actionType: ActionType, viewTag: number): EventDispatcher | null {
+    switch (actionType) {
+      case ActionType.REANIMATED_WORKLET:
+        return new ReanimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('ReanimatedEventDispatcher'), viewTag)
+      case ActionType.NATIVE_ANIMATED_EVENT:
+        return new AnimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('AnimatedEventDispatcher'), viewTag)
+      case ActionType.JS_FUNCTION_OLD_API:
+      case ActionType.JS_FUNCTION_NEW_API:
+        return new JSEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('JSEventDispatcher'));
+    }
+  }
+
+  public updateGestureHandler(
+    handlerTag: number,
+    newConfig: Readonly<Record<string, unknown>>
+  ) {
+    const gestureHandler = this.gestureHandlerRegistry.getGestureHandlerByHandlerTag(handlerTag)
+    gestureHandler.updateGestureConfig(newConfig)
+  }
+
+  public dropGestureHandler(handlerTag: number) {
+    this.warn("dropGestureHandler is not implemented")
+  }
+
+  public handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
+    this.warn("handleSetJSResponder is not implemented")
+  }
+
+  public handleClearJSResponder() {
+    this.warn("handleClearJSResponder is not implemented")
+  }
+
+  public flushOperations() {
+    this.warn("flushOperations is not implemented")
+  }
+
+  // -------------------------------------------------------------------------------------------------------------------
+  protected warn(message: string) {
+    this.ctx.logger.warn("RNGH: " + message)
+  }
+
+  public getGestureHandlerRegistry() {
+    return this.gestureHandlerRegistry
+  }
+
+  public getLogger() {
+    return this.logger
+  }
+
+  public getViewRegistry() {
+    if (!this.viewRegistry) {
+      this.logger.info("Tried to get viewRegistry before it was initialized")
+      throw new Error("Tried to get viewRegistry before it was initialized")
+    }
+    return this.viewRegistry
+  }
+
+  public setGestureHandlerState(handlerTag: number, newState: State) {
+    const handler = this.getGestureHandlerRegistry().getGestureHandlerByHandlerTag(handlerTag);
+    switch (newState) {
+      case State.ACTIVE:
+        handler.activate();
+        break;
+      case State.BEGAN:
+        handler.begin();
+        break;
+      case State.END:
+        handler.end();
+        break;
+      case State.FAILED:
+        handler.fail();
+        break;
+      case State.CANCELLED:
+        handler.cancel();
+        break;
+    }
+  }
+}