@nativescript-community/gesturehandler 0.2.2 → 2.0.0

package/{gesturehandler.android.js → .history/src/gesturehandler/gesturehandler.android_20220328163618.ts}

@@ -1,12 +1,42 @@
 import { Application, View } from '@nativescript/core';
-import { GestureTypes } from '@nativescript/core/ui/gestures';
+import { GestureEventData, GestureTypes } from '@nativescript/core/ui/gestures';
 import { Page } from '@nativescript/core/ui/page';
 import { layout } from '@nativescript/core/utils/utils';
-import { BaseGestureRootView, BaseNative, GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, HandlerType, ManagerBase, ROOT_GESTURE_HANDLER_TAG, ViewDisposeEvent, ViewInitEvent, applyMixins, install as installBase, nativeProperty, } from './gesturehandler.common';
+import {
+    HandlerOptions,
+    LongPressGestureHandlerOptions,
+    NativeViewGestureHandlerOptions,
+    PanGestureHandlerOptions,
+    PinchGestureHandlerOptions,
+    RotationGestureHandlerOptions,
+    TapGestureHandlerOptions,
+} from './gesturehandler';
+import {
+    BaseGestureRootView,
+    BaseNative,
+    GestureHandlerStateEvent,
+    GestureHandlerTouchEvent,
+    GestureState,
+    GestureStateEventData,
+    GestureTouchEventData,
+    HandlerType,
+    ManagerBase,
+    OptionsTypeMap,
+    ROOT_GESTURE_HANDLER_TAG,
+    TypeMap,
+    ViewDisposeEvent,
+    ViewInitEvent,
+    applyMixins,
+    install as installBase,
+    nativeProperty,
+} from './gesturehandler.common';
 import { observe as gestureObserve } from './gestures_override';
-export { GestureState, GestureHandlerStateEvent, GestureHandlerTouchEvent, HandlerType, ViewInitEvent, ViewDisposeEvent };
-let PageLayout;
+
+export { GestureState, GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureStateEventData, GestureTouchEventData, HandlerType, ViewInitEvent, ViewDisposeEvent };
+
+let PageLayout: typeof com.nativescript.gesturehandler.PageLayout;
 class PageGestureExtended extends Page {
+    nativeView: com.nativescript.gesturehandler.PageLayout;
     initNativeView() {
         this.nativeView.initialize();
     }
@@ -19,6 +49,7 @@ class PageGestureExtended extends Page {
 }
 let installed = false;
 let installedOverrides = false;
+
 export class GestureRootView extends BaseGestureRootView {
     createNativeView() {
         if (!PageLayout) {
@@ -39,6 +70,7 @@ export class GestureRootView extends BaseGestureRootView {
         return this.nativeView && this.nativeView.registry();
     }
 }
+
 export function install(overrideNGestures = false) {
     if (!installed) {
         installed = true;
@@ -49,10 +81,12 @@ export function install(overrideNGestures = false) {
                 PageLayout = com.nativescript.gesturehandler.PageLayout;
             }
             const layout = new PageLayout(this._context, ROOT_GESTURE_HANDLER_TAG);
+            // this.gestureRegistry = layout.registry();
             return layout;
         };
         applyMixins(NSPage, [PageGestureExtended]);
     }
+
     if (overrideNGestures === true && !installedOverrides) {
         installedOverrides = true;
         const NSView = require('@nativescript/core/ui/core/view').View;
@@ -60,23 +94,54 @@ export function install(overrideNGestures = false) {
         const NSButton = require('@nativescript/core/ui/button').Button;
         delete NSButtonBase.tapEvent;
         delete NSButton.tapEvent;
+        // we need to disable on click listener
         NSButton.prototype.initNativeView = function () {
             NSButtonBase.prototype.initNativeView.call(this);
         };
         NSButton.prototype.disposeNativeView = function () {
             NSButtonBase.prototype.disposeNativeView.call(this);
         };
-        NSView.prototype._observe = function (type, callback, thisArg) {
+        NSView.prototype._observe = function (type: GestureTypes, callback: (args: GestureEventData) => void, thisArg?: any): void {
             if (!this._gestureObservers[type]) {
                 this._gestureObservers[type] = [];
             }
+
             this._gestureObservers[type].push(gestureObserve(this, type, callback, thisArg));
             if (this.isLoaded && !this.touchListenerIsSet) {
                 this.setOnTouchListener();
             }
         };
+        // NSView.prototype.setOnTouchListener = function () {
+        //     if (!this.nativeViewProtected || !this.getGestureObservers(GestureTypes.touch)) {
+        //         return;
+        //     }
+        //     // do not set noop listener that handles the event (disabled listener) if IsUserInteractionEnabled is
+        //     // false as we might need the ability for the event to pass through to a parent view
+        //     this.touchListener =
+        //         this.touchListener ||
+        //         new android.view.View.OnTouchListener({
+        //             onTouch: (view: android.view.View, event: android.view.MotionEvent) => {
+        //                 this.handleGestureTouch(event);
+
+        //                 const nativeView = this.nativeViewProtected;
+        //                 if (!nativeView || !nativeView.onTouchEvent) {
+        //                     return false;
+        //                 }
+
+        //                 return nativeView.onTouchEvent(event);
+        //             },
+        //         });
+        //     this.nativeViewProtected.setOnTouchListener(this.touchListener);
+
+        //     this.touchListenerIsSet = true;
+        //     console.log('setOnTouchListener', this);
+        //     if (this.nativeViewProtected.setClickable) {
+        //         this.nativeViewProtected.setClickable(this.isUserInteractionEnabled);
+        //     }
+        // };
     }
 }
+
 const KEY_HIT_SLOP_LEFT = 'left';
 const KEY_HIT_SLOP_TOP = 'top';
 const KEY_HIT_SLOP_RIGHT = 'right';
@@ -85,13 +150,64 @@ const KEY_HIT_SLOP_VERTICAL = 'vertical';
 const KEY_HIT_SLOP_HORIZONTAL = 'horizontal';
 const KEY_HIT_SLOP_WIDTH = 'width';
 const KEY_HIT_SLOP_HEIGHT = 'height';
-export class Handler extends BaseNative {
-    constructor() {
-        super(...arguments);
-        this.nativeGetterKey = 'nativeView';
-        this.tag = 0;
-    }
-    getExtraData(handler) {
+
+export abstract class Handler<T extends com.swmansion.gesturehandler.GestureHandler<any>, U extends HandlerOptions> extends BaseNative<T, U> {
+    @nativeProperty({
+        nativeSetterName: 'setHitSlop',
+        nativegetterName: 'getHitSlop',
+        converter: {
+            toNative(value) {
+                const HIT_SLOP_NONE = GestureHandler.HIT_SLOP_NONE;
+                if (typeof value === 'number') {
+                    const hitSlop = layout.toDevicePixels(value);
+                    return [hitSlop, hitSlop, hitSlop, hitSlop, HIT_SLOP_NONE, HIT_SLOP_NONE];
+                } else {
+                    let left = HIT_SLOP_NONE,
+                        top = HIT_SLOP_NONE,
+                        right = HIT_SLOP_NONE,
+                        bottom = HIT_SLOP_NONE;
+                    let width = HIT_SLOP_NONE,
+                        height = HIT_SLOP_NONE;
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_HORIZONTAL)) {
+                        const horizontalPad = layout.toDevicePixels(value[KEY_HIT_SLOP_HORIZONTAL]);
+                        left = right = horizontalPad;
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_VERTICAL)) {
+                        const verticalPad = layout.toDevicePixels(value[KEY_HIT_SLOP_VERTICAL]);
+                        top = bottom = verticalPad;
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_LEFT)) {
+                        left = layout.toDevicePixels(value[KEY_HIT_SLOP_LEFT]);
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_TOP)) {
+                        top = layout.toDevicePixels(value[KEY_HIT_SLOP_TOP]);
+                    }
+                    if (value.hasKey(KEY_HIT_SLOP_RIGHT)) {
+                        right = layout.toDevicePixels(value[KEY_HIT_SLOP_RIGHT]);
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_BOTTOM)) {
+                        bottom = layout.toDevicePixels(value[KEY_HIT_SLOP_BOTTOM]);
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_WIDTH)) {
+                        width = layout.toDevicePixels(value[KEY_HIT_SLOP_WIDTH]);
+                    }
+                    if (value.hasOwnProperty(KEY_HIT_SLOP_HEIGHT)) {
+                        height = layout.toDevicePixels(value[KEY_HIT_SLOP_HEIGHT]);
+                    }
+                    return [left, top, right, bottom, width, height];
+                }
+            },
+        },
+    })
+    hitSlop;
+    @nativeProperty enabled: boolean;
+    @nativeProperty shouldCancelWhenOutside: boolean;
+    shouldStartGesture: (arg) => boolean;
+    manager: WeakRef<Manager>;
+    touchListener: com.swmansion.gesturehandler.OnTouchEventListener<T>;
+    nativeGetterKey = 'nativeView';
+
+    getExtraData(handler: T) {
         const numberOfPointers = handler.getNumberOfPointers();
         const positions = [];
         for (let index = 0; index < numberOfPointers; index++) {
@@ -99,11 +215,13 @@ export class Handler extends BaseNative {
             positions.push(layout.toDeviceIndependentPixels(handler.getYAtIndex(index)));
         }
         return {
+            // x: layout.toDeviceIndependentPixels(handler.getX()),
+            // y: layout.toDeviceIndependentPixels(handler.getY()),
             positions,
             numberOfPointers,
         };
     }
-    initNativeView(native, options) {
+    initNativeView(native: T, options: U) {
         super.initNativeView(native, options);
         this.native.setTag(this.tag);
         this.touchListener = new com.swmansion.gesturehandler.OnTouchEventListener({
@@ -120,14 +238,14 @@ export class Handler extends BaseNative {
         this.touchListener = null;
         super.disposeNativeView();
     }
-    handleShouldStartGesture(handler, event) {
+    handleShouldStartGesture(handler: T, event: android.view.MotionEvent) {
         if (this.shouldStartGesture) {
             return this.shouldStartGesture(this.getExtraData(handler));
         }
         return true;
     }
-    onTouchEvent(handler, event) {
-        const view = handler.getView();
+    onTouchEvent(handler: T, event: android.view.MotionEvent) {
+        const view = handler.getView() as any;
         this.notify({
             eventName: GestureHandlerTouchEvent,
             object: this,
@@ -139,8 +257,8 @@ export class Handler extends BaseNative {
             },
         });
     }
-    onStateChange(handler, state, prevState) {
-        const view = handler.getView();
+    onStateChange(handler: T, state: number, prevState: number) {
+        const view = handler.getView() as any;
         this.notify({
             eventName: GestureHandlerStateEvent,
             object: this,
@@ -153,7 +271,10 @@ export class Handler extends BaseNative {
             },
         });
     }
-    setTag(tag) {
+
+    tag: number = 0;
+    attachedView: View;
+    setTag(tag: number) {
         this.tag = tag;
         if (this.native) {
             this.native.setTag(tag);
@@ -161,6 +282,7 @@ export class Handler extends BaseNative {
     }
     getTag() {
         return this.tag;
+        // return this.getNative().getTag();
     }
     getView() {
         return this.getNative().getView();
@@ -168,7 +290,8 @@ export class Handler extends BaseNative {
     cancel() {
         return this.getNative().cancel();
     }
-    attachToView(view) {
+
+    attachToView(view: View) {
         if (view === this.attachedView) {
             return;
         }
@@ -178,7 +301,7 @@ export class Handler extends BaseNative {
         this.attachedView = view;
         this.manager.get().attachGestureHandler(this, view);
     }
-    detachFromView(view) {
+    detachFromView(view?: View) {
         if ((view && view !== this.attachedView) || !this.attachedView) {
             return;
         }
@@ -189,63 +312,19 @@ export class Handler extends BaseNative {
         this.attachedView = null;
     }
 }
-__decorate([
-    nativeProperty({
-        nativeSetterName: 'setHitSlop',
-        nativegetterName: 'getHitSlop',
-        converter: {
-            toNative(value) {
-                const HIT_SLOP_NONE = GestureHandler.HIT_SLOP_NONE;
-                if (typeof value === 'number') {
-                    const hitSlop = layout.toDevicePixels(value);
-                    return [hitSlop, hitSlop, hitSlop, hitSlop, HIT_SLOP_NONE, HIT_SLOP_NONE];
-                }
-                else {
-                    let left = HIT_SLOP_NONE, top = HIT_SLOP_NONE, right = HIT_SLOP_NONE, bottom = HIT_SLOP_NONE;
-                    let width = HIT_SLOP_NONE, height = HIT_SLOP_NONE;
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_HORIZONTAL)) {
-                        const horizontalPad = layout.toDevicePixels(value[KEY_HIT_SLOP_HORIZONTAL]);
-                        left = right = horizontalPad;
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_VERTICAL)) {
-                        const verticalPad = layout.toDevicePixels(value[KEY_HIT_SLOP_VERTICAL]);
-                        top = bottom = verticalPad;
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_LEFT)) {
-                        left = layout.toDevicePixels(value[KEY_HIT_SLOP_LEFT]);
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_TOP)) {
-                        top = layout.toDevicePixels(value[KEY_HIT_SLOP_TOP]);
-                    }
-                    if (value.hasKey(KEY_HIT_SLOP_RIGHT)) {
-                        right = layout.toDevicePixels(value[KEY_HIT_SLOP_RIGHT]);
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_BOTTOM)) {
-                        bottom = layout.toDevicePixels(value[KEY_HIT_SLOP_BOTTOM]);
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_WIDTH)) {
-                        width = layout.toDevicePixels(value[KEY_HIT_SLOP_WIDTH]);
-                    }
-                    if (value.hasOwnProperty(KEY_HIT_SLOP_HEIGHT)) {
-                        height = layout.toDevicePixels(value[KEY_HIT_SLOP_HEIGHT]);
-                    }
-                    return [left, top, right, bottom, width, height];
-                }
-            },
-        },
-    })
-], Handler.prototype, "hitSlop", void 0);
-__decorate([
-    nativeProperty
-], Handler.prototype, "enabled", void 0);
-__decorate([
-    nativeProperty
-], Handler.prototype, "shouldCancelWhenOutside", void 0);
-export class TapGestureHandler extends Handler {
+
+export class TapGestureHandler extends Handler<com.swmansion.gesturehandler.TapGestureHandler, TapGestureHandlerOptions> {
+    @nativeProperty numberOfTaps: number;
+    @nativeProperty maxDurationMs: number;
+    @nativeProperty maxDelayMs: number;
+    @nativeProperty({ nativeSetterName: 'setMaxDx' }) maxDeltaX: number;
+    @nativeProperty({ nativeSetterName: 'setMaxDy' }) maxDeltaY: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) maxDist: number;
+    @nativeProperty({ nativeSetterName: 'setMinNumberOfPointers' }) minPointers: number;
     createNative(options) {
         return new com.swmansion.gesturehandler.TapGestureHandler();
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.TapGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             x: layout.toDeviceIndependentPixels(handler.getLastRelativePositionX()),
             y: layout.toDeviceIndependentPixels(handler.getLastRelativePositionY()),
@@ -254,33 +333,29 @@ export class TapGestureHandler extends Handler {
         });
     }
 }
-__decorate([
-    nativeProperty
-], TapGestureHandler.prototype, "numberOfTaps", void 0);
-__decorate([
-    nativeProperty
-], TapGestureHandler.prototype, "maxDurationMs", void 0);
-__decorate([
-    nativeProperty
-], TapGestureHandler.prototype, "maxDelayMs", void 0);
-__decorate([
-    nativeProperty({ nativeSetterName: 'setMaxDx' })
-], TapGestureHandler.prototype, "maxDeltaX", void 0);
-__decorate([
-    nativeProperty({ nativeSetterName: 'setMaxDy' })
-], TapGestureHandler.prototype, "maxDeltaY", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], TapGestureHandler.prototype, "maxDist", void 0);
-__decorate([
-    nativeProperty({ nativeSetterName: 'setMinNumberOfPointers' })
-], TapGestureHandler.prototype, "minPointers", void 0);
-export class PanGestureHandler extends Handler {
+
+export class PanGestureHandler extends Handler<com.swmansion.gesturehandler.PanGestureHandler, PanGestureHandlerOptions> {
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) minDist: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) activeOffsetXStart: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) activeOffsetXEnd: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) failOffsetXStart: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) failOffsetXEnd: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) activeOffsetYStart: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) activeOffsetYEnd: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) failOffsetYStart: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) failOffsetYEnd: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) minVelocity: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) minVelocityX: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) minVelocityY: number;
+    @nativeProperty minPointers: number;
+    @nativeProperty maxPointers: number;
+    @nativeProperty({ nativeSetterName: 'setAverageTouches' }) avgTouches: number;
+    @nativeProperty numberOfPointers: number;
     createNative(options) {
-        const context = Application.android.context;
+        const context = Application.android.context as android.content.Context;
         return new com.swmansion.gesturehandler.PanGestureHandler(context);
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.PanGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             x: layout.toDeviceIndependentPixels(handler.getLastRelativePositionX()),
             y: layout.toDeviceIndependentPixels(handler.getLastRelativePositionY()),
@@ -293,59 +368,13 @@ export class PanGestureHandler extends Handler {
         });
     }
 }
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "minDist", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "activeOffsetXStart", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "activeOffsetXEnd", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "failOffsetXStart", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "failOffsetXEnd", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "activeOffsetYStart", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "activeOffsetYEnd", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "failOffsetYStart", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "failOffsetYEnd", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "minVelocity", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "minVelocityX", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PanGestureHandler.prototype, "minVelocityY", void 0);
-__decorate([
-    nativeProperty
-], PanGestureHandler.prototype, "minPointers", void 0);
-__decorate([
-    nativeProperty
-], PanGestureHandler.prototype, "maxPointers", void 0);
-__decorate([
-    nativeProperty({ nativeSetterName: 'setAverageTouches' })
-], PanGestureHandler.prototype, "avgTouches", void 0);
-__decorate([
-    nativeProperty
-], PanGestureHandler.prototype, "numberOfPointers", void 0);
-export class PinchGestureHandler extends Handler {
+
+export class PinchGestureHandler extends Handler<com.swmansion.gesturehandler.PinchGestureHandler, PinchGestureHandlerOptions> {
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) minSpan: number;
     createNative(options) {
         return new com.swmansion.gesturehandler.PinchGestureHandler();
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.PinchGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             x: layout.toDeviceIndependentPixels(handler.getLastRelativePositionX()),
             y: layout.toDeviceIndependentPixels(handler.getLastRelativePositionY()),
@@ -358,18 +387,16 @@ export class PinchGestureHandler extends Handler {
         });
     }
 }
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], PinchGestureHandler.prototype, "minSpan", void 0);
+
 const GestureHandler = com.swmansion.gesturehandler.GestureHandler;
-export var FlingDirection;
-(function (FlingDirection) {
-    FlingDirection[FlingDirection["DIRECTION_LEFT"] = GestureHandler.DIRECTION_LEFT] = "DIRECTION_LEFT";
-    FlingDirection[FlingDirection["DIRECTION_UP"] = GestureHandler.DIRECTION_UP] = "DIRECTION_UP";
-    FlingDirection[FlingDirection["DIRECTION_DOWN"] = GestureHandler.DIRECTION_DOWN] = "DIRECTION_DOWN";
-    FlingDirection[FlingDirection["DIRECTION_RIGHT"] = GestureHandler.DIRECTION_RIGHT] = "DIRECTION_RIGHT";
-})(FlingDirection || (FlingDirection = {}));
-function directionToString(direction) {
+export enum FlingDirection {
+    DIRECTION_LEFT = GestureHandler.DIRECTION_LEFT,
+    DIRECTION_UP = GestureHandler.DIRECTION_UP,
+    DIRECTION_DOWN = GestureHandler.DIRECTION_DOWN,
+    DIRECTION_RIGHT = GestureHandler.DIRECTION_RIGHT,
+}
+
+function directionToString(direction: number) {
     switch (direction) {
         case GestureHandler.DIRECTION_RIGHT:
             return 'right';
@@ -381,7 +408,8 @@ function directionToString(direction) {
             return 'left';
     }
 }
-function directionFromString(direction) {
+
+function directionFromString(direction: string) {
     switch (direction) {
         case 'right':
             return GestureHandler.DIRECTION_RIGHT;
@@ -393,28 +421,27 @@ function directionFromString(direction) {
             return GestureHandler.DIRECTION_LEFT;
     }
 }
-export class FlingGestureHandler extends Handler {
+
+export class FlingGestureHandler extends Handler<com.swmansion.gesturehandler.FlingGestureHandler, TapGestureHandlerOptions> {
+    @nativeProperty numberOfPointers: number;
+    @nativeProperty direction: number;
     createNative(options) {
         return new com.swmansion.gesturehandler.FlingGestureHandler();
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.FlingGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             direction: directionToString(handler.getRecognizedDirection()),
         });
     }
 }
-__decorate([
-    nativeProperty
-], FlingGestureHandler.prototype, "numberOfPointers", void 0);
-__decorate([
-    nativeProperty
-], FlingGestureHandler.prototype, "direction", void 0);
-export class LongPressGestureHandler extends Handler {
+export class LongPressGestureHandler extends Handler<com.swmansion.gesturehandler.LongPressGestureHandler, LongPressGestureHandlerOptions> {
+    @nativeProperty minDurationMs: number;
+    @nativeProperty({ converter: { fromNative: layout.toDevicePixels } }) maxDist: number;
     createNative(options) {
-        const context = Application.android.context;
+        const context = Application.android.context as android.content.Context;
         return new com.swmansion.gesturehandler.LongPressGestureHandler(context);
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.LongPressGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             x: layout.toDeviceIndependentPixels(handler.getLastRelativePositionX()),
             y: layout.toDeviceIndependentPixels(handler.getLastRelativePositionY()),
@@ -423,17 +450,11 @@ export class LongPressGestureHandler extends Handler {
         });
     }
 }
-__decorate([
-    nativeProperty
-], LongPressGestureHandler.prototype, "minDurationMs", void 0);
-__decorate([
-    nativeProperty({ converter: { fromNative: layout.toDevicePixels } })
-], LongPressGestureHandler.prototype, "maxDist", void 0);
-export class RotationGestureHandler extends Handler {
+export class RotationGestureHandler extends Handler<com.swmansion.gesturehandler.RotationGestureHandler, RotationGestureHandlerOptions> {
     createNative(options) {
         return new com.swmansion.gesturehandler.RotationGestureHandler();
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.RotationGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             x: layout.toDeviceIndependentPixels(handler.getLastRelativePositionX()),
             y: layout.toDeviceIndependentPixels(handler.getLastRelativePositionY()),
@@ -446,28 +467,23 @@ export class RotationGestureHandler extends Handler {
         });
     }
 }
-export class NativeViewGestureHandler extends Handler {
+
+export class NativeViewGestureHandler extends Handler<com.swmansion.gesturehandler.NativeViewGestureHandler, NativeViewGestureHandlerOptions> {
+    @nativeProperty shouldActivateOnStart: boolean;
+    @nativeProperty disallowInterruption: boolean;
     createNative(options) {
         return new com.swmansion.gesturehandler.NativeViewGestureHandler();
     }
-    getExtraData(handler) {
+    getExtraData(handler: com.swmansion.gesturehandler.NativeViewGestureHandler) {
         return Object.assign(super.getExtraData(handler), {
             pointerInside: handler.isWithinBounds(),
         });
     }
 }
-__decorate([
-    nativeProperty
-], NativeViewGestureHandler.prototype, "shouldActivateOnStart", void 0);
-__decorate([
-    nativeProperty
-], NativeViewGestureHandler.prototype, "disallowInterruption", void 0);
+
 export class Manager extends ManagerBase {
-    constructor() {
-        super(...arguments);
-        this.viewListeners = new Map();
-    }
-    configureInteractions(handler, options = {}) {
+    _interactionManager: com.nativescript.gesturehandler.GestureHandlerInteractionController;
+    configureInteractions<T extends com.swmansion.gesturehandler.GestureHandler<any>, U extends HandlerOptions>(handler: Handler<T, U>, options: U = {} as any) {
         this.interactionManager.configureInteractions(handler.getNative(), options.waitFor, options.simultaneousHandlers);
     }
     get interactionManager() {
@@ -476,14 +492,16 @@ export class Manager extends ManagerBase {
         }
         return this._interactionManager;
     }
+
+    static sManager: Manager;
     static getInstance() {
         if (!Manager.sManager) {
             Manager.sManager = new Manager();
         }
         return Manager.sManager;
     }
-    createGestureHandler(handlerName, handlerTag, config) {
-        let handler = null;
+    createGestureHandler<T extends HandlerType>(handlerName: T, handlerTag: number, config?: OptionsTypeMap[T]): TypeMap[T] {
+        let handler: Handler<any, any> = null;
         switch (handlerName) {
             case 'tap':
                 handler = new TapGestureHandler(config);
@@ -511,15 +529,16 @@ export class Manager extends ManagerBase {
             handler.manager = new WeakRef(this);
             handler.setTag(handlerTag);
         }
-        return handler;
+        return handler as any;
     }
-    findRegistry(view) {
-        let registry;
-        const page = view.page;
+
+    findRegistry(view: View) {
+        let registry: com.swmansion.gesturehandler.GestureHandlerRegistryImpl;
+        const page = view.page as PageGestureExtended;
         if (page) {
             registry = page.registry;
-        }
-        else {
+        } else {
+            // no root page try to find a parent GestureRootView
             let parent = view.parent;
             while (parent) {
                 if (parent instanceof GestureRootView) {
@@ -530,20 +549,20 @@ export class Manager extends ManagerBase {
         }
         return registry;
     }
-    attachGestureHandlerToView(handler, view) {
+    attachGestureHandlerToView(handler: Handler<any, any>, view: View) {
         const nHandler = handler.getNative();
         if (nHandler) {
             const registry = this.findRegistry(view);
             if (registry) {
                 registry.registerHandler(nHandler);
                 registry.attachHandlerToView(nHandler.getTag(), view[handler.nativeGetterKey]);
-            }
-            else {
+            } else {
                 throw new Error('a Page or a GestureRootView is needed to attach a gesture');
             }
         }
     }
-    detachGestureHandlerFromView(handler, view) {
+
+    detachGestureHandlerFromView(handler: Handler<any, any>, view: View) {
         const nHandler = handler.getNative();
         if (nHandler) {
             const registry = this.findRegistry(view);
@@ -552,7 +571,9 @@ export class Manager extends ManagerBase {
             }
         }
     }
-    attachGestureHandler(handler, view) {
+
+    viewListeners = new Map<View, Map<number, { init: () => void; dispose: () => void }>>();
+    attachGestureHandler(handler: Handler<any, any>, view: View) {
         if (view.nativeView) {
             this.attachGestureHandlerToView(handler, view);
         }
@@ -570,7 +591,7 @@ export class Manager extends ManagerBase {
             dispose: onDispose,
         });
     }
-    detachGestureHandler(handler, view) {
+    detachGestureHandler(handler: Handler<any, any>, view: View) {
         if (view) {
             const viewListeners = this.viewListeners.get(view);
             if (viewListeners) {
@@ -588,4 +609,3 @@ export class Manager extends ManagerBase {
         this.detachGestureHandlerFromView(handler, view);
     }
 }
-//# sourceMappingURL=gesturehandler.android.js.map