react-native-map4d-map-dtqg 0.1.0

package/ios/RMFPOIManager.m

@@ -0,0 +1,168 @@
+//
+//  RMFPOIManager.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPOIManager.h"
+#import "RMFPOI.h"
+#import "RCTConvert+Map4dMap.h"
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTConvert+CoreLocation.h>
+#import <Foundation/Foundation.h>
+
+@implementation RMFPOIManager
+
+RCT_EXPORT_MODULE(RMFPOI)
+
+- (UIView *)view {
+  RMFPOI * poi = [[RMFPOI alloc] init];
+  return poi;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(coordinate, CLLocationCoordinate2D)
+RCT_EXPORT_VIEW_PROPERTY(title, NSString)
+RCT_EXPORT_VIEW_PROPERTY(titleColor, UIColor)
+RCT_EXPORT_VIEW_PROPERTY(subtitle, NSString)
+RCT_EXPORT_VIEW_PROPERTY(poiType, NSString)
+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(userInteractionEnabled, BOOL)
+
+RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
+
+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:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setCoordinate:[RCTConvert CLLocationCoordinate2D:coordinate]];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setTitle:(nonnull NSNumber *)reactTag
+                  withTitle:(NSString*)title)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setTitle:title];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setTitleColor:(nonnull NSNumber *)reactTag
+                  withColor:(id)json)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      UIColor* color = [RCTConvert UIColor:json];
+      if (color != nil) {
+        [poi setTitleColor:color];
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setSubTitle:(nonnull NSNumber *)reactTag
+                  withSubTitle:(NSString*)subTitle)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setSubtitle:subTitle];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setPoiType:(nonnull NSNumber *)reactTag
+                  withType:(NSString*)type)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setPoiType:type];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setIcon:(nonnull NSNumber *)reactTag
+                  withIcon:(id)json)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setIcon:[RCTConvert RMFIcon:json]];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setZIndex:(nonnull NSNumber *)reactTag
+                  withZIndex:(float)zIndex)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi 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:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi 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:[RMFPOI class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
+    } else {
+      RMFPOI *poi = (RMFPOI *)view;
+      [poi setUserData:[RCTConvert NSDictionary:json]];
+    }
+  }];
+}
+
+@end

package/ios/RMFPOIMap4d.h

@@ -0,0 +1,22 @@
+//
+//  RMFPOIMap4d.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPOIMap4d_h
+#define RMFPOIMap4d_h
+
+#import <Map4dMap/Map4dMap.h>
+
+@class RMFPOI;
+
+@interface RMFPOIMap4d : MFPOI
+
+@property (nonatomic, weak) RMFPOI * reactPOI;
+
+@end
+
+#endif /* RMFPOIMap4d_h */

package/ios/RMFPOIMap4d.m

@@ -0,0 +1,12 @@
+//
+//  RMFPOIMap4d.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/5/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPOIMap4d.h"
+
+@implementation RMFPOIMap4d
+@end

package/ios/RMFPolygon.h

@@ -0,0 +1,41 @@
+//
+//  RMFPolygon.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 10/7/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPolygon_h
+#define RMFPolygon_h
+
+#import <React/UIView+React.h>
+#import <Map4dMap/Map4dMap.h>
+#import "RMFPolygonMap4d.h"
+#import "RMFMapView.h"
+#import "RMFCoordinate.h"
+
+@interface RMFPolygon : UIView
+
+@property (nonatomic, strong) RMFPolygonMap4d* map4dPolygon;
+
+@property (nonatomic, copy) RCTBubblingEventBlock _Nullable onPress;
+
+@property (nonatomic, strong) NSArray<RMFCoordinate*>* coordinates;
+@property (nonatomic, strong) NSArray<NSArray<RMFCoordinate*>*>* holes;
+
+@property (nonatomic, assign) UIColor* fillColor;
+@property (nonatomic, assign) CGFloat strokeWidth;
+@property (nonatomic, assign) UIColor* strokeColor;
+
+@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 /* RMFPolygon_h */

package/ios/RMFPolygon.m

@@ -0,0 +1,106 @@
+//
+//  RMFPolygon.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 10/7/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPolygon.h"
+#import "RMFEventResponse.h"
+
+@implementation RMFPolygon
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _map4dPolygon = [[RMFPolygonMap4d alloc] init];
+    _map4dPolygon.reactPolygon = self;
+    
+    _coordinates = nil;
+    _holes = nil;
+    _fillColor = _map4dPolygon.fillColor;
+    _strokeColor = _map4dPolygon.strokeColor;
+    _strokeWidth = _map4dPolygon.strokeWidth;
+    _zIndex = _map4dPolygon.zIndex;
+    _visible = true;
+    _userData = nil;
+  }
+  return self;
+}
+
+- (void)setMapView:(RMFMapView *)mapView {
+  _map4dPolygon.map = mapView;
+}
+
+/** Properties */
+
+- (void)setCoordinates:(NSArray<RMFCoordinate *> *)coordinates {
+  _coordinates = coordinates;
+  MFMutablePath* path = [[MFMutablePath alloc] init];
+  for (int i = 0; i < coordinates.count; i++) {
+    [path addCoordinate:coordinates[i].coordinate];
+  }
+  _map4dPolygon.path = path;
+}
+
+- (void)setHoles:(NSArray<NSArray<RMFCoordinate *> *> *)holes {
+  _holes = holes;
+  
+  NSMutableArray<MFPath*>* polygonHoles = [[NSMutableArray alloc] init];
+  for (int i = 0; i < holes.count; i++) {
+    NSArray<RMFCoordinate*>* coordinates = [holes objectAtIndex:i];
+    MFMutablePath* path = [[MFMutablePath alloc] init];
+    for (int j = 0; j < coordinates.count; j++) {
+      [path addCoordinate:coordinates[j].coordinate];
+    }
+    [polygonHoles addObject:path];
+  }
+  _map4dPolygon.holes = polygonHoles;
+}
+
+- (void)setFillColor:(UIColor *)fillColor {
+  _fillColor = fillColor;
+  _map4dPolygon.fillColor = fillColor;
+}
+
+- (void)setStrokeColor:(UIColor *)strokeColor {
+  _strokeColor = strokeColor;
+  _map4dPolygon.strokeColor = strokeColor;
+}
+
+- (void)setStrokeWidth:(CGFloat)strokeWidth {
+  _strokeWidth = strokeWidth;
+  _map4dPolygon.strokeWidth = strokeWidth;
+}
+
+- (void)setZIndex:(float)zIndex {
+  _zIndex = zIndex;
+  _map4dPolygon.zIndex = zIndex;
+}
+
+- (void)setVisible:(BOOL)visible {
+  _visible = visible;
+  _map4dPolygon.isHidden = !visible;
+}
+
+- (void)setUserData:(NSDictionary *)userData {
+  _userData = userData;
+}
+/** Event */
+- (void)didTapAtPixel:(CGPoint)pixel {
+  if (!self.onPress) {
+    return;
+  }
+  
+  CLLocationCoordinate2D tapLocation = [_map4dPolygon.map.projection coordinateForPoint:pixel];
+  NSMutableDictionary* response = [NSMutableDictionary dictionaryWithDictionary:[RMFEventResponse fromCoordinate:tapLocation
+                                                                                                           pixel:pixel]];
+  response[@"polygon"] = @{
+    @"userData": _userData != nil ? _userData : @{}
+  };
+  response[@"action"] = @"polygon-press";
+  
+  self.onPress(response);
+}
+
+@end

package/ios/RMFPolygonManager.h

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

package/ios/RMFPolygonManager.m

@@ -0,0 +1,141 @@
+//
+//  RMFPolygonManager.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 10/7/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPolygonManager.h"
+#import "RMFPolygon.h"
+#import "RCTConvert+Map4dMap.h"
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <Foundation/Foundation.h>
+
+@implementation RMFPolygonManager
+
+RCT_EXPORT_MODULE(RMFPolygon)
+
+- (UIView *)view {
+  RMFPolygon* polygon = [[RMFPolygon alloc] init];
+  return polygon;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(coordinates, RMFCoordinateArray)
+RCT_EXPORT_VIEW_PROPERTY(holes, RMFCoordinateArrayArray)
+RCT_EXPORT_VIEW_PROPERTY(fillColor, UIColor)
+RCT_EXPORT_VIEW_PROPERTY(strokeColor, UIColor)
+RCT_EXPORT_VIEW_PROPERTY(strokeWidth, CGFloat)
+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_METHOD(setCoordinates:(nonnull NSNumber *)reactTag
+                  withCoordinates:(id)coordinates)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      [polygon setCoordinates:[RCTConvert RMFCoordinateArray:coordinates]];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setHoles:(nonnull NSNumber *)reactTag
+                  withHoles:(id)holes)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      [polygon setHoles:[RCTConvert RMFCoordinateArrayArray:holes]];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setFillColor:(nonnull NSNumber *)reactTag
+                  color:(id)json)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      UIColor* color = [RCTConvert UIColor:json];
+      if (color != nil) {
+        [polygon setFillColor:color];
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setStrokeColor:(nonnull NSNumber *)reactTag
+                  color:(id)json)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      UIColor* color = [RCTConvert UIColor:json];
+      if (color != nil) {
+        [polygon setStrokeColor:color];
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(setStrokeWidth:(nonnull NSNumber *)reactTag
+                  width:(CGFloat)width)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      [polygon setStrokeWidth:width];
+    }
+  }];
+}
+
+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:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      [polygon 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:[RMFPolygon class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
+    } else {
+      RMFPolygon *polygon = (RMFPolygon *)view;
+      [polygon setUserData:[RCTConvert NSDictionary:json]];
+    }
+  }];
+}
+
+@end

package/ios/RMFPolygonMap4d.h

@@ -0,0 +1,23 @@
+//
+//  RMFPolygonMap4d.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 10/7/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPolygonMap4d_h
+#define RMFPolygonMap4d_h
+
+#import <Map4dMap/Map4dMap.h>
+
+@class RMFPolygon;
+
+@interface RMFPolygonMap4d : MFPolygon
+
+@property (nonatomic, weak) RMFPolygon *reactPolygon;
+
+@end
+
+
+#endif /* RMFPolygonMap4d_h */

package/ios/RMFPolygonMap4d.m

@@ -0,0 +1,15 @@
+//
+//  RMFPolygonMap4d.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 10/7/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPolygonMap4d.h"
+
+@implementation RMFPolygonMap4d
+
+
+
+@end

package/ios/RMFPolyline.h

@@ -0,0 +1,38 @@
+//
+//  RMFPolyline.h
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/3/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#ifndef RMFPolyline_h
+#define RMFPolyline_h
+
+#import <React/UIView+React.h>
+#import <Map4dMap/Map4dMap.h>
+#import "RMFPolylineMap4d.h"
+#import "RMFMapView.h"
+#import "RMFCoordinate.h"
+
+@interface RMFPolyline : UIView
+
+@property (nonatomic, strong) RMFPolylineMap4d * map4dPolyline;
+
+@property (nonatomic, copy) RCTBubblingEventBlock _Nullable onPress;
+
+@property(nonatomic, strong) NSArray<RMFCoordinate *> * coordinates;
+@property(nonatomic, assign) CGFloat width;
+@property(nonatomic, assign) NSString * lineStyle;
+@property(nonatomic, assign, nullable) UIColor * color;
+@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 /* RMFPolyline_h */

package/ios/RMFPolyline.m

@@ -0,0 +1,101 @@
+//
+//  RMFPolyline.m
+//  Map4dMap
+//
+//  Created by Huy Dang on 7/3/20.
+//  Copyright © 2020 IOTLink. All rights reserved.
+//
+
+#import "RMFPolyline.h"
+#import "RMFEventResponse.h"
+
+@implementation RMFPolyline
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _map4dPolyline = [[RMFPolylineMap4d alloc] init];
+    _map4dPolyline.reactPolyline = self;
+    
+    _coordinates = nil;
+    _width = _map4dPolyline.width;
+    _lineStyle = @"solid";//MFPolylineStyleSolid
+    _color = _map4dPolyline.color;
+    _zIndex = _map4dPolyline.zIndex;
+    _visible = true;//!_map4dPolyline.isHidden
+    _userData = nil;
+  }
+  return self;
+}
+
+- (void)setMapView:(RMFMapView *)mapView {
+  _map4dPolyline.map = mapView;
+}
+
+/** Properties */
+
+- (void)setCoordinates:(NSArray<RMFCoordinate *> *)coordinates {
+  _coordinates = coordinates;
+  MFMutablePath* path = [[MFMutablePath alloc] init];
+  for(int i = 0; i < coordinates.count; i++)
+  {
+    [path addCoordinate:coordinates[i].coordinate];
+  }
+  _map4dPolyline.path = path;
+}
+
+- (void)setWidth:(CGFloat)width {
+  _width = width;
+  _map4dPolyline.width = width;
+}
+
+- (void)setColor:(UIColor *)color {
+  _color = color;
+  _map4dPolyline.color = color;
+}
+
+- (void)setLineStyle:(NSString *)lineStyle {
+  _lineStyle = lineStyle;
+  if ([lineStyle isEqualToString:@"dotted"]) {
+    _map4dPolyline.strokePattern = [MFStrokePattern dashWithLength:_width gap:_width];
+  } else {
+    _map4dPolyline.strokePattern = MFStrokePattern.solid;
+  }
+}
+
+- (void)setZIndex:(float)zIndex {
+  _zIndex = zIndex;
+  _map4dPolyline.zIndex = zIndex;
+}
+
+- (void)setVisible:(BOOL)visible {
+  _visible = visible;
+  _map4dPolyline.isHidden = !visible;
+}
+
+- (void)setUserInteractionEnabled:(BOOL)enabled {
+  [super setUserInteractionEnabled:enabled];
+  _map4dPolyline.userInteractionEnabled = enabled;
+}
+
+ - (void)setUserData:(NSDictionary *)userData {
+   _userData = userData;
+ }
+
+/** Event */
+- (void)didTapAtPixel:(CGPoint)pixel {
+  if (!self.onPress) {
+    return;
+  }
+  
+  CLLocationCoordinate2D tapLocation = [_map4dPolyline.map.projection coordinateForPoint:pixel];
+  NSMutableDictionary* response = [NSMutableDictionary dictionaryWithDictionary:[RMFEventResponse fromCoordinate:tapLocation
+                                                                                                           pixel:pixel]];
+  response[@"polyline"] = @{
+    @"userData": _userData != nil ? _userData : @{}
+  };
+  response[@"action"] = @"polyline-press";
+  
+  self.onPress(response);
+}
+
+@end