react-native-maps 0.29.4 → 0.30.2

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

package/lib/ios/AirMaps/AIRMapWMSTile.m

@@ -9,141 +9,108 @@
 #import "AIRMapWMSTile.h"
 #import <React/UIView+React.h>
 
-@implementation AIRMapWMSTile {
-    BOOL _urlTemplateSet;
-}
-
-- (void)setShouldReplaceMapContent:(BOOL)shouldReplaceMapContent
-{
-  _shouldReplaceMapContent = shouldReplaceMapContent;
-  if(self.tileOverlay) {
-    self.tileOverlay.canReplaceMapContent = _shouldReplaceMapContent;
-  }
-  [self update];
-}
-
-- (void)setMaximumZ:(NSUInteger)maximumZ
+@implementation AIRMapWMSTile
+ 
+- (void)createTileOverlayAndRendererIfPossible
 {
-  _maximumZ = maximumZ;
-  if(self.tileOverlay) {
-    self.tileOverlay.maximumZ = _maximumZ;
-  }
-  [self update];
-}
+    if (!_urlTemplateSet) return;
+    if (_tileCachePathSet || _maximumNativeZSet) {
+        NSLog(@"tileCache new overlay dir %@", self.tileCachePath);
+        NSLog(@"tileCache %d", _tileCachePathSet);
+        NSLog(@"tileCache %d", _maximumNativeZSet);
+        self.tileOverlay = [[AIRMapWMSTileCachedOverlay 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 = [[AIRMapWMSTileOverlay alloc] initWithURLTemplate:self.urlTemplate];
+        _cachedOverlayCreated = NO;
+    }
 
-- (void)setMinimumZ:(NSUInteger)minimumZ
-{
-  _minimumZ = minimumZ;
-  if(self.tileOverlay) {
-    self.tileOverlay.minimumZ = _minimumZ;
-  }
-  [self update];
-}
+    [self updateProperties];
 
-- (void)setTileSize:(NSInteger)tileSize
-{
-    _tileSize = tileSize;
-    if(self.tileOverlay) {
-        self.tileOverlay.tileSize = CGSizeMake(tileSize, tileSize);
+    self.renderer = [[MKTileOverlayRenderer alloc] initWithTileOverlay:self.tileOverlay];
+    if (_opacitySet) {
+        self.renderer.alpha = self.opacity;
     }
-    [self update];
-}
-- (void)setUrlTemplate:(NSString *)urlTemplate{
-    _urlTemplate = urlTemplate;
-    _urlTemplateSet = YES;
-    [self createTileOverlayAndRendererIfPossible];
-    [self update];
 }
 
-- (void) createTileOverlayAndRendererIfPossible
-{
-    if (!_urlTemplateSet) return;
-    self.tileOverlay  = [[TileOverlay alloc] initWithURLTemplate:self.urlTemplate];
-    self.tileOverlay.canReplaceMapContent = self.shouldReplaceMapContent;
+@end
 
-    if(self.minimumZ) {
-        self.tileOverlay.minimumZ = self.minimumZ;
-    }
-    if (self.maximumZ) {
-        self.tileOverlay.maximumZ = self.maximumZ;
-    }
-    if (self.tileSize) {
-        self.tileOverlay.tileSize = CGSizeMake(self.tileSize, self.tileSize);;
-    }
-    self.renderer = [[MKTileOverlayRenderer alloc] initWithTileOverlay:self.tileOverlay];
-}
 
-- (void) update
+@implementation AIRMapWMSTileOverlay
+
+- (id)initWithURLTemplate:(NSString *)URLTemplate 
 {
-    if (!_renderer) return;
-    
-    if (_map == nil) return;
-    [_map removeOverlay:self];
-    [_map addOverlay:self level:MKOverlayLevelAboveLabels];
-    for (id<MKOverlay> overlay in _map.overlays) {
-        if ([overlay isKindOfClass:[AIRMapWMSTile class]]) {
-            continue;
-        }
-        [_map removeOverlay:overlay];
-        [_map addOverlay:overlay];
-    }
+    self = [super initWithURLTemplate:URLTemplate];
+    return self;
 }
 
-#pragma mark MKOverlay implementation
-
-- (CLLocationCoordinate2D) coordinate
+- (NSURL *)URLForTilePath:(MKTileOverlayPath)path
 {
-    return self.tileOverlay.coordinate;
+   return [AIRMapWMSTileHelper URLForTilePath:path withURLTemplate:self.URLTemplate withTileSize:self.tileSize.width];
 }
 
-- (MKMapRect) boundingMapRect
+@end
+
+
+@implementation AIRMapWMSTileCachedOverlay
+
+- (id)initWithURLTemplate:(NSString *)URLTemplate 
 {
-    return self.tileOverlay.boundingMapRect;
+    self = [super initWithURLTemplate:URLTemplate];
+    return self;
 }
 
-- (BOOL)canReplaceMapContent
+- (NSURL *)URLForTilePath:(MKTileOverlayPath)path
 {
-    return self.tileOverlay.canReplaceMapContent;
+   return [AIRMapWMSTileHelper URLForTilePath:path withURLTemplate:self.URLTemplate withTileSize:self.tileSize.width];
 }
 
 @end
 
-@implementation TileOverlay
-@synthesize MapX;
-@synthesize MapY;
-@synthesize FULL;
-
--(id) initWithURLTemplate:(NSString *)URLTemplate {
-    self = [super initWithURLTemplate:URLTemplate];
-    MapX = -20037508.34789244;
-    MapY = 20037508.34789244;
-    FULL = 20037508.34789244 * 2;
-    return self ;
-}
 
--(NSURL *)URLForTilePath:(MKTileOverlayPath)path{
+@implementation AIRMapWMSTileHelper 
++ (NSURL *)URLForTilePath:(MKTileOverlayPath)path withURLTemplate:(NSString *)URLTemplate withTileSize:(NSInteger)tileSize
+{
     NSArray *bb = [self getBoundBox:path.x yAxis:path.y zoom:path.z];
-    NSMutableString *url = [self.URLTemplate mutableCopy];
+    NSMutableString *url = [URLTemplate mutableCopy];
     [url replaceOccurrencesOfString: @"{minX}" withString:[NSString stringWithFormat:@"%@", bb[0]] options:0 range:NSMakeRange(0, url.length)];
     [url replaceOccurrencesOfString: @"{minY}" withString:[NSString stringWithFormat:@"%@", bb[1]] options:0 range:NSMakeRange(0, url.length)];
     [url replaceOccurrencesOfString: @"{maxX}" withString:[NSString stringWithFormat:@"%@", bb[2]] options:0 range:NSMakeRange(0, url.length)];
     [url replaceOccurrencesOfString: @"{maxY}" withString:[NSString stringWithFormat:@"%@", bb[3]] options:0 range:NSMakeRange(0, url.length)];
-    [url replaceOccurrencesOfString: @"{width}" withString:[NSString stringWithFormat:@"%d", (int)self.tileSize.width] options:0 range:NSMakeRange(0, url.length)];
-    [url replaceOccurrencesOfString: @"{height}" withString:[NSString stringWithFormat:@"%d", (int)self.tileSize.height] options:0 range:NSMakeRange(0, url.length)];
+    [url replaceOccurrencesOfString: @"{width}" withString:[NSString stringWithFormat:@"%d", (int)tileSize] options:0 range:NSMakeRange(0, url.length)];
+    [url replaceOccurrencesOfString: @"{height}" withString:[NSString stringWithFormat:@"%d", (int)tileSize] options:0 range:NSMakeRange(0, url.length)];
     return [NSURL URLWithString:url];
 }
 
--(NSArray *)getBoundBox:(NSInteger)x yAxis:(NSInteger)y zoom:(NSInteger)zoom{
++ (NSArray *)getBoundBox:(NSInteger)x yAxis:(NSInteger)y zoom:(NSInteger)zoom
+{
+    double MapX = -20037508.34789244;
+    double MapY = 20037508.34789244;
+    double FULL = 20037508.34789244 * 2;
     double tile = FULL / pow(2.0, (double)zoom);
     
     NSArray *result  =[[NSArray alloc] initWithObjects:
-                       [NSNumber numberWithDouble:MapX + (double)x * tile ],
-                       [NSNumber numberWithDouble:MapY - (double)(y+1) * tile ],
-                       [NSNumber numberWithDouble:MapX + (double)(x+1) * tile ],
-                       [NSNumber numberWithDouble:MapY - (double)y * tile ],
+                       [NSNumber numberWithDouble:MapX + (double)x * tile],
+                       [NSNumber numberWithDouble:MapY - (double)(y + 1) * tile],
+                       [NSNumber numberWithDouble:MapX + (double)(x + 1) * tile],
+                       [NSNumber numberWithDouble:MapY - (double)y * tile],
                        nil];
     
-    return result;
-    
+    return result;   
 }
-@end
+
+@end

package/lib/ios/AirMaps/AIRMapWMSTileManager.m

@@ -35,8 +35,13 @@ 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(tileSize, NSInteger)
 RCT_EXPORT_VIEW_PROPERTY(shouldReplaceMapContent, BOOL)
+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.xcodeproj/project.pbxproj

@@ -57,6 +57,7 @@
 		A8494E2E218891180092506D /* AIRGoogleMapWMSTileManager.m in Sources */ = {isa = PBXBuildFile; fileRef = A8494E2A218891180092506D /* AIRGoogleMapWMSTileManager.m */; };
 		A8494E2F218891180092506D /* AIRGoogleMapWMSTile.m in Sources */ = {isa = PBXBuildFile; fileRef = A8494E2D218891180092506D /* AIRGoogleMapWMSTile.m */; };
 		B5EA3BA92098E22B000E7AFD /* AIRDummyView.m in Sources */ = {isa = PBXBuildFile; fileRef = B5EA3BA72098E22B000E7AFD /* AIRDummyView.m */; };
+		BE2E4EC92621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.m in Sources */ = {isa = PBXBuildFile; fileRef = BE2E4EC82621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.m */; };
 		DA6C26381C9E2AFE0035349F /* AIRMapUrlTile.m in Sources */ = {isa = PBXBuildFile; fileRef = DA6C26371C9E2AFE0035349F /* AIRMapUrlTile.m */; };
 		DA6C263E1C9E324A0035349F /* AIRMapUrlTileManager.m in Sources */ = {isa = PBXBuildFile; fileRef = DA6C263D1C9E324A0035349F /* AIRMapUrlTileManager.m */; };
 /* End PBXBuildFile section */
@@ -175,6 +176,8 @@
 		A8494E2D218891180092506D /* AIRGoogleMapWMSTile.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AIRGoogleMapWMSTile.m; path = AirGoogleMaps/AIRGoogleMapWMSTile.m; sourceTree = "<group>"; };
 		B5EA3BA72098E22B000E7AFD /* AIRDummyView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AIRDummyView.m; path = AirGoogleMaps/AIRDummyView.m; sourceTree = "<group>"; };
 		B5EA3BA82098E22B000E7AFD /* AIRDummyView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AIRDummyView.h; path = AirGoogleMaps/AIRDummyView.h; sourceTree = "<group>"; };
+		BE2E4EC72621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AIRMapUrlTileCachedOverlay.h; path = AirMaps/AIRMapUrlTileCachedOverlay.h; sourceTree = SOURCE_ROOT; };
+		BE2E4EC82621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AIRMapUrlTileCachedOverlay.m; path = AirMaps/AIRMapUrlTileCachedOverlay.m; sourceTree = SOURCE_ROOT; };
 		DA6C26361C9E2AFE0035349F /* AIRMapUrlTile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AIRMapUrlTile.h; sourceTree = "<group>"; };
 		DA6C26371C9E2AFE0035349F /* AIRMapUrlTile.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = AIRMapUrlTile.m; sourceTree = "<group>"; };
 		DA6C263C1C9E324A0035349F /* AIRMapUrlTileManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AIRMapUrlTileManager.h; sourceTree = "<group>"; };
@@ -214,6 +217,8 @@
 		11FA5C531C4A1296003AC2EE /* AirMaps */ = {
 			isa = PBXGroup;
 			children = (
+				BE2E4EC72621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.h */,
+				BE2E4EC82621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.m */,
 				1125B2BD1C4AD3DA007D0023 /* AIRMap.h */,
 				1125B2BE1C4AD3DA007D0023 /* AIRMap.m */,
 				1125B2BF1C4AD3DA007D0023 /* AIRMapCallout.h */,
@@ -402,7 +407,7 @@
 				9B9498CE2017EFB800158761 /* AIRGMSMarker.m in Sources */,
 				9B9498D72017EFB800158761 /* AIRGoogleMapManager.m in Sources */,
 				19DABC7F1E7C9D3C00F41150 /* RCTConvert+AirMap.m in Sources */,
-                A8494E2E218891180092506D /* AIRGoogleMapWMSTileManager.m in Sources */,
+				A8494E2E218891180092506D /* AIRGoogleMapWMSTileManager.m in Sources */,
 				8B19A3C82257BBDF00BB8735 /* AIRMapCalloutSubview.m in Sources */,
 				1125B2E51C4AD3DA007D0023 /* AIRMapPolyline.m in Sources */,
 				4C99C9E12226D8C400A8693E /* AIRWeakMapReference.m in Sources */,
@@ -410,6 +415,7 @@
 				9B9498CF2017EFB800158761 /* AIRGMSPolyline.m in Sources */,
 				9B9498D42017EFB800158761 /* RCTConvert+GMSMapViewType.m in Sources */,
 				9B9498D32017EFB800158761 /* AIRGoogleMap.m in Sources */,
+				BE2E4EC92621F63C00CC7F2E /* AIRMapUrlTileCachedOverlay.m in Sources */,
 				DA6C263E1C9E324A0035349F /* AIRMapUrlTileManager.m in Sources */,
 				9B9498DB2017EFB800158761 /* AIRGoogleMapMarker.m in Sources */,
 				628F81201FD16DF80058313A /* AIRMapLocalTile.m in Sources */,

package/package.json

@@ -3,11 +3,25 @@
   "description": "React Native Mapview component for iOS + Android",
   "main": "index.js",
   "author": "Leland Richardson <leland.m.richardson@gmail.com>",
-  "version": "0.29.4",
+  "version": "0.30.2",
   "scripts": {
-    "lint": "./node_modules/eslint/bin/eslint.js .",
-    "ci": "npm run lint"
+    "lint": "eslint . --max-warnings 0",
+    "test": "jest",
+    "prepare": "husky install",
+    "release": "semantic-release"
   },
+  "files": [
+    "index.d.ts",
+    "lib",
+    "react-native-google-maps.podspec",
+    "react-native-maps.podspec",
+    "react-native.config.js",
+    "!lib/android/build",
+    "!lib/ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/react-native-maps/react-native-maps"
@@ -27,10 +41,33 @@
     "react-native-web": ">= 0.11"
   },
   "devDependencies": {
-    "@react-native-community/eslint-config": "0.0.5",
-    "eslint": "5.16.0"
+    "@commitlint/cli": "16.2.3",
+    "@commitlint/config-conventional": "16.2.1",
+    "@react-native-community/eslint-config": "^3.0.1",
+    "babel-jest": "^27.3.1",
+    "eslint": "7.32.0",
+    "husky": "7.0.4",
+    "jest": "^27.3.1",
+    "react": "^17.0.2",
+    "react-native": "^0.66.3",
+    "semantic-release": "19.0.2",
+    "typescript": "^4.4.3"
   },
   "dependencies": {
-    "@types/geojson": "^7946.0.7"
+    "@types/geojson": "^7946.0.7",
+    "deprecated-react-native-prop-types": "^2.3.0"
+  },
+  "jest": {
+    "preset": "react-native",
+    "testRegex": "<rootDir>/__tests__/.*|(\\.|/)(test|spec)\\.jsx?$",
+    "transform": {
+      "^.+\\.js$": "<rootDir>/node_modules/react-native/jest/preprocessor.js"
+    },
+    "moduleFileExtensions": [
+      "js"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!@react-native|react-native)"
+    ]
   }
 }

package/react-native-google-maps.podspec

@@ -17,6 +17,6 @@ Pod::Spec.new do |s|
   s.compiler_flags = '-DHAVE_GOOGLE_MAPS=1', '-DHAVE_GOOGLE_MAPS_UTILS=1', '-fno-modules'
 
   s.dependency 'React-Core'
-  s.dependency 'GoogleMaps', '3.5.0'
-  s.dependency 'Google-Maps-iOS-Utils', '2.1.0'
+  s.dependency 'GoogleMaps', '5.1.0'
+  s.dependency 'Google-Maps-iOS-Utils', '3.10.3'
 end

package/.eslintrc

@@ -1,3 +0,0 @@
-{
-  "extends": "@react-native-community"
-}