Merge pull request #387 from RignonNoel/feature-new_events

feat(all): add IndoorLevelActivated and IndoorBuildingFocused

Author: dapriett

README.md

@@ -169,6 +169,8 @@ The following events are available:
 `markerInfoWindowTapped` | Fires when a marker's info window is tapped
 `cameraChanged` | Fires after the camera has changed
 `cameraMove` | Fires repeatedly while the camera is moving
+`indoorBuildingFocused` | Fired when the focused building (building currently centered, selected by user or by location provider)
+`indoorLevelActivated` | Fired when the level of the focused building change
 
 ## Native Map Object
 

demo/app/main-page.js

@@ -245,8 +245,18 @@ function onCameraMove(args) {
     console.log("Camera moving: "+JSON.stringify(args.camera));
 }
 
+function onIndoorBuildingFocused(args) {
+    console.log("Building focus changed: " + JSON.stringify(args.indoorBuilding));
+}
+
+function onIndoorLevelActivated(args) {
+    console.log("Indoor level changed: " + JSON.stringify(args.activateLevel));
+}
+
 exports.onMapReady = onMapReady;
 exports.onCoordinateTapped = onCoordinateTapped;
 exports.onMarkerEvent = onMarkerEvent;
 exports.onCameraChanged = onCameraChanged;
 exports.onCameraMove = onCameraMove;
+exports.onIndoorBuildingFocused = onIndoorBuildingFocused;
+exports.onIndoorLevelActivated = onIndoorLevelActivated;

demo/app/main-page.xml

@@ -7,6 +7,8 @@
                       markerEndDragging="onMarkerEvent" markerDrag="onMarkerEvent"
                       markerInfoWindowTapped="onMarkerEvent" coordinateTapped="onCoordinateTapped"
                       cameraChanged="onCameraChanged"
+                      indoorBuildingFocused="onIndoorBuildingFocused"
+                      indoorLevelActivated="onIndoorLevelActivated"
                       cameraMove="onCameraMove">
             <maps:mapView.infoWindowTemplate>
                 <StackLayout orientation="vertical" width="200" height="150" >

src/map-view-common.ts

@@ -1,7 +1,8 @@
 import {
     MapView, Position, Marker, Shape, Polyline, Polygon, Projection,
     Circle, Camera, MarkerEventData, ShapeEventData, VisibleRegion,
-    CameraEventData, PositionEventData, Bounds, Style, UISettings
+    CameraEventData, PositionEventData, Bounds, Style, UISettings, IndoorBuilding, IndoorLevel,
+    IndoorLevelActivatedEventData, BuildingFocusedEventData
 } from "./map-view";
 import { Point, View, Template, KeyedTemplate } from "tns-core-modules/ui/core/view";
 import { Image } from "tns-core-modules/ui/image";
@@ -162,7 +163,7 @@ export abstract class MapViewBase extends View implements MapView {
             }
             return undefined;
         }
-    }
+    };
     public _infoWindowTemplates = new Array<KeyedTemplate>();
 
     public projection: Projection;
@@ -181,6 +182,8 @@ export abstract class MapViewBase extends View implements MapView {
     public static cameraChangedEvent: string = "cameraChanged";
     public static cameraMoveEvent: string = "cameraMove";
     public static myLocationTappedEvent: string = "myLocationTapped";
+    public static indoorBuildingFocusedEvent: string = "indoorBuildingFocused";
+    public static indoorLevelActivatedEvent: string = "indoorLevelActivated";
 
     public get gMap() {
         return this._gMap;
@@ -349,6 +352,16 @@ export abstract class MapViewBase extends View implements MapView {
     notifyMyLocationTapped() {
         this.notify({ eventName: MapViewBase.myLocationTappedEvent, object: this });
     }
+
+    notifyBuildingFocusedEvent(indoorBuilding: IndoorBuilding) {
+        let args: BuildingFocusedEventData = { eventName: MapViewBase.indoorBuildingFocusedEvent, object: this, indoorBuilding: indoorBuilding };
+        this.notify(args);
+    }
+
+    notifyIndoorLevelActivatedEvent(activateLevel: IndoorLevel) {
+        let args: IndoorLevelActivatedEventData = { eventName: MapViewBase.indoorLevelActivatedEvent, object: this, activateLevel: activateLevel };
+        this.notify(args);
+    }
 }
 
 export const infoWindowTemplateProperty = new Property<MapViewBase, string | Template>({ name: "infoWindowTemplate" });

src/map-view.android.ts

@@ -11,6 +11,7 @@ import { Image } from "tns-core-modules/ui/image";
 import { Color } from "tns-core-modules/color";
 import { Point } from "tns-core-modules/ui/core/view";
 import imageSource = require("tns-core-modules/image-source");
+import {IndoorLevel} from "./map-view";
 
 export * from "./map-view-common";
 
@@ -133,6 +134,44 @@ export class MapView extends MapViewBase {
                     onMyLocationButtonClick: () => {
                         owner.notifyMyLocationTapped();
 
+                        return false;
+                    },
+                }));
+
+                gMap.setOnIndoorStateChangeListener(new com.google.android.gms.maps.GoogleMap.OnIndoorStateChangeListener({
+                    onIndoorBuildingFocused: () => {
+                        const buildingFocused = gMap.getFocusedBuilding();
+                        let data = null;
+                        if (buildingFocused) {
+                            const levels = [];
+                            let count = 0;
+                            while (count < buildingFocused.getLevels().size()) {
+                                levels.push(
+                                    {
+                                        name: buildingFocused.getLevels().get(count).getName(),
+                                        shortName: buildingFocused.getLevels().get(count).getShortName(),
+                                    }
+                                );
+                                count += 1;
+                            }
+                            data = {
+                                defaultLevelIndex: buildingFocused.getDefaultLevelIndex(),
+                                levels: levels,
+                                isUnderground: buildingFocused.isUnderground(),
+                            };
+
+                        }
+                        owner.notifyBuildingFocusedEvent(data);
+
+                        return false;
+                    },
+                    onIndoorLevelActivated: (gmsIndoorBuilding) => {
+                        const level = gmsIndoorBuilding.getLevels().get(gmsIndoorBuilding.getActiveLevelIndex());
+                        owner.notifyIndoorLevelActivatedEvent({
+                            name: level.getName(),
+                            shortName: level.getShortName(),
+                        });
+
                         return false;
                     }
                 }));

src/map-view.d.ts

@@ -4,6 +4,17 @@ import { Image } from "tns-core-modules/ui/image";
 import { Color } from "tns-core-modules/color";
 import { EventData } from "tns-core-modules/data/observable";
 
+export class IndoorLevel {
+    public name: string;
+    public shortName: string;
+}
+
+export class IndoorBuilding {
+    public defaultLevelIndex: number;
+    public levels: IndoorLevel[];
+    public isUnderground: boolean;
+}
+
 export class Camera {
     public latitude: number;
     public longitude: number;
@@ -265,3 +276,11 @@ export interface CameraEventData extends EventData {
 export interface PositionEventData extends EventData {
     position: Position;
 }
+
+export interface BuildingFocusedEventData extends EventData {
+    indoorBuilding: IndoorBuilding;
+}
+
+export interface IndoorLevelActivatedEventData extends EventData {
+    activateLevel: IndoorLevel;
+}

src/map-view.ios.ts

@@ -15,6 +15,62 @@ export * from "./map-view-common";
 
 declare function UIEdgeInsetsMake(...params: any[]): any;
 
+class IndoorDisplayDelegateImpl extends NSObject implements GMSIndoorDisplayDelegate {
+
+    public static ObjCProtocols = [GMSIndoorDisplayDelegate];
+
+    private _owner: WeakRef<MapView>;
+
+    public static initWithOwner(owner: WeakRef<MapView>): IndoorDisplayDelegateImpl {
+        let handler = <IndoorDisplayDelegateImpl>IndoorDisplayDelegateImpl.new();
+        handler._owner = owner;
+        return handler;
+    }
+
+    public didChangeActiveBuilding(indoorBuilding: GMSIndoorBuilding): void {
+        let owner = this._owner.get();
+        if (owner) {
+            let data = null;
+            if (indoorBuilding) {
+                const levels = [];
+                let count = 0;
+
+                while (count < indoorBuilding.levels.count) {
+                    levels.push(
+                        {
+                            name: indoorBuilding.levels[count].name,
+                            shortName: indoorBuilding.levels[count].shortName,
+                        }
+                    );
+                    count += 1;
+                }
+
+                data = {
+                    defaultLevelIndex: indoorBuilding.defaultLevelIndex,
+                    levels: levels,
+                    isUnderground: indoorBuilding.underground,
+                };
+            }
+            owner.notifyBuildingFocusedEvent(data);
+        }
+    }
+
+    public didChangeActiveLevel(activateLevel: GMSIndoorLevel): void {
+        let owner = this._owner.get();
+        if (owner) {
+            let data = null;
+            if (activateLevel) {
+                data = {
+                    name: activateLevel.name,
+                    shortName: activateLevel.shortName,
+                };
+            }
+            owner.notifyIndoorLevelActivatedEvent(data);
+        }
+    }
+}
+
+
 class MapViewDelegateImpl extends NSObject implements GMSMapViewDelegate {
 
     public static ObjCProtocols = [GMSMapViewDelegate];
@@ -217,29 +273,34 @@ export class MapView extends MapViewBase {
     protected _markers: Array<Marker> = new Array<Marker>();
 
     private _delegate: MapViewDelegateImpl;
+    private _indoorDelegate:IndoorDisplayDelegateImpl;
 
     constructor() {
         super();
 
         this.nativeView = GMSMapView.mapWithFrameCamera(CGRectZero, this._createCameraPosition());
         this._delegate = MapViewDelegateImpl.initWithOwner(new WeakRef(this));
+        this._indoorDelegate = IndoorDisplayDelegateImpl.initWithOwner(new WeakRef(this));
         this.updatePadding();
     }
 
     public onLoaded() {
         super.onLoaded();
         this.nativeView.delegate = this._delegate;
+        this.nativeView.indoorDisplay.delegate = this._indoorDelegate;
         this.notifyMapReady();
     }
 
     public onUnloaded() {
         this.nativeView.delegate = null;
+        this.nativeView.indoorDisplay.delegate = null;
         super.onUnloaded();
     }
 
     public disposeNativeView() {
         this._markers = null;
         this._delegate = null;
+        this._indoorDelegate=null;
         super.disposeNativeView();
         GC();
     };