react-native-maps 0.29.4 → 0.30.0

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

package/lib/ios/AirMaps/AIRMapUrlTileCachedOverlay.m

@@ -0,0 +1,235 @@
+//
+//  AIRMapUrlTileCachedOverlay.m
+//  Airmaps
+//
+//  Created by Markus Suomi on 10/04/2021.
+//
+
+#import "AIRMapUrlTileCachedOverlay.h"
+
+@interface AIRMapUrlTileCachedOverlay ()
+
+@end
+
+@implementation AIRMapUrlTileCachedOverlay {
+    CIContext *_ciContext;
+    CGColorSpaceRef _colorspace;
+    NSURLSession *_urlSession;
+}
+
+- (void)loadTileAtPath:(MKTileOverlayPath)path result:(void (^)(NSData *, NSError *))result
+{
+    if (!result) return;
+
+    NSInteger maximumZ = self.maximumNativeZ ? self.maximumNativeZ : path.z;
+    [self scaleIfNeededLowerZoomTile:path maximumZ:maximumZ result:^(NSData *image, NSError *error) {
+        if (!image && self.offlineMode && self.tileCachePath) {
+            NSInteger zoomLevelToStart = (path.z > maximumZ) ? maximumZ - 1 : path.z - 1; 
+            NSInteger minimumZoomToSearch = self.minimumZ >= zoomLevelToStart - 3 ? self.minimumZ : zoomLevelToStart - 3;
+            [self findLowerZoomTileAndScale:path tryZ:zoomLevelToStart minZ:minimumZoomToSearch result:result];
+        } else {
+            result(image, error);
+        }    
+    }];
+}
+
+- (void)scaleIfNeededLowerZoomTile:(MKTileOverlayPath)path maximumZ:(NSInteger)maximumZ result:(void (^)(NSData *, NSError *))result
+{
+    NSInteger overZoomLevel = path.z - maximumZ;
+    if (overZoomLevel <= 0) {
+        [self getTileImage:path result:result];
+        return;
+    }
+
+    NSInteger zoomFactor = 1 << overZoomLevel;
+    
+    MKTileOverlayPath parentTile;
+    parentTile.x = path.x >> overZoomLevel;
+    parentTile.y = path.y >> overZoomLevel;
+    parentTile.z = path.z - overZoomLevel;
+    parentTile.contentScaleFactor = path.contentScaleFactor;
+    
+    NSInteger xOffset = path.x % zoomFactor;
+    NSInteger yOffset = path.y % zoomFactor;
+    NSInteger subTileSize = self.tileSize.width / zoomFactor;
+
+    if (!_ciContext) _ciContext = [CIContext context];
+    if (!_colorspace) _colorspace = CGColorSpaceCreateDeviceRGB();
+
+    [self getTileImage:parentTile result:^(NSData *image, NSError *error) {
+        if (!image) {
+            result(nil, nil);
+            return;
+        }
+
+        CIImage* originalCIImage = [CIImage imageWithData:image];
+
+        CGRect rect;
+        rect.origin.x = xOffset * subTileSize;
+        rect.origin.y = self.tileSize.width - (yOffset + 1) * subTileSize;
+        rect.size.width = subTileSize;
+        rect.size.height = subTileSize;
+        CIVector *inputRect = [CIVector vectorWithCGRect:rect];
+        CIFilter* cropFilter = [CIFilter filterWithName:@"CICrop"];
+        [cropFilter setValue:originalCIImage forKey:@"inputImage"];
+        [cropFilter setValue:inputRect forKey:@"inputRectangle"];
+
+        CGAffineTransform trans = CGAffineTransformMakeScale(zoomFactor, zoomFactor);
+        CIImage* scaledCIImage = [cropFilter.outputImage imageByApplyingTransform:trans];
+
+        NSData *finalImage = [_ciContext PNGRepresentationOfImage:scaledCIImage format:kCIFormatABGR8 colorSpace:_colorspace options:nil];
+        result(finalImage, nil);
+    }];    
+}
+
+- (void)findLowerZoomTileAndScale:(MKTileOverlayPath)path tryZ:(NSInteger)tryZ minZ:(NSInteger)minZ result:(void (^)(NSData *, NSError *))result
+{
+    [self scaleIfNeededLowerZoomTile:path maximumZ:tryZ result:^(NSData *image, NSError *error) {
+        if (image) {
+            result(image, error);
+        } else if (tryZ >= minZ) {
+            [self findLowerZoomTileAndScale:path tryZ:tryZ - 1 minZ:minZ result:result];
+        } else {
+            result(nil, nil);
+        }
+    }];
+}
+
+- (void)getTileImage:(MKTileOverlayPath)path result:(void (^)(NSData *, NSError *))result
+{
+    NSData *image;
+    NSURL *tileCacheFileDirectory = [NSURL URLWithString:[NSString stringWithFormat:@"%d/%d/", (int)path.z, (int)path.x] relativeToURL:self.tileCachePath];
+    NSURL *tileCacheFilePath = [NSURL URLWithString:[NSString stringWithFormat:@"%d", (int)path.y] relativeToURL:tileCacheFileDirectory];
+
+    if (self.tileCachePath) {
+        image = [self readTileImage:path fromFilePath:tileCacheFilePath];
+        if (image) {
+            result(image, nil);
+            if (!self.offlineMode && self.tileCacheMaxAge) {
+                [self checkForRefresh:path fromFilePath:tileCacheFilePath];
+            }
+        }
+    }
+
+    if (!image) {
+        if (!self.offlineMode) {
+            [self fetchTile:path result:^(NSData *image, NSError *error) {
+                result(image, error);
+                if (image && self.tileCachePath) {
+                    [self writeTileImage:tileCacheFileDirectory withTileCacheFilePath:tileCacheFilePath withTileData:image];
+                }
+            }];
+        } else {
+            result(nil, nil);
+        }
+    }
+}
+
+- (NSData *)readTileImage:(MKTileOverlayPath)path fromFilePath:(NSURL *)tileCacheFilePath
+{
+    NSError *error;
+
+    if ([[NSFileManager defaultManager] fileExistsAtPath:[tileCacheFilePath path]]) {
+        if (!self.tileCacheMaxAge) {
+            [[NSFileManager defaultManager] setAttributes:@{NSFileModificationDate:[NSDate date]}
+                            ofItemAtPath:[tileCacheFilePath path]
+                                    error:&error];
+        }
+
+        NSData *tile = [NSData dataWithContentsOfFile:[tileCacheFilePath path]];
+        NSLog(@"tileCache HIT for %d_%d_%d", (int)path.z, (int)path.x, (int)path.y);
+        NSLog(@"tileCache HIT, with max age set at %d", self.tileCacheMaxAge);
+        return tile;
+    } else {
+        NSLog(@"tileCache MISS for %d_%d_%d", (int)path.z, (int)path.x, (int)path.y);
+        return nil;
+    }
+}
+
+- (void)fetchTile:(MKTileOverlayPath)path result:(void (^)(NSData *, NSError *))result
+{
+    if (!_urlSession) [self createURLSession];
+
+    [[_urlSession dataTaskWithURL:[self URLForTilePath:path]
+        completionHandler:^(NSData *data,
+                            NSURLResponse *response,
+                            NSError *error) {
+            result(data, error);
+        }] resume];
+}
+
+- (void)writeTileImage:(NSURL *)tileCacheFileDirectory withTileCacheFilePath:(NSURL *)tileCacheFilePath withTileData:(NSData *)data
+{
+    NSError *error;
+    
+    if (![[NSFileManager defaultManager] fileExistsAtPath:[tileCacheFileDirectory path]]) {
+        [[NSFileManager defaultManager] createDirectoryAtPath:[tileCacheFileDirectory path] withIntermediateDirectories:YES attributes:nil error:&error];
+        if (error) {
+            NSLog(@"Error: %@", error);
+            return;
+        }
+    }
+
+    [[NSFileManager defaultManager] createFileAtPath:[tileCacheFilePath path] contents:data attributes:nil];
+    NSLog(@"tileCache SAVED tile %@", [tileCacheFilePath path]);
+}
+
+- (void)createTileCacheDirectory
+{
+    NSError *error;
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *documentsDirectory = [paths objectAtIndex:0];
+    NSString *tileCacheBaseDirectory = [NSString stringWithFormat:@"%@/tileCache", documentsDirectory];
+    self.tileCachePath = [NSURL fileURLWithPath:tileCacheBaseDirectory isDirectory:YES];
+    
+    if (![[NSFileManager defaultManager] fileExistsAtPath:[self.tileCachePath path]])
+        [[NSFileManager defaultManager] createDirectoryAtPath:[self.tileCachePath path] withIntermediateDirectories:NO attributes:nil error:&error];
+}
+
+- (void)createURLSession
+{
+ if (!_urlSession) {
+     _urlSession = [NSURLSession sharedSession];
+ }
+}
+
+- (void)checkForRefresh:(MKTileOverlayPath)path fromFilePath:(NSURL *)tileCacheFilePath
+{
+    if ([self doesFileNeedRefresh:path fromFilePath:tileCacheFilePath withMaxAge:self.tileCacheMaxAge]) {
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^ {
+            // This code runs asynchronously!
+            if ([self doesFileNeedRefresh:path fromFilePath:tileCacheFilePath withMaxAge:self.tileCacheMaxAge]) {
+                if (!_urlSession) [self createURLSession];
+
+                [[_urlSession dataTaskWithURL:[self URLForTilePath:path]
+                    completionHandler:^(NSData *data,
+                                        NSURLResponse *response,
+                                        NSError *error) {
+                    if (!error) {
+                        [[NSFileManager defaultManager] createFileAtPath:[tileCacheFilePath path] contents:data attributes:nil];
+                        NSLog(@"tileCache File refreshed at %@", [tileCacheFilePath path]);
+                    }
+                }] resume];             
+            }
+        });
+    }
+}
+
+- (BOOL)doesFileNeedRefresh:(MKTileOverlayPath)path fromFilePath:(NSURL *)tileCacheFilePath withMaxAge:(NSInteger)tileCacheMaxAge
+{
+    NSError *error;
+    NSDictionary<NSFileAttributeKey, id> *fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:[tileCacheFilePath path] error:&error]; 
+
+    if (fileAttributes) {
+        NSDate *modificationDate = fileAttributes[@"NSFileModificationDate"];
+        if (modificationDate) {
+            if (-1 * (int)modificationDate.timeIntervalSinceNow > tileCacheMaxAge) {
+                return YES;
+            }
+        }
+    }
+
+    return NO;
+}
+
+@end

package/lib/ios/AirMaps/AIRMapUrlTileManager.m

@@ -34,9 +34,14 @@ RCT_EXPORT_MODULE()
 
 RCT_EXPORT_VIEW_PROPERTY(urlTemplate, NSString)
 RCT_EXPORT_VIEW_PROPERTY(maximumZ, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(maximumNativeZ, NSInteger)
 RCT_EXPORT_VIEW_PROPERTY(minimumZ, NSInteger)
 RCT_EXPORT_VIEW_PROPERTY(flipY, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(shouldReplaceMapContent, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(tileSize, CGFloat)
+RCT_EXPORT_VIEW_PROPERTY(tileSize, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(tileCachePath, NSString)
+RCT_EXPORT_VIEW_PROPERTY(tileCacheMaxAge, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(offlineMode, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(opacity, CGFloat)
 
 @end

package/lib/ios/AirMaps/AIRMapWMSTile.h

@@ -16,26 +16,20 @@
 #import "AIRMapCoordinate.h"
 #import "AIRMap.h"
 #import "RCTConvert+AirMap.h"
+#import "AIRMapUrlTile.h"
+#import "AIRMapUrlTileCachedOverlay.h"
 
-@interface AIRMapWMSTile : MKAnnotationView <MKOverlay>
+@interface AIRMapWMSTile : AIRMapUrlTile <MKOverlay>
+@end
 
-@property (nonatomic, weak) AIRMap *map;
+@interface AIRMapWMSTileOverlay : MKTileOverlay
+@end
 
-@property (nonatomic, strong) MKTileOverlay *tileOverlay;
-@property (nonatomic, strong) MKTileOverlayRenderer *renderer;
-@property (nonatomic, copy) NSString *urlTemplate;
-@property NSInteger maximumZ;
-@property NSInteger minimumZ;
-@property NSInteger tileSize;
-@property BOOL shouldReplaceMapContent;
+@interface AIRMapWMSTileCachedOverlay : AIRMapUrlTileCachedOverlay
+@end
 
-#pragma mark MKOverlay protocol
+@interface AIRMapWMSTileHelper : NSObject
 
-@property(nonatomic, readonly) CLLocationCoordinate2D coordinate;
-@property(nonatomic, readonly) MKMapRect boundingMapRect;
-- (BOOL)canReplaceMapContent;
-@end
++ (NSURL *)URLForTilePath:(MKTileOverlayPath)path withURLTemplate:(NSString *)URLTemplate withTileSize:(NSInteger)tileSize;
 
-@interface TileOverlay : MKTileOverlay
-@property (nonatomic) double MapX,MapY,FULL;
 @end