@react-native-oh-tpl/react-native-gesture-handler 2.14.1-2.14.8 → 2.14.1-2.14.9

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

@@ -0,0 +1,38 @@
+import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
+import { RNC } from "../namespace/ts"
+
+export type RNGestureHandlerButtonDescriptor = RNC.RNGestureHandlerButton.Descriptor
+
+@Component
+export struct RNGestureHandlerButton {
+  static readonly NAME = RNC.RNGestureHandlerButton.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/rnoh/RNGestureHandlerModule.ts

@@ -0,0 +1,230 @@
+import { TurboModule, TurboModuleContext, Tag } from "@rnoh/react-native-openharmony/ts";
+import { TM } from "../namespace/ts"
+import { GestureHandlerRegistry, State, OutgoingEventDispatcher, RNGHLogger, InteractionManager } from '../core';
+import { GestureHandlerFactory } from "../gesture-handlers"
+import { ViewRegistry, ViewRegistryArkTS, ViewRegistryCAPI } from './ViewRegistry';
+import { StandardRNGHLogger, FakeRNGHLogger } from './Logger';
+import { JSEventDispatcher, AnimatedEventDispatcher, ReanimatedEventDispatcher } from './OutgoingEventDispatchers'
+import { RNOHScrollLockerArkTS, RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
+import { RNGHRootTouchHandlerCAPI, RawTouchEvent } from "./RNGHRootTouchHandlerCAPI"
+import { RNGHRootTouchHandlerArkTS } from './RNGHRootTouchHandlerArkTS';
+import { ViewCAPI } from "./View"
+import { FakeRNGestureResponder, RNOHGestureResponder } from "./RNOHGestureResponder"
+
+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: GestureHandlerRegistry
+  private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
+  private viewRegistry: ViewRegistry | undefined = undefined
+  private logger: RNGHLogger
+  private touchHandlerByRootTag = new Map<Tag, RNGHRootTouchHandlerCAPI>()
+  private interactionManager: InteractionManager
+
+  constructor(ctx: TurboModuleContext) {
+    super(ctx)
+    const debug = false
+    this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
+    this.interactionManager = new InteractionManager(this.logger)
+    this.gestureHandlerRegistry = new GestureHandlerRegistry(this.logger)
+
+    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)
+      })
+      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::CANCEL_TOUCHES", (rootTag: any) => {
+        const touchHandler = this.touchHandlerByRootTag.get(rootTag)
+        touchHandler?.cancelTouches()
+      })
+    }
+  }
+
+  /**
+   * @architecture: C-API
+   * Called from C++.
+   */
+  private onGHRootCreated(rootTag: Tag) {
+    this.touchHandlerByRootTag.set(rootTag, new RNGHRootTouchHandlerCAPI(this.logger, new RNGHRootTouchHandlerArkTS(rootTag, this.viewRegistry, this.gestureHandlerRegistry, this.logger)));
+  }
+
+  /**
+   * @architecture: C-API
+   * Called from C++.
+   */
+  private onTouch(e: RawTouchEvent & { rootTag: Tag }) {
+    const logger = this.logger.cloneWithPrefix("onTouch")
+    if (!(this.viewRegistry instanceof ViewRegistryCAPI)) {
+      logger.error("Expected ViewRegistryCAPI")
+      return;
+    }
+    const touchHandler = this.touchHandlerByRootTag.get(e.rootTag)
+    if (!touchHandler) {
+      logger.error(`Couldn't find touch handler for gesture root tag: ${e.rootTag}`)
+      return;
+    }
+    // update view registry
+    e.touchableViews.forEach(touchableView => {
+      const view = this.viewRegistry.getViewByTag(touchableView.tag)
+      if (view) {
+        if (!(view instanceof ViewCAPI)) {
+          logger.error(`Expected ViewCAPI`)
+          return
+        }
+        view.updateBoundingBox(touchableView)
+      } else {
+        this.viewRegistry.save(new ViewCAPI(touchableView))
+      }
+    })
+    // relay touch
+    touchHandler.handleTouch(e, e.touchableViews.map(({tag}) => this.viewRegistry.getViewByTag(tag)));
+  }
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  public install() {
+    this.viewRegistry = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new ViewRegistryArkTS(this.ctx.descriptorRegistry) : new ViewRegistryCAPI()
+    const scrollLocker = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new RNOHScrollLockerArkTS(this.ctx.rnInstance) : new RNOHScrollLockerCAPI(this.ctx.rnInstance, this.logger);
+    const rnGestureResponder =  this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new FakeRNGestureResponder() : new RNOHGestureResponder(this.ctx.rnInstance)
+    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, scrollLocker, this.interactionManager, rnGestureResponder)
+    return true
+  }
+
+  public createGestureHandler(
+    handlerName: string,
+    handlerTag: number,
+    config: Readonly<Record<string, unknown>>
+  ) {
+    const logger = this.logger.cloneWithPrefix("createGestureHandler")
+    if (!this.gestureHandlerFactory) {
+      this.ctx.logger.error("Trying to create a gesture handler before creating gesture handler factory")
+      return
+    }
+    logger.debug({ handlerName, handlerTag, config })
+    const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
+    this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
+    this.interactionManager.configureInteractions(gestureHandler, config);
+    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 viewRegistry = this.viewRegistry
+    let view = this.viewRegistry.getViewByTag(viewTag)
+    if (!view && viewRegistry instanceof ViewRegistryCAPI) {
+      view = new ViewCAPI({
+        tag: viewTag,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      })
+      viewRegistry.save(view)
+    }
+    if (!view) {
+      this.ctx.logger.error("Expected view")
+      return;
+    }
+    this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
+    this.gestureHandlerRegistry
+      .getGestureHandlerByHandlerTag(handlerTag)
+      .setEventDispatcher(eventDispatcher)
+  }
+
+  private createEventDispatcher(actionType: ActionType, viewTag: number): OutgoingEventDispatcher | 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)
+    this.interactionManager.configureInteractions(gestureHandler, newConfig);
+    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;
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/RNGestureHandlerRootView.ets

@@ -0,0 +1,53 @@
+import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
+import { RNC } from "../namespace/ts"
+import { RNGHRootTouchHandlerArkTS as RNGHRootTouchHandler } from "./RNGHRootTouchHandlerArkTS"
+import { RNGestureHandlerModule } from "./RNGestureHandlerModule"
+
+
+export type RNGestureHandlerRootViewDescriptor = RNC.RNGestureHandlerRootView.Descriptor
+
+@Component
+export struct RNGestureHandlerRootView {
+  static readonly NAME = RNC.RNGestureHandlerRootView.NAME
+  ctx!: RNOHContext
+  tag: number = -1
+  @BuilderParam buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void
+  @State descriptor: RNGestureHandlerRootViewDescriptor = {} as RNGestureHandlerRootViewDescriptor
+  private unsubscribes: (() => void)[] = []
+  private touchHandler: RNGHRootTouchHandler | undefined = undefined
+
+  aboutToAppear() {
+    const rnGestureHandlerModule = this.ctx.rnInstance.getTurboModule<RNGestureHandlerModule>(RNGestureHandlerModule.NAME)
+    const rootTag = this.ctx.descriptorRegistry.getDescriptorLineage(this.tag)[0].tag
+    this.touchHandler = new RNGHRootTouchHandler(rootTag, rnGestureHandlerModule.getViewRegistry(), rnGestureHandlerModule.getGestureHandlerRegistry(), rnGestureHandlerModule.getLogger())
+    this.handleDescriptorChange(this.ctx.descriptorRegistry.getDescriptor<RNGestureHandlerRootViewDescriptor>(this.tag))
+    this.unsubscribes.push(this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag, (d) => {
+      this.handleDescriptorChange(d as RNGestureHandlerRootViewDescriptor)
+    }))
+  }
+
+  aboutToDisappear() {
+    this.unsubscribes.forEach(unsubscribe => unsubscribe())
+  }
+
+  handleDescriptorChange(newDescriptor: RNGestureHandlerRootViewDescriptor) {
+    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 })
+      })
+      Stack() {
+      }
+      .width("100%")
+      .height("100%")
+      .onTouch((e) => {
+        this.touchHandler?.handleTouch(e)
+      })
+      .hitTestBehavior(HitTestMode.Transparent)
+
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/RNOHGestureResponder.ts

@@ -0,0 +1,24 @@
+import { RNInstance } from "@rnoh/react-native-openharmony/ts"
+import { RNGestureResponder } from "../core"
+
+export class FakeRNGestureResponder {
+  lock() {
+    // Cancelling RN events isn't supported in ArkTS architecture.
+    return () => {}
+  }
+}
+
+/**
+ * Used in C-API architecture.
+ */
+export class RNOHGestureResponder implements RNGestureResponder {
+  constructor(private rnInstance: RNInstance) {
+  }
+
+  lock(viewTag: number): () => void {
+    this.rnInstance.postMessageToCpp("RNGH::ROOT_VIEW_IS_HANDLING_TOUCHES", { descendantViewTag: viewTag, isHandlingTouches: true })
+    return () => {
+      this.rnInstance.postMessageToCpp("RNGH::ROOT_VIEW_IS_HANDLING_TOUCHES", { descendantViewTag: viewTag, isHandlingTouches: false })
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/RNOHScrollLocker.ts

@@ -0,0 +1,32 @@
+import { RNInstance } from '@rnoh/react-native-openharmony/ts';
+import { ScrollLocker, RNGHLogger } from '../core';
+
+export class RNOHScrollLockerArkTS implements ScrollLocker {
+  constructor(private rnInstance: RNInstance) {
+  }
+
+  lockScrollContainingViewTag(viewTag: number) {
+    return this.rnInstance.blockComponentsGestures(viewTag);
+  }
+}
+
+export class RNOHScrollLockerCAPI implements ScrollLocker {
+  private logger: RNGHLogger
+
+  constructor(private rnInstance: RNInstance, logger: RNGHLogger) {
+    this.logger = logger.cloneWithPrefix("RNOHScrollLockerCAPI")
+  }
+
+  lockScrollContainingViewTag(viewTag: number) {
+    this.rnInstance.postMessageToCpp('RNGH::SET_NATIVE_RESPONDERS_BLOCK', {
+      targetTag: viewTag,
+      shouldBlock: true,
+    });
+    return () => {
+      this.rnInstance.postMessageToCpp('RNGH::SET_NATIVE_RESPONDERS_BLOCK', {
+        targetTag: viewTag,
+        shouldBlock: false,
+      });
+    };
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/View.ts

@@ -0,0 +1,119 @@
+import { DescriptorRegistry, Descriptor, Tag } from '@rnoh/react-native-openharmony/ts';
+import { View, Vector2D, BoundingBox } from "../core"
+
+
+export type RawTouchableView = {
+  tag: number,
+  /**
+   * Relative to application window.
+   */
+  x: number,
+  /**
+   * Relative to application window.
+   */
+  y: number,
+  width: number,
+  height: number
+}
+
+export class ViewCAPI implements View {
+  private tag: number
+  private boundingBox: BoundingBox
+
+  constructor({ tag, ...boundingBox }: RawTouchableView) {
+    this.tag = tag
+    this.boundingBox = boundingBox
+  }
+
+  getTag(): number {
+    return this.tag
+  }
+
+  getBoundingRect(): BoundingBox {
+    return { ...this.boundingBox }
+  }
+
+  isPositionInBounds({x, y}: {
+    x: number;
+    y: number
+  }): boolean {
+    const rect = this.getBoundingRect();
+    return (
+      x >= rect.x &&
+        x <= rect.x + rect.width &&
+        y >= rect.y &&
+        y <= rect.y + rect.height
+    );
+  }
+
+  updateBoundingBox(boundingBox: BoundingBox) {
+    this.boundingBox = boundingBox
+  }
+}
+
+export class ViewArkTS implements View {
+  constructor(
+    private descriptorRegistry: DescriptorRegistry,
+    private viewTag: number,
+  ) {
+  }
+
+
+  public getTag(): Tag {
+    return this.viewTag;
+  }
+
+  public isPositionInBounds({x, y}: {
+    x: number;
+    y: number
+  }): boolean {
+    const rect = this.getBoundingRect();
+    return (
+      x >= rect.x &&
+        x <= rect.x + rect.width &&
+        y >= rect.y &&
+        y <= rect.y + rect.height
+    );
+  }
+
+  public getBoundingRect(): BoundingBox {
+    const d = this.getDescriptor();
+    if (!d) {
+      return { x: 0, y: 0, width: 0, height: 0 };
+    }
+    const offsetToAbsolutePosition = this.getOffsetToAbsolutePosition();
+    return {
+      x: d.layoutMetrics.frame.origin.x - offsetToAbsolutePosition.x,
+      y: d.layoutMetrics.frame.origin.y - offsetToAbsolutePosition.y,
+      width: d.layoutMetrics.frame.size.width,
+      height: d.layoutMetrics.frame.size.height,
+    };
+  }
+
+  private getDescriptor() {
+    return this.descriptorRegistry.getDescriptor(this.viewTag);
+  }
+
+  private getOffsetToAbsolutePosition(): Vector2D {
+    const currentOffset = new Vector2D();
+    let parentTag = this.getDescriptor()?.parentTag;
+    while (parentTag !== undefined) {
+      const d = this.descriptorRegistry.getDescriptor(parentTag);
+      currentOffset.add(this.extractScrollOffsetFromDescriptor(d));
+      currentOffset.subtract(new Vector2D(d.layoutMetrics.frame.origin));
+      parentTag = d.parentTag;
+    }
+    return currentOffset;
+  }
+
+  private extractScrollOffsetFromDescriptor(descriptor: Descriptor<any>) {
+    if (descriptor.type !== 'ScrollView') {
+      return new Vector2D();
+    }
+    const scrollViewState: any = descriptor.state;
+    return new Vector2D({
+      x: scrollViewState.contentOffsetX,
+      y: scrollViewState.contentOffsetY,
+    });
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/ViewRegistry.ts

@@ -0,0 +1,95 @@
+import { DescriptorRegistry, Tag, } from '@rnoh/react-native-openharmony/ts';
+import { ViewArkTS } from './View';
+import { View } from '../core';
+import type { ViewFinder } from "./RNGHRootTouchHandlerArkTS"
+
+export interface ViewRegistry extends ViewFinder {
+  getViewByTag(viewTag: Tag)
+  save(view: View)
+}
+
+export class ViewRegistryArkTS implements ViewRegistry {
+  constructor(
+    private descriptorRegistry: DescriptorRegistry,
+  ) {
+  }
+
+  getViewByTag(viewTag: Tag) {
+    return this.createView(viewTag);
+  }
+
+  save(view: View) {
+    /**
+     * Currently, a new View object is created when getViewByTag is called. That was the approach in initial "quick"
+     * implementation of this library. The save was introduced later, for the needs of implementation using C-API architecture.
+     * C-API architecture is going to replace ArkTS anyway, so there's no point of doing this properly since this class
+     * will be removed in the future.
+     */
+  }
+
+  private createView(tag: Tag): ViewArkTS {
+    return new ViewArkTS(this.descriptorRegistry, tag);
+  }
+
+  getTouchableViewsAt(
+    pos: {
+      x: number;
+      y: number;
+    },
+    rootTag: Tag,
+  ): ViewArkTS[] {
+    const rootView = this.createView(rootTag);
+    const results: ViewArkTS[] = [];
+    for (const view of this.getTouchableViewsAtPosInView(pos, rootView)) {
+      results.push(view);
+    }
+    return results;
+  }
+
+  private getTouchableViewsAtPosInView(
+    pos: {
+      x: number;
+      y: number;
+    },
+    view: ViewArkTS,
+  ) {
+    if (!view.isPositionInBounds(pos)) return [];
+    const results: ViewArkTS[] = [];
+    results.push(view);
+    for (const child of this.getChildrenOf(view.getTag())) {
+      for (const result of this.getTouchableViewsAtPosInView(pos, child)) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+
+  private getChildrenOf(viewTag: Tag): ViewArkTS[] {
+    return this.descriptorRegistry.findDescriptorWrapperByTag(viewTag).childrenTags.map((tag) => new ViewArkTS(this.descriptorRegistry, tag))
+  }
+}
+
+
+export class ViewRegistryCAPI implements ViewRegistry {
+  private viewByTag = new Map<Tag, View>()
+
+  save(view: View) {
+    this.viewByTag.set(view.getTag(), view)
+  }
+
+  getViewByTag(viewTag: Tag) {
+    return this.viewByTag.get(viewTag);
+  }
+
+  getTouchableViewsAt(
+    pos: {
+      x: number;
+      y: number;
+    },
+    rootTag: Tag,
+  ): ViewArkTS[] {
+    // Finding views is handled on CPP side and provided with the touch event.
+    // This method can be removed from ViewRegistry interface once support for ArkTS architecture is removed.
+    return []
+  }
+}

package/harmony/gesture_handler/src/main/ets/rnoh/types.ts

@@ -0,0 +1,25 @@
+export enum TouchType {
+  Down,
+  Up,
+  Move,
+  Cancel
+}
+
+interface BaseEvent {
+  timestamp: number;
+}
+
+export interface TouchObject {
+  type: TouchType;
+  id: number;
+  windowX: number;
+  windowY: number;
+  x: number;
+  y: number;
+}
+
+export interface TouchEvent extends BaseEvent {
+  type: TouchType;
+  touches: TouchObject[];
+  changedTouches: TouchObject[];
+}

package/harmony/gesture_handler/src/main/module.json5

@@ -0,0 +1,9 @@
+{
+  "module": {
+    "name": "gesture_handler",
+    "type": "har",
+    "deviceTypes": [
+      "default"
+    ],
+  }
+}

package/harmony/gesture_handler/src/main/resources/base/element/color.json

@@ -0,0 +1,8 @@
+{
+  "color": [
+    {
+      "name": "start_window_background",
+      "value": "#FFFFFF"
+    }
+  ]
+}

package/harmony/gesture_handler/src/main/resources/base/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_desc",
+      "value": "module description"
+    },
+    {
+      "name": "WebviewAbility_desc",
+      "value": "description"
+    },
+    {
+      "name": "WebviewAbility_label",
+      "value": "label"
+    }
+  ]
+}

package/harmony/gesture_handler/src/main/resources/base/profile/main_pages.json

@@ -0,0 +1,5 @@
+{
+  "src": [
+    "pages/Index"
+  ]
+}

package/harmony/gesture_handler/src/main/resources/en_US/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_desc",
+      "value": "module description"
+    },
+    {
+      "name": "WebviewAbility_desc",
+      "value": "description"
+    },
+    {
+      "name": "WebviewAbility_label",
+      "value": "label"
+    }
+  ]
+}