react-native-maps 0.29.2 → 0.30.1

package/lib/components/MapUrlTile.js

@@ -28,12 +28,20 @@ const propTypes = {
    * @platform android
    */
   zIndex: PropTypes.number,
+
   /**
    * The maximum zoom level for this tile overlay.
    *
    */
   maximumZ: PropTypes.number,
 
+  /**
+   * (Optional) The maximum native zoom level for this tile overlay. Tiles are auto-scaled for higher
+   * zoom levels.
+   *
+   */
+  maximumNativeZ: PropTypes.number,
+
   /**
    * The minimum zoom level for this tile overlay.
    *
@@ -48,12 +56,20 @@ const propTypes = {
   shouldReplaceMapContent: PropTypes.bool,
 
   /**
-   * (Optional) Tile size for iOS only, default size is 256 * 256.
+   * (Optional) Tile size only, default size is 256 (for tiles of 256 * 256 pixels)
    *
-   * @platform ios
    */
   tileSize: PropTypes.number,
 
+  /**
+   * (Optional) Doubles tile size from 256 to 512 utilising higher zoom levels i.e.
+   * loading 4 higher zoom level tiles and combining them for one high-resolution
+   * tile. iOS does this automatically, even if it is not desirable always.
+   *
+   *  @platform android
+   */
+  doubleTileSize: PropTypes.bool,
+
   /**
    *
    * Allow tiles using the TMS coordinate system (origin bottom left)
@@ -61,6 +77,42 @@ const propTypes = {
    *
    */
   flipY: PropTypes.bool,
+
+  /**
+   *
+   * (Optional) Enable caching of tiles in the specified directory. Directory
+   * can be specified either as a normal path or in URL format (file://). Tiles
+   * are stored in tileCachePath directory as follows "/{z}/{x}/{y}" i.e. in
+   * sub-directories 2-levels deep, filename tile y-coordinate without any
+   * filetype-extension.
+   * NB! All cache management needs to be implemented by client e.g. deleting tiles
+   * to manage use of storage space etc.
+   *
+   */
+  tileCachePath: PropTypes.string,
+
+  /**
+   * (Optional) Defines how maximum age in seconds for cached tile before they
+   * are refreshed. NB! Refresh logic is "serve-stale-while-refresh" i.e. to
+   * ensure map availability a stale (over max age) tile is served while a tile
+   * refresh process is started in the background.
+   */
+  tileCacheMaxAge: PropTypes.number,
+
+  /**
+   * (Optional) Sets offline-mode. In offline-mode tiles are not fetched from
+   * the tile servers, rather only tiles stored in the cache directory are used.
+   * Furthermore automated tile scaling is activated: if tile at a desired zoom
+   * level is not found from the cache directory, then lower zoom level tile is
+   * used (until minimumZ) and scaled.
+   */
+  offlineMode: PropTypes.bool,
+
+  /**
+   * (Optional) Map layer opacity. Value between 0 - 1, with 0 meaning fully
+   * transparent.
+   */
+  opacity: PropTypes.number,
 };
 
 class MapUrlTile extends React.Component {

package/lib/components/MapView.js

@@ -1042,7 +1042,7 @@ class MapView extends React.Component {
     if (Platform.OS === 'android' && this.props.liteMode) {
       return (
         <AIRMapLite
-          ref={ref => {
+          ref={(ref) => {
             this.map = ref;
           }}
           {...props}
@@ -1054,7 +1054,7 @@ class MapView extends React.Component {
 
     return (
       <AIRMap
-        ref={ref => {
+        ref={(ref) => {
           this.map = ref;
         }}
         {...props}
@@ -1069,7 +1069,7 @@ MapView.childContextTypes = childContextTypes;
 
 MapView.MAP_TYPES = MAP_TYPES;
 
-const nativeComponent = Component =>
+const nativeComponent = (Component) =>
   requireNativeComponent(Component, MapView, {
     nativeOnly: {
       onChange: true,
@@ -1090,7 +1090,7 @@ if (Platform.OS === 'android') {
         'react-native-maps: AirGoogleMaps dir must be added to your xCode project to support GoogleMaps on iOS.'
       );
 }
-const getAirMapComponent = provider => airMaps[provider || 'default'];
+const getAirMapComponent = (provider) => airMaps[provider || 'default'];
 
 let AIRMapLite;
 if (!NativeModules.UIManager.getViewManagerConfig) {

package/lib/components/MapWMSTile.js

@@ -29,12 +29,20 @@ const propTypes = {
    * @platform android
    */
   zIndex: PropTypes.number,
+
   /**
    * The maximum zoom level for this tile overlay.
    *
    */
   maximumZ: PropTypes.number,
 
+  /**
+   * (Optional) The maximum native zoom level for this tile overlay. Tiles are auto-scaled for higher
+   * zoom levels.
+   *
+   */
+  maximumNativeZ: PropTypes.number,
+
   /**
    * The minimum zoom level for this tile overlay.
    *
@@ -47,15 +55,54 @@ const propTypes = {
    * @platform ios
    */
   shouldReplaceMapContent: PropTypes.bool,
+
   /**
-   * tileSize.
+   * (Optional) Tile size only, default size is 256 (for tiles of 256 * 256 pixels)
    *
    */
   tileSize: PropTypes.number,
 
   /**
-   * opacity. between 0 - 1
    *
+   * Allow tiles using the TMS coordinate system (origin bottom left)
+   * to be used, and displayed at their correct coordinates
+   *
+   */
+  flipY: PropTypes.bool,
+
+  /**
+   *
+   * (Optional) Enable caching of tiles in the specified directory. Directory
+   * can be specified either as a normal path or in URL format (file://). Tiles
+   * are stored in tileCachePath directory as follows "/{z}/{x}/{y}" i.e. in
+   * sub-directories 2-levels deep, filename tile y-coordinate without any
+   * filetype-extension.
+   * NB! All cache management needs to be implemented by client e.g. deleting tiles
+   * to manage use of storage space etc.
+   *
+   */
+  tileCachePath: PropTypes.string,
+
+  /**
+   * (Optional) Defines how maximum age in seconds for cached tile before they
+   * are refreshed. NB! Refresh logic is "serve-stale-while-refresh" i.e. to
+   * ensure map availability a stale (over max age) tile is served while a tile
+   * refresh process is started in the background.
+   */
+  tileCacheMaxAge: PropTypes.number,
+
+  /**
+   * (Optional) Sets offline-mode. In offline-mode tiles are not fetched from
+   * the tile servers, rather only tiles stored in the cache directory are used.
+   * Furthermore automated tile scaling is activated: if tile at a desired zoom
+   * level is not found from the cache directory, then lower zoom level tile is
+   * used (until minimumZ) and scaled.
+   */
+  offlineMode: PropTypes.bool,
+
+  /**
+   * (Optional) Map layer opacity. Value between 0 - 1, with 0 meaning fully
+   * transparent.
    */
   opacity: PropTypes.number,
 };

package/lib/components/decorateMapComponent.js

@@ -24,7 +24,7 @@ export const contextTypes = {
   provider: PropTypes.string,
 };
 
-export const createNotSupportedComponent = message => () => {
+export const createNotSupportedComponent = (message) => () => {
   console.error(message);
   return null;
 };

package/lib/ios/AirGoogleMaps/AIRGoogleMapMarker.h

@@ -36,6 +36,7 @@
 @property (nonatomic, assign) NSInteger zIndex;
 @property (nonatomic, assign) double opacity;
 @property (nonatomic, assign) BOOL draggable;
+@property (nonatomic, assign) BOOL tappable;
 @property (nonatomic, assign) BOOL tracksViewChanges;
 @property (nonatomic, assign) BOOL tracksInfoWindowChanges;
 

package/lib/ios/AirGoogleMaps/AIRGoogleMapMarker.m

@@ -391,6 +391,14 @@ CGRect unionRect(CGRect a, CGRect b) {
   return _realMarker.draggable;
 }
 
+- (void)setTappable:(BOOL)tappable {
+  _realMarker.tappable = tappable;
+}
+
+- (BOOL)tappable {
+  return _realMarker.tappable;
+}
+
 - (void)setFlat:(BOOL)flat {
   _realMarker.flat = flat;
 }

package/lib/ios/AirGoogleMaps/AIRGoogleMapMarkerManager.m

@@ -44,6 +44,7 @@ RCT_EXPORT_VIEW_PROPERTY(anchor, CGPoint)
 RCT_EXPORT_VIEW_PROPERTY(calloutAnchor, CGPoint)
 RCT_EXPORT_VIEW_PROPERTY(zIndex, NSInteger)
 RCT_EXPORT_VIEW_PROPERTY(draggable, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(tappable, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(flat, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(tracksViewChanges, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(tracksInfoWindowChanges, BOOL)

package/lib/ios/AirMaps/AIRMapManager.m

@@ -734,7 +734,11 @@ RCT_EXPORT_METHOD(getAddressFromCoordinates:(nonnull NSNumber *)reactTag
                 if (CGPathContainsPoint(mpr, NULL, mapPointAsCGP, FALSE)) {
                     id event = @{
                                 @"action": @"polygon-press",
-                                };
+                                @"coordinate": @{
+                                    @"latitude": @(tapCoordinate.latitude),
+                                    @"longitude": @(tapCoordinate.longitude),
+                                },
+                            };
                     polygon.onPress(event);
                 }
 
@@ -1018,6 +1022,7 @@ static int kDragCenterContext;
                          @"accuracy": @(location.location.horizontalAccuracy),
                          @"altitudeAccuracy": @(location.location.verticalAccuracy),
                          @"speed": @(location.location.speed),
+                         @"heading": @(location.location.course),
                          }
                  };
     

package/lib/ios/AirMaps/AIRMapMarkerManager.m

@@ -45,6 +45,7 @@ RCT_EXPORT_VIEW_PROPERTY(pinColor, UIColor)
 RCT_EXPORT_VIEW_PROPERTY(draggable, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(zIndex, NSInteger)
 RCT_EXPORT_VIEW_PROPERTY(opacity, double)
+RCT_EXPORT_VIEW_PROPERTY(isPreselected, BOOL)
 
 RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onSelect, RCTDirectEventBlock)

package/lib/ios/AirMaps/AIRMapUrlTile.h

@@ -15,19 +15,37 @@
 #import "AIRMapCoordinate.h"
 #import "AIRMap.h"
 #import "RCTConvert+AirMap.h"
-
-@interface AIRMapUrlTile : MKAnnotationView <MKOverlay>
+#import "AIRMapUrlTileCachedOverlay.h"
+
+@interface AIRMapUrlTile : MKAnnotationView <MKOverlay> {
+	BOOL _urlTemplateSet;
+	BOOL _tileSizeSet;
+	BOOL _flipYSet;
+	BOOL _tileCachePathSet;
+	BOOL _tileCacheMaxAgeSet;
+	BOOL _maximumNativeZSet;
+	BOOL _cachedOverlayCreated;
+	BOOL _opacitySet;
+}
 
 @property (nonatomic, weak) AIRMap *map;
 
-@property (nonatomic, strong) MKTileOverlay *tileOverlay;
+@property (nonatomic, strong) AIRMapUrlTileCachedOverlay *tileOverlay;
 @property (nonatomic, strong) MKTileOverlayRenderer *renderer;
 @property (nonatomic, copy) NSString *urlTemplate;
 @property NSInteger maximumZ;
+@property NSInteger maximumNativeZ;
 @property NSInteger minimumZ;
 @property BOOL flipY;
 @property BOOL shouldReplaceMapContent;
-@property CGFloat tileSize;
+@property NSInteger tileSize;
+@property (nonatomic, copy) NSString *tileCachePath;
+@property NSInteger tileCacheMaxAge;
+@property BOOL offlineMode;
+@property CGFloat opacity;
+
+- (void)updateProperties;
+- (void)update;
 
 #pragma mark MKOverlay protocol
 

package/lib/ios/AirMaps/AIRMapUrlTile.m

@@ -8,66 +8,151 @@
 
 #import "AIRMapUrlTile.h"
 #import <React/UIView+React.h>
+#import "AIRMapUrlTileCachedOverlay.h"
 
-@implementation AIRMapUrlTile {
-    BOOL _urlTemplateSet;
-    BOOL _tileSizeSet;
-}
+@implementation AIRMapUrlTile 
 
 - (void)setShouldReplaceMapContent:(BOOL)shouldReplaceMapContent
 {
-  _shouldReplaceMapContent = shouldReplaceMapContent;
-  if(self.tileOverlay) {
-    self.tileOverlay.canReplaceMapContent = _shouldReplaceMapContent;
-  }
-  [self update];
+    _shouldReplaceMapContent = shouldReplaceMapContent;
+    if (self.tileOverlay) {
+        self.tileOverlay.canReplaceMapContent = _shouldReplaceMapContent;
+    }
+    [self update];
 }
 
-- (void)setMaximumZ:(NSUInteger)maximumZ
+- (void)setMaximumZ:(NSInteger)maximumZ
 {
-  _maximumZ = maximumZ;
-  if(self.tileOverlay) {
-    self.tileOverlay.maximumZ = _maximumZ;
-  }
-  [self update];
+    _maximumZ = maximumZ;
+    if (self.tileOverlay) {
+        self.tileOverlay.maximumZ = _maximumZ;
+    }
+    [self update];
 }
 
-- (void)setMinimumZ:(NSUInteger)minimumZ
+- (void)setMaximumNativeZ:(NSInteger)maximumNativeZ
 {
-  _minimumZ = minimumZ;
-  if(self.tileOverlay) {
-    self.tileOverlay.minimumZ = _minimumZ;
-  }
-  [self update];
+    _maximumNativeZ = maximumNativeZ;
+    _maximumNativeZSet = YES;
+    if (_cachedOverlayCreated) {
+        self.tileOverlay.maximumNativeZ = _maximumNativeZ;
+    } else {
+        [self createTileOverlayAndRendererIfPossible];
+    }
+    [self update];
+}
+
+- (void)setMinimumZ:(NSInteger)minimumZ
+{
+    _minimumZ = minimumZ;
+    if (self.tileOverlay) {
+        self.tileOverlay.minimumZ = _minimumZ;
+    }
+    [self update];
 }
 
 - (void)setFlipY:(BOOL)flipY
 {
-  _flipY = flipY;
-  if (self.tileOverlay) {
-    self.tileOverlay.geometryFlipped = _flipY;
-  }
+    _flipY = flipY;
+    _flipYSet = YES;
+    if (self.tileOverlay) {
+        self.tileOverlay.geometryFlipped = _flipY;
+    }
+    [self update];
 }
 
-- (void)setUrlTemplate:(NSString *)urlTemplate{
+- (void)setUrlTemplate:(NSString *)urlTemplate
+{
     _urlTemplate = urlTemplate;
     _urlTemplateSet = YES;
     [self createTileOverlayAndRendererIfPossible];
     [self update];
 }
 
-- (void)setTileSize:(CGFloat)tileSize{
+- (void)setTileSize:(NSInteger)tileSize
+{
     _tileSize = tileSize;
     _tileSizeSet = YES;
     [self createTileOverlayAndRendererIfPossible];
     [self update];
 }
 
-- (void) createTileOverlayAndRendererIfPossible
+- (void)setTileCachePath:(NSString *)tileCachePath{
+    if (!tileCachePath) return;
+    _tileCachePath = tileCachePath;
+    _tileCachePathSet = YES;
+    [self createTileOverlayAndRendererIfPossible];
+    [self update];
+}
+
+- (void)setTileCacheMaxAge:(NSInteger)tileCacheMaxAge{
+    _tileCacheMaxAge = tileCacheMaxAge;
+    _tileCacheMaxAgeSet = YES;
+    if (_cachedOverlayCreated) {
+        self.tileOverlay.tileCacheMaxAge = _tileCacheMaxAge;
+    } else {
+        [self createTileOverlayAndRendererIfPossible];
+    }
+    [self update];
+}
+
+- (void)setOfflineMode:(BOOL)offlineMode
+{
+    _offlineMode = offlineMode;
+    if (_cachedOverlayCreated) {
+        self.tileOverlay.offlineMode = _offlineMode;
+    }
+    if (self.renderer) [self.renderer reloadData];
+}
+
+- (void)setOpacity:(CGFloat)opacity
+{
+    _opacity = opacity;
+    _opacitySet = YES;
+    if (self.renderer) {
+        self.renderer.alpha = opacity;
+    } else {
+        [self createTileOverlayAndRendererIfPossible];
+    }
+    [self update];
+}
+
+- (void)createTileOverlayAndRendererIfPossible
 {
     if (!_urlTemplateSet) return;
-    self.tileOverlay = [[MKTileOverlay alloc] initWithURLTemplate:self.urlTemplate];
+    if (_tileCachePathSet || _maximumNativeZSet) {
+        NSLog(@"tileCache dir %@", _tileCachePath);
+        self.tileOverlay = [[AIRMapUrlTileCachedOverlay alloc] initWithURLTemplate:self.urlTemplate];
+        _cachedOverlayCreated = YES;
+        if (_tileCachePathSet) {
+            NSURL *urlPath = [NSURL URLWithString:[self.tileCachePath stringByAppendingString:@"/"]];
+            if (urlPath.fileURL) {
+                self.tileOverlay.tileCachePath = urlPath;
+            } else {
+                NSURL *filePath = [NSURL fileURLWithPath:self.tileCachePath isDirectory:YES];
+                self.tileOverlay.tileCachePath = filePath;
+            }
+
+            if (_tileCacheMaxAgeSet) {
+                self.tileOverlay.tileCacheMaxAge = self.tileCacheMaxAge;
+            }
+        }
+    } else {
+        NSLog(@"tileCache normal overlay");
+        self.tileOverlay = [[MKTileOverlay alloc] initWithURLTemplate:self.urlTemplate];
+        _cachedOverlayCreated = NO;
+    }
+
+    [self updateProperties];
 
+    self.renderer = [[MKTileOverlayRenderer alloc] initWithTileOverlay:self.tileOverlay];
+    if (_opacitySet) {
+        self.renderer.alpha = self.opacity;
+    }
+}
+
+- (void)updateProperties
+{
     self.tileOverlay.canReplaceMapContent = self.shouldReplaceMapContent;
 
     if(self.minimumZ) {
@@ -76,16 +161,21 @@
     if (self.maximumZ) {
         self.tileOverlay.maximumZ = self.maximumZ;
     }
-    if (self.flipY) {
+    if (_cachedOverlayCreated && self.maximumNativeZ) {
+        self.tileOverlay.maximumNativeZ = self.maximumNativeZ;
+    }
+    if (_flipYSet) {
         self.tileOverlay.geometryFlipped = self.flipY;
     }
     if (_tileSizeSet) {
         self.tileOverlay.tileSize = CGSizeMake(self.tileSize, self.tileSize);
     }
-    self.renderer = [[MKTileOverlayRenderer alloc] initWithTileOverlay:self.tileOverlay];
+    if (_cachedOverlayCreated && self.offlineMode) {
+        self.tileOverlay.offlineMode = self.offlineMode;
+    }
 }
 
-- (void) update
+- (void)update
 {
     if (!_renderer) return;
     
@@ -103,12 +193,12 @@
 
 #pragma mark MKOverlay implementation
 
-- (CLLocationCoordinate2D) coordinate
+- (CLLocationCoordinate2D)coordinate
 {
     return self.tileOverlay.coordinate;
 }
 
-- (MKMapRect) boundingMapRect
+- (MKMapRect)boundingMapRect
 {
     return self.tileOverlay.boundingMapRect;
 }

package/lib/ios/AirMaps/AIRMapUrlTileCachedOverlay.h

@@ -0,0 +1,17 @@
+//
+//  AIRMapUrlTileCachedOverlay.h
+//  Airmaps
+//
+//  Created by Markus Suomi on 10/04/2021.
+//
+
+#import <MapKit/MapKit.h>
+
+@interface AIRMapUrlTileCachedOverlay : MKTileOverlay
+
+@property NSInteger maximumNativeZ;
+@property (nonatomic, copy) NSURL *tileCachePath;
+@property NSInteger tileCacheMaxAge;
+@property BOOL offlineMode;
+
+@end