react-native-map4d-map-dtqg 0.1.0

package/ios/RMFMarker.m

@@ -0,0 +1,267 @@
+//
+//  RMFMarker.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 4/28/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFMarker.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTLog.h>
+#import <React/RCTImageView.h>
+#import <Map4dMap/Map4dMap.h>
+#import "RMFEventResponse.h"
+#import "RMFDummyView.h"
+
+@implementation RMFMarker {
+//  RCTImageLoaderCancellationBlock _reloadImageCancellationBlock;
+    UIView *_iconView;
+    NSMutableArray* observables;
+}
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _map4dMarker = [[RMFMarkerMap4d alloc] init];
+    _map4dMarker.reactMarker = self;
+    
+    _coordinate = _map4dMarker.position;
+    _anchor = _map4dMarker.groundAnchor;
+    _elevation = _map4dMarker.elevation;
+    _rotation = _map4dMarker.rotation;
+    _draggable = _map4dMarker.draggable;
+    _infoWindowAnchor = _map4dMarker.infoWindowAnchor;
+    _title = nil;//_map4dMarker.title;
+    _snippet = nil;//_map4dMarker.snippet;
+    _icon = nil;
+    _zIndex = _map4dMarker.zIndex;
+    _visible = true;//!_map4dMarker.isHidden;
+    _userData = nil;
+    _iconView = nil;
+    observables = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+- (void)setMapView:(RMFMapView *)mapView {
+  if (mapView != nil) {
+    if (self.icon == nil) {
+      _map4dMarker.icon = nil;
+    } else {
+      _map4dMarker.icon = [UIImage imageWithCGImage:self.icon.image.CGImage scale:[UIScreen mainScreen].scale orientation:self.icon.image.imageOrientation];
+    }
+  }
+  _map4dMarker.map = mapView;
+}
+
+/** Property */
+
+- (void)setCoordinate:(CLLocationCoordinate2D)coordinate {
+  _coordinate = coordinate;
+  _map4dMarker.position = coordinate;
+}
+
+- (void)setAnchor:(CGPoint)anchor {
+  _anchor = anchor;
+  _map4dMarker.groundAnchor = anchor;
+}
+
+- (void)setElevation:(double)elevation {
+  _elevation = elevation;
+  _map4dMarker.elevation = elevation;
+}
+
+- (void)setRotation:(double)rotation {
+  _rotation = rotation;
+  _map4dMarker.rotation = rotation;
+}
+
+- (void)setDraggable:(BOOL)draggable {
+  _draggable = draggable;
+  _map4dMarker.draggable = draggable;
+}
+
+- (void) setInfoWindowAnchor:(CGPoint)infoWindowAnchor {
+  _infoWindowAnchor = infoWindowAnchor;
+  _map4dMarker.infoWindowAnchor = infoWindowAnchor;
+}
+
+- (void)setTitle:(NSString *)title {
+  _title = title;
+  _map4dMarker.title = title;
+}
+
+- (void)setSnippet:(NSString *)snippet {
+  _snippet = snippet;
+  _map4dMarker.snippet = snippet;
+}
+
+- (void)setIcon:(RMFIcon *)icon {
+  _icon = icon;
+  if (icon == nil) {
+    _map4dMarker.icon = nil;
+    return;
+  }
+  dispatch_async(dispatch_get_global_queue(0,0), ^{
+    NSData * imageData = [[NSData alloc] initWithContentsOfURL: [NSURL URLWithString: icon.uri]];
+    if (imageData != nil) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        self->_icon.image = [UIImage imageWithData:imageData];
+        if (self->_map4dMarker.map != nil) {
+          CGFloat scale = [UIScreen mainScreen].scale;
+          self->_map4dMarker.icon = [UIImage imageWithCGImage:[self->_icon.image CGImage] scale:scale orientation:self->_icon.image.imageOrientation];
+        }
+      });
+    }
+  });
+}
+
+- (void)setZIndex:(float)zIndex {
+  _zIndex = zIndex;
+  _map4dMarker.zIndex = zIndex;
+}
+
+- (void)setVisible:(BOOL)visible {
+  _visible = visible;
+  _map4dMarker.isHidden = !visible;
+}
+
+- (void)setUserInteractionEnabled:(BOOL)enabled {
+  [super setUserInteractionEnabled:enabled];
+  _map4dMarker.userInteractionEnabled = enabled;
+}
+
+ - (void)setUserData:(NSDictionary *)userData {
+   _userData = userData;
+ }
+
+- (NSDictionary*)responseWithAction:(NSString*)action pixel:(CGPoint)pixel {
+  CLLocationCoordinate2D tapLocation = [_map4dMarker.map.projection coordinateForPoint:pixel];
+  NSMutableDictionary* response = [NSMutableDictionary dictionaryWithDictionary:[RMFEventResponse fromCoordinate:tapLocation
+                                                                                                           pixel:pixel]];
+  response[@"marker"] = @{
+    kRMFLatLngCoordinateResponseKey: [RMFEventResponse fromCoordinate:_map4dMarker.position],
+    @"userData": _userData != nil ? _userData : @{}
+  };
+  response[@"action"] = action;
+  return response;
+}
+
+/** Event */
+- (void)didBeginDraggingMarkerAtPixel:(CGPoint)pixel {
+  if (self.onDragStart) {
+    self.onDragStart([self responseWithAction:@"marker-drag-start" pixel:pixel]);
+  }
+}
+
+- (void)didEndDraggingMarkerAtPixel:(CGPoint)pixel {
+  if (self.onDragEnd) {
+    self.onDragEnd([self responseWithAction:@"marker-drag-end" pixel:pixel]);
+  }
+}
+
+- (void)didDragMarkerAtPixel:(CGPoint)pixel {
+  if (self.onDrag) {
+    self.onDrag([self responseWithAction:@"marker-drag" pixel:pixel]);
+  }
+}
+
+- (void)didTapInfoWindowAtPixel:(CGPoint)pixel {
+  if (self.onPressInfoWindow) {
+    self.onPressInfoWindow([self responseWithAction:@"marker-info-window-press" pixel:pixel]);
+  }
+}
+
+- (void)didTapAtPixel:(CGPoint)pixel {
+  if (self.onPress) {
+    self.onPress([self responseWithAction:@"marker-press" pixel:pixel]);
+  };
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+  float width = 0;
+  float height = 0;
+
+  for (UIView *v in [_iconView subviews]) {
+    float fw = v.frame.origin.x + v.frame.size.width;
+    float fh = v.frame.origin.y + v.frame.size.height;
+
+    width = MAX(fw, width);
+    height = MAX(fh, height);
+  }
+  [_iconView setFrame:CGRectMake(0, 0, width, height)];
+  [self->_map4dMarker setIconView:_iconView];
+}
+
+- (void)iconViewInsertSubview:(UIView*)subview atIndex:(NSInteger)atIndex {
+  if (!_map4dMarker.iconView) {
+    _iconView = [[UIView alloc] init];
+    _map4dMarker.iconView = _iconView;
+  }
+  [_iconView insertSubview:subview atIndex:atIndex];
+}
+
+- (void) removeAllObserver {
+    for (UIView* v in observables) {
+        [v removeObserver:self forKeyPath:@"image"];
+        [v removeObserver:self forKeyPath:@"bounds"];
+    }
+    [observables removeAllObjects];
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+{
+    UIApplicationState appState = [[UIApplication sharedApplication] applicationState];
+    if (context == (__bridge void * _Nullable)(_iconView)) {
+        if (_map4dMarker != NULL) {
+            //TODO: remove me
+            //RCTImageView will clear image when window == nil or app go to background mode --> causes a bug, marker is updated without image.
+            //TODO: how to fix if we stop cheating?
+            if (context == (__bridge void * _Nullable) self.map4dMarker.iconView
+                && (!self.window || appState == UIApplicationStateBackground)
+                ) {
+                return;
+            }
+            [self.map4dMarker setIconView:_iconView];
+        }
+    } else {
+        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+    }
+}
+
+- (void)addObserver:(UIView*)view {
+  if ([view isKindOfClass:[RCTImageView class]]) {
+    [view addObserver:self forKeyPath:@"image" options:NSKeyValueObservingOptionNew context:(__bridge void * _Nullable)(_iconView)];
+    [view addObserver:self forKeyPath:@"bounds" options:NSKeyValueObservingOptionNew context:(__bridge void * _Nullable)(_iconView)];
+    [observables addObject:view];
+  }
+  
+  NSArray<UIView *> *reactSubviews = [view reactSubviews];
+  for (int i = 0; i < reactSubviews.count; i++) {
+    UIView* view = [reactSubviews objectAtIndex:i];
+    [self addObserver:view];
+  }
+}
+
+
+- (void)insertReactSubview:(id<RCTComponent>)subview atIndex:(NSInteger)atIndex {
+  [self iconViewInsertSubview:(UIView*)subview atIndex:atIndex+1];
+  [self removeAllObserver];
+  [self addObserver:(UIView *) subview];
+  RMFDummyView *dummySubview = [[RMFDummyView alloc] initWithView:(UIView *)subview];
+  [super insertReactSubview:(UIView*)dummySubview atIndex:atIndex];
+}
+
+- (void)removeReactSubview:(id<RCTComponent>)dummySubview {
+  [self removeAllObserver];
+  UIView* subview = ((RMFDummyView*)dummySubview).view;
+  [(UIView*)subview removeFromSuperview];
+  [super removeReactSubview:(UIView*)dummySubview];
+}
+
+- (void)dealloc {
+  [self removeAllObserver];
+}
+
+@end

package/ios/RMFMarkerManager.h

@@ -0,0 +1,17 @@
+//
+//  RMFMarkerManager.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 4/24/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFMarkerManager_h
+#define RMFMarkerManager_h
+
+#import <React/RCTViewManager.h>
+
+@interface RMFMarkerManager : RCTViewManager
+@end
+
+#endif /* RMFMarkerManager_h */

package/ios/RMFMarkerManager.m

@@ -0,0 +1,156 @@
+//
+//  RMFMarkerManager.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 4/28/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFMarkerManager.h"
+#import "RMFMarker.h"
+#import <React/RCTConvert+CoreLocation.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+@implementation RMFMarkerManager
+
+RCT_EXPORT_MODULE(RMFMarker)
+
+- (UIView *)view {
+  RMFMarker * marker = [[RMFMarker alloc] init];
+  return marker;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(coordinate, CLLocationCoordinate2D)
+RCT_EXPORT_VIEW_PROPERTY(anchor, CGPoint)
+RCT_EXPORT_VIEW_PROPERTY(elevation, double)
+RCT_EXPORT_VIEW_PROPERTY(rotation, double)
+RCT_EXPORT_VIEW_PROPERTY(draggable, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(infoWindowAnchor, CGPoint)
+RCT_EXPORT_VIEW_PROPERTY(title, NSString)
+RCT_EXPORT_VIEW_PROPERTY(snippet, NSString)
+RCT_EXPORT_VIEW_PROPERTY(userInteractionEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(icon, RMFIcon)
+RCT_EXPORT_VIEW_PROPERTY(zIndex, float)
+RCT_EXPORT_VIEW_PROPERTY(visible, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(userData, NSDictionary)
+
+RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPressInfoWindow, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onDragStart, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onDrag, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onDragEnd, RCTDirectEventBlock)
+
+RCT_EXPORT_METHOD(setCoordinate:(nonnull NSNumber *)reactTag
+                  withCoordinate:(id)coordinate)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setCoordinate:[RCTConvert CLLocationCoordinate2D:coordinate]];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setRotation:(nonnull NSNumber *)reactTag
+                  rotation:(double)rotation)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setRotation:rotation];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setTitle:(nonnull NSNumber *)reactTag
+                  title:(NSString*)title)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setTitle:title];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setSnippet:(nonnull NSNumber *)reactTag
+                  snippet:(NSString*)snippet)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setSnippet:snippet];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setDraggable:(nonnull NSNumber *)reactTag
+                  draggable:(BOOL)draggable)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setDraggable:draggable];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setZIndex:(nonnull NSNumber *)reactTag
+                  zIndex:(float)zIndex)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+            RMFMarker *marker = (RMFMarker *)view;
+            [marker setZIndex:zIndex];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setVisible:(nonnull NSNumber *)reactTag
+                  visible:(BOOL)visible)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+          RMFMarker *marker = (RMFMarker *)view;
+          [marker setVisible:visible];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(setUserData:(nonnull NSNumber *)reactTag
+                  userData:(id)json)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMarker class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+        } else {
+          RMFMarker *marker = (RMFMarker *)view;
+          [marker setUserData:[RCTConvert NSDictionary:json]];
+        }
+    }];
+}
+
+@end

package/ios/RMFMarkerMap4d.h

@@ -0,0 +1,19 @@
+//
+//  RMFMarkerMap4d.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 5/4/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFMarkerMap4d_h
+#define RMFMarkerMap4d_h
+
+#import <Map4dMap/Map4dMap.h>
+
+@class RMFMarker;
+@interface RMFMarkerMap4d : MFMarker
+@property (nonatomic, weak) RMFMarker *reactMarker;
+@end
+
+#endif /* RMFMarkerMap4d_h */

package/ios/RMFMarkerMap4d.m

@@ -0,0 +1,13 @@
+//
+//  RMFMarkerMap4d.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 5/4/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFMarkerMap4d.h"
+#import <Foundation/Foundation.h>
+
+@implementation RMFMarkerMap4d
+@end

package/ios/RMFPOI.h

@@ -0,0 +1,38 @@
+//
+//  RMFPOI.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPOI_h
+#define RMFPOI_h
+
+#import <React/UIView+React.h>
+#import "RMFPOIMap4d.h"
+#import "RMFMapView.h"
+#import "RMFIcon.h"
+
+@interface RMFPOI : UIView
+
+@property (nonatomic, strong, nonnull) RMFPOIMap4d * map4dPOI;
+
+@property (nonatomic, copy) RCTBubblingEventBlock _Nullable onPress;
+
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property (nonatomic, strong, nullable) NSString *title;
+@property (nonatomic, strong, nullable) UIColor* titleColor;
+@property (nonatomic, strong, nullable) NSString* subtitle;
+@property (nonatomic, strong, nullable) NSString* poiType;
+@property (nonatomic, copy, nullable) RMFIcon *icon;
+@property (nonatomic, assign) float zIndex;
+@property (nonatomic, assign) BOOL visible;
+@property (nonatomic, copy, nullable) NSDictionary * userData;
+
+- (void)didTapAtPixel:(CGPoint)pixel;
+- (void)setMapView:(RMFMapView* _Nullable)mapView;
+
+@end
+
+#endif /* RMFPOI_h */

package/ios/RMFPOI.m

@@ -0,0 +1,123 @@
+//
+//  RMFPOI.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPOI.h"
+#import <Foundation/Foundation.h>
+#import "RMFEventResponse.h"
+
+@implementation RMFPOI
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _map4dPOI = [[RMFPOIMap4d alloc] init];
+    _map4dPOI.reactPOI = self;
+    
+    _coordinate = _map4dPOI.position;
+    _title = nil;//_map4dPOI.title;
+    _titleColor = _map4dPOI.color;
+    _subtitle = nil;//_map4dPOI.subtitle;
+    _poiType = nil;//_map4dPOI.type;
+    _icon = nil;
+    _zIndex = _map4dPOI.zIndex;
+    _visible = true;//!_map4dPOI.isHidden;
+    _userData = nil;
+  }
+  return self;
+}
+
+- (void)setMapView:(RMFMapView *)mapView {
+  _map4dPOI.map = mapView;
+}
+
+/** Properties */
+
+- (void)setCoordinate:(CLLocationCoordinate2D)coordinate {
+  _coordinate = coordinate;
+  _map4dPOI.position = coordinate;
+}
+
+- (void)setTitle:(NSString *)title {
+  _title = title;
+  _map4dPOI.title = title;
+}
+
+- (void)setTitleColor:(UIColor *)titleColor {
+  _titleColor = titleColor;
+  _map4dPOI.color = titleColor;
+}
+
+- (void)setSubtitle:(NSString *)subtitle {
+  _subtitle = subtitle;
+  _map4dPOI.subtitle = subtitle;
+}
+
+- (void)setPoiType:(NSString *)poiType {
+  _poiType = poiType;
+  _map4dPOI.type = poiType;
+}
+- (void)setIcon:(RMFIcon *)icon {
+  _icon = icon;
+  if (icon == nil || icon.uri == nil) {
+    _map4dPOI.icon = nil;
+    return;
+  }
+
+  dispatch_async(dispatch_get_global_queue(0,0), ^{
+    NSData * imageData = [[NSData alloc] initWithContentsOfURL: [NSURL URLWithString: icon.uri]];
+    if (imageData != nil) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        UIImage* icon = [UIImage imageWithData:imageData];
+        self->_map4dPOI.icon = [UIImage imageWithCGImage:[icon CGImage]
+                                                   scale:[UIScreen mainScreen].scale
+                                             orientation:icon.imageOrientation];
+      });
+    }
+  });
+}
+
+- (void)setZIndex:(float)zIndex {
+  _zIndex = zIndex;
+  _map4dPOI.zIndex = zIndex;
+}
+
+- (void)setVisible:(BOOL)visible {
+  _visible = visible;
+  _map4dPOI.isHidden = !visible;
+}
+
+- (void)setUserInteractionEnabled:(BOOL)enabled {
+  [super setUserInteractionEnabled:enabled];
+  _map4dPOI.userInteractionEnabled = enabled;
+}
+
+ - (void)setUserData:(NSDictionary *)userData {
+   _userData = userData;
+//   _map4dPOI.userData = userData;
+ }
+
+/** Event */
+
+- (void)didTapAtPixel:(CGPoint)pixel {
+  if (!self.onPress) {
+    return;
+  }
+  
+  CLLocationCoordinate2D tapLocation = [_map4dPOI.map.projection coordinateForPoint:pixel];
+  NSMutableDictionary* response = [NSMutableDictionary dictionaryWithDictionary:[RMFEventResponse fromCoordinate:tapLocation
+                                                                                                           pixel:pixel]];
+  response[@"poi"] = @{
+    kRMFLatLngCoordinateResponseKey: [RMFEventResponse fromCoordinate:_coordinate],
+    @"title": _title,
+    @"userData": _userData != nil ? _userData : @{}
+  };
+  response[@"action"] = @"poi-press";
+  
+  self.onPress(response);
+}
+
+@end

package/ios/RMFPOIManager.h

@@ -0,0 +1,18 @@
+//
+//  RMFPOIManager.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPOIManager_h
+#define RMFPOIManager_h
+
+#import <React/RCTViewManager.h>
+
+@interface RMFPOIManager : RCTViewManager
+
+@end
+
+#endif /* RMFPOIManager_h */