chore: Event listener type improvements and cleanup

Author: CatchABus

src/ui-carto/core/index.android.ts

@@ -2,23 +2,12 @@ import { BaseNative } from '../BaseNative';
 import { AltitudeKey, DefaultLatLonKeys, GenericMapPos, LatitudeKey, LongitudeKey, MapVec, ScreenBounds, ScreenPos } from './index.common';
 export * from './index.common';
 
-export const ClickType = {
-    get SINGLE() {
-        return com.carto.ui.ClickType.CLICK_TYPE_SINGLE;
-    },
-    get LONG() {
-        return com.carto.ui.ClickType.CLICK_TYPE_LONG;
-    },
-    get DOUBLE() {
-        return com.carto.ui.ClickType.CLICK_TYPE_DOUBLE;
-    },
-    get DUAL() {
-        return com.carto.ui.ClickType.CLICK_TYPE_DUAL;
-    }
-};
-
 export class MapBounds<T = DefaultLatLonKeys> extends BaseNative<com.carto.core.MapBounds, {}> {
-    constructor(public northeast?: GenericMapPos<T>, public southwest?: GenericMapPos<T>, native?: com.carto.core.MapBounds) {
+    constructor(
+        public northeast?: GenericMapPos<T>,
+        public southwest?: GenericMapPos<T>,
+        native?: com.carto.core.MapBounds
+    ) {
         super(undefined, native);
     }
     createNative() {

src/ui-carto/core/index.common.ts

@@ -32,6 +32,14 @@ export class ScreenBounds {
     min: ScreenPos;
     max: ScreenPos;
 }
+
+export enum ClickType {
+    SINGLE,
+    LONG,
+    DOUBLE,
+    DUAL
+}
+
 // export namespace MapBounds {
 //     function fromCoordinates(southwest: MapPos, northeast: MapPos): MapBounds;
 // }

src/ui-carto/core/index.ios.ts

@@ -2,15 +2,12 @@ import { BaseNative } from '../BaseNative';
 import { AltitudeKey, DefaultLatLonKeys, GenericMapPos, LatitudeKey, LongitudeKey, MapVec, ScreenBounds, ScreenPos } from './index.common';
 export * from './index.common';
 
-export enum ClickType {
-    SINGLE = NTClickType.T_CLICK_TYPE_SINGLE,
-    LONG = NTClickType.T_CLICK_TYPE_LONG,
-    DOUBLE = NTClickType.T_CLICK_TYPE_DOUBLE,
-    DUAL = NTClickType.T_CLICK_TYPE_DUAL
-}
-
 export class MapBounds<T = DefaultLatLonKeys> extends BaseNative<NTMapBounds, {}> {
-    constructor(public northeast?: GenericMapPos<T>, public southwest?: GenericMapPos<T>, native?: NTMapBounds) {
+    constructor(
+        public northeast?: GenericMapPos<T>,
+        public southwest?: GenericMapPos<T>,
+        native?: NTMapBounds
+    ) {
         super(undefined, native);
     }
     createNative() {

src/ui-carto/ui/index.android.ts

@@ -1,4 +1,5 @@
 import {
+    ClickType,
     DefaultLatLonKeys,
     MapBounds,
     MapPos,
@@ -16,19 +17,10 @@ import {
 import { Layer, TileLayer } from '../layers';
 import { IProjection } from '../projections';
 import { restrictedPanningProperty } from './cssproperties';
-import {
-    Layers as BaseLayers,
-    CartoViewBase,
-    MapClickedEvent,
-    MapIdleEvent,
-    MapInteractionEvent,
-    MapMovedEvent,
-    MapReadyEvent,
-    MapStableEvent
-} from './index.common';
+import { Layers as BaseLayers, CartoViewBase, MapClickedEvent, MapIdleEvent, MapInteractionEvent, MapMovedEvent, MapReadyEvent, MapStableEvent } from './index.common';
 
 import { ImageSource, Property, Utils, booleanConverter } from '@nativescript/core';
-import { MapOptions } from '.';
+import { MapClickInfo, MapGestureInfo, MapInteractionInfo, MapOptions } from '.';
 import { EPSG4326 } from '../projections/epsg4326';
 export { MapClickedEvent, MapIdleEvent, MapMovedEvent, MapReadyEvent, MapStableEvent };
 
@@ -111,63 +103,54 @@ export class CartoMap<T = DefaultLatLonKeys> extends CartoViewBase {
         }
         const listener = new com.akylas.carto.additions.AKMapEventListener({
             onMapIdle: () => {
-                if (this.hasListeners(MapIdleEvent)) {
-                    this.sendEvent(MapIdleEvent);
-                }
+                this.sendEvent(MapIdleEvent);
             },
             onMapMoved: (userAction: boolean) => {
-                if (this.hasListeners(MapMovedEvent)) {
-                    this.sendEvent(MapMovedEvent, { userAction });
-                }
+                this.sendEvent<MapGestureInfo>(MapMovedEvent, { userAction });
             },
             onMapInteraction: (interaction: com.carto.ui.MapInteractionInfo, userAction: boolean) => {
-                if (this.hasListeners(MapInteractionEvent)) {
-                    this.sendEvent(MapInteractionEvent, {
-                        interaction: {
-                            userAction,
-                            get isAnimationStarted() {
-                                return interaction.isAnimationStarted();
-                            },
-                            get isPanAction() {
-                                return interaction.isPanAction();
-                            },
-                            get isRotateAction() {
-                                return interaction.isRotateAction();
-                            },
-                            get isTiltAction() {
-                                return interaction.isTiltAction();
-                            },
-                            get isZoomAction() {
-                                return interaction.isZoomAction();
-                            }
+                this.sendEvent<MapInteractionInfo>(MapInteractionEvent, {
+                    userAction,
+                    interaction: {
+                        get isAnimationStarted() {
+                            return interaction.isAnimationStarted();
+                        },
+                        get isPanAction() {
+                            return interaction.isPanAction();
+                        },
+                        get isRotateAction() {
+                            return interaction.isRotateAction();
+                        },
+                        get isTiltAction() {
+                            return interaction.isTiltAction();
+                        },
+                        get isZoomAction() {
+                            return interaction.isZoomAction();
                         }
-                    });
-                }
+                    }
+                });
             },
             onMapStable: (userAction: boolean) => {
-                if (this.hasListeners(MapStableEvent)) {
-                    this.sendEvent(MapStableEvent, { userAction });
-                }
+                this.sendEvent<MapGestureInfo>(MapStableEvent, { userAction });
             },
             onMapClicked: (mapClickInfo: com.carto.ui.MapClickInfo) => {
-                if (this.hasListeners(MapClickedEvent)) {
-                    this.sendEvent(MapClickedEvent, {
-                        android: mapClickInfo,
-                        get clickInfo() {
-                            return {
-                                get duration() {
-                                    return mapClickInfo.getClickInfo().getDuration();
-                                }
-                            };
-                        },
-                        get clickType() {
-                            return mapClickInfo.getClickType();
-                        },
-                        get position() {
-                            return fromNativeMapPos(mapClickInfo.getClickPos());
-                        }
-                    });
-                }
+                this.sendEvent<MapClickInfo>(MapClickedEvent, {
+                    android: mapClickInfo,
+                    get clickInfo() {
+                        return {
+                            get duration(): number {
+                                return mapClickInfo.getClickInfo().getDuration();
+                            }
+                        };
+                    },
+                    get clickType(): ClickType {
+                        // This will return an integer value that can be compared with the actual enum
+                        return mapClickInfo.getClickType().swigValue();
+                    },
+                    get position() {
+                        return fromNativeMapPos(mapClickInfo.getClickPos());
+                    }
+                });
             }
         });
         this.nativeViewProtected.listener = listener;

src/ui-carto/ui/index.common.ts

@@ -3,8 +3,8 @@ import { CSSType, ContentView } from '@nativescript/core';
 import { BaseNative } from '../BaseNative';
 import { LatitudeKey, MapPos, fromNativeMapPos } from '../core';
 import { Layer } from '../layers';
-import { nativeVectorToArray } from '../utils';
 import { bearingProperty, focusPosProperty, tiltProperty, zoomProperty } from './cssproperties';
+import { MapInfo } from '.';
 
 export const MapReadyEvent = 'mapReady';
 export const MapStableEvent = 'mapStable';
@@ -123,7 +123,7 @@ export abstract class CartoViewBase extends ContentView {
     @mapProperty maxZoom: number;
     @mapProperty restrictedPanning: boolean;
 
-    public sendEvent(eventName: string, data?) {
+    public sendEvent<T extends MapInfo = MapInfo>(eventName: string, data?: T) {
         if (this.hasListeners(eventName)) {
             this.notify({
                 eventName,

src/ui-carto/ui/index.d.ts

@@ -1,5 +1,5 @@
 import { EventData, ImageSource, Style, View } from '@nativescript/core';
-import { DefaultLatLonKeys, GenericMapPos, MapBounds, ScreenBounds, ScreenPos } from '../core';
+import { ClickType, DefaultLatLonKeys, GenericMapPos, MapBounds, ScreenBounds, ScreenPos } from '../core';
 import { Layer } from '../layers';
 import { Projection } from '../projections';
 import { Layers } from './index.common';
@@ -31,27 +31,53 @@ export const MapIdleEvent: string;
 export const MapMovedEvent: string;
 export const MapClickedEvent: string;
 
-export interface MapEventData extends EventData {
-    data: any;
+export interface MapInfo {}
+
+export interface MapGestureInfo extends MapInfo {
+    userAction: boolean;
 }
-export interface MapPosEventData<T = DefaultLatLonKeys> extends EventData {
-    MapPos: GenericMapPos<T>;
+
+export interface MapInteractionInfo extends MapGestureInfo {
+    interaction: {
+        isAnimationStarted: boolean;
+        isPanAction: boolean;
+        isRotateAction: boolean;
+        isTiltAction: boolean;
+        isZoomAction: boolean;
+    };
 }
 
-export interface MapClickInfo<T = DefaultLatLonKeys> {
-    clickType: number;
+export interface MapClickInfo<T = DefaultLatLonKeys> extends MapInfo {
+    android?: any;
+    ios?: any;
     clickInfo: {
         duration: number;
     };
+    clickType: ClickType;
     position: GenericMapPos<T>;
 }
-export interface MapInteractionInfo {
-    userAction: boolean;
-    isAnimationStarted: boolean;
-    isPanAction: boolean;
-    isRotateAction: boolean;
-    isTiltAction: boolean;
-    isZoomAction: boolean;
+
+export interface MapEventData extends EventData {
+    data?: MapInfo;
+}
+export interface MapPosEventData<T = DefaultLatLonKeys> extends EventData {
+    MapPos: GenericMapPos<T>;
+}
+
+export interface MapMovedEventData extends MapEventData {
+    data: MapGestureInfo;
+}
+
+export interface MapStableEventData extends MapEventData {
+    data: MapGestureInfo;
+}
+
+export interface MapInteractionEventData extends MapEventData {
+    data: MapInteractionInfo;
+}
+
+export interface MapClickedEventData extends MapEventData {
+    data: MapClickInfo;
 }
 
 export class MapOptions {
@@ -232,4 +258,10 @@ export class CartoMap<T = DefaultLatLonKeys> extends View {
     clearPreloadingCaches();
     cancelAllTasks();
     captureRendering(wait?: boolean): Promise<ImageSource>;
+
+    on(event: 'mapReady' | 'mapIdle', callback: (args: EventData) => void, thisArg?: any): void;
+    on(event: 'mapStable', callback: (args: MapStableEventData) => void, thisArg?: any): void;
+    on(event: 'mapMoved', callback: (args: MapMovedEventData) => void, thisArg?: any): void;
+    on(event: 'mapInteraction', callback: (args: MapInteractionEventData) => void, thisArg?: any): void;
+    on(event: 'mapClicked', callback: (args: MapClickedEventData) => void, thisArg?: any): void;
 }