react-native-maps 1.21.0-alpha.8 → 1.21.0-alpha.80

package/ios/AirMaps/AIRMap.m

@@ -20,6 +20,7 @@
 #import "AIRMapWMSTile.h"
 #import "AIRMapLocalTile.h"
 #import "AIRMapOverlay.h"
+#import "AIRMapSnapshot.h"
 
 const NSTimeInterval AIRMapRegionChangeObserveInterval = 0.1;
 const CGFloat AIRMapZoomBoundBuffer = 0.01;
@@ -38,8 +39,6 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 @property (nonatomic, strong) UIActivityIndicatorView *activityIndicatorView;
 @property (nonatomic, assign) NSNumber *shouldZoomEnabled;
 @property (nonatomic, assign) NSNumber *shouldScrollEnabled;
-@property (nonatomic, strong) MKCompassButton *defaultCompassButton;
-@property (nonatomic, strong) MKCompassButton *overlayCompassButton;
 
 - (void)updateScrollEnabled;
 - (void)updateZoomEnabled;
@@ -50,8 +49,12 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 {
     UIView *_legalLabel;
     BOOL _initialRegionSet;
+    BOOL _initialRegionProvided;
+    BOOL _initialCameraProvided;
     BOOL _initialCameraSet;
-    
+    BOOL _initialized;
+    BOOL _loadingStarted;
+
     // Array to manually track RN subviews
     //
     // AIRMap implicitly creates subviews that aren't regular RN children
@@ -69,7 +72,7 @@ const NSInteger AIRMapMaxZoomLevel = 20;
     if ((self = [super init])) {
         _hasStartedRendering = NO;
         _reactSubviews = [NSMutableArray new];
-        
+
         // Find Apple link label
         for (UIView *subview in self.subviews) {
             if ([NSStringFromClass(subview.class) isEqualToString:@"MKAttributionLabel"]) {
@@ -79,16 +82,18 @@ const NSInteger AIRMapMaxZoomLevel = 20;
                 break;
             }
         }
-        
+
         // 3rd-party callout view for MapKit that has more options than the built-in. It's painstakingly built to
         // be identical to the built-in callout view (which has a private API)
         self.calloutView = [SMCalloutView platformCalloutView];
         self.calloutView.delegate = self;
-        
+
         self.minZoom = 0;
         self.maxZoom = AIRMapMaxZoomLevel;
         self.compassOffset = CGPointMake(0, 0);
         self.legacyZoomConstraintsEnabled = YES;
+        _initialized = YES;
+        [self listenToMemoryWarnings];
     }
     return self;
 }
@@ -201,46 +206,25 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 }
 // Create Polyline with coordinates
 -(void) fitToCoordinates:(NSArray<AIRMapCoordinate*>*) coordinates edgePadding:(UIEdgeInsets) edgeInsets animated:(Boolean) animated {
-CLLocationCoordinate2D coords[coordinates.count];
-for(int i = 0; i < coordinates.count; i++)
-{
-    coords[i] = coordinates[i].coordinate;
-}
-MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordinates.count];
+    CLLocationCoordinate2D coords[coordinates.count];
+    for(int i = 0; i < coordinates.count; i++)
+    {
+        coords[i] = coordinates[i].coordinate;
+    }
+    MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordinates.count];
 
-// Set Map viewport
+    // Set Map viewport
 
-[self setVisibleMapRect:[polyline boundingMapRect] edgePadding:edgeInsets animated:animated];
+    [self setVisibleMapRect:[polyline boundingMapRect] edgePadding:edgeInsets animated:animated];
 }
+
+
 - (CGRect) frameForMarker:(AIRMapMarker*) mrkAnn {
     MKAnnotationView* mrkView = [self viewForAnnotation: mrkAnn];
     CGRect mrkFrame = mrkView.frame;
     return mrkFrame;
 }
 
-- (NSDictionary*) getMarkersFramesWithOnlyVisible:(BOOL)onlyVisible {
-    NSMutableDictionary* markersFrames = [NSMutableDictionary new];
-    for (AIRMapMarker* mrkAnn in self.markers) {
-        CGRect frame = [self frameForMarker:mrkAnn];
-        CGPoint point = [self convertCoordinate:mrkAnn.coordinate toPointToView:self];
-        NSDictionary* frameDict = @{
-            @"x": @(frame.origin.x),
-            @"y": @(frame.origin.y),
-            @"width": @(frame.size.width),
-            @"height": @(frame.size.height)
-        };
-        NSDictionary* pointDict = @{
-            @"x": @(point.x),
-            @"y": @(point.y)
-        };
-        NSString* k = mrkAnn.identifier;
-        BOOL isVisible = CGRectIntersectsRect(self.bounds, frame);
-        if (k != nil && (!onlyVisible || isVisible)) {
-            [markersFrames setObject:@{ @"frame": frameDict, @"point": pointDict } forKey:k];
-        }
-    }
-    return markersFrames;
-}
 
 - (AIRMapMarker*) markerAtPoint:(CGPoint)point {
     AIRMapMarker* mrk = nil;
@@ -269,16 +253,16 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
 // Allow touches to be sent to our calloutview.
 // See this for some discussion of why we need to override this: https://github.com/nfarina/calloutview/pull/9
 - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
-    
+
     CGPoint touchPoint = [self.calloutView convertPoint:point fromView:self];
     UIView *touchedView = [self.calloutView hitTest:touchPoint withEvent:event];
-    
+
     if (touchedView) {
         UIWindow* win = [[[UIApplication sharedApplication] windows] firstObject];
         AIRMapCalloutSubview* calloutSubview = nil;
         AIRMapCallout* callout = nil;
         AIRMapMarker* marker = nil;
-        
+
         UIView* tmp = touchedView;
         while (tmp && tmp != win && tmp != self.calloutView) {
             if ([tmp respondsToSelector:@selector(onPress)]) {
@@ -290,7 +274,7 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
             }
             tmp = tmp.superview;
         }
-        
+
         if (callout) {
             marker = [self markerForCallout:callout];
             if (marker) {
@@ -300,49 +284,49 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
                 }
             }
         }
-        
+
         return calloutSubview ? calloutSubview : touchedView;
     }
-    
+
     return [super hitTest:point withEvent:event];
 }
 
 #pragma mark SMCalloutViewDelegate
 
 - (NSTimeInterval)calloutView:(SMCalloutView *)calloutView delayForRepositionWithSize:(CGSize)offset {
-    
+
     // When the callout is being asked to present in a way where it or its target will be partially offscreen, it asks us
     // if we'd like to reposition our surface first so the callout is completely visible. Here we scroll the map into view,
     // but it takes some math because we have to deal in lon/lat instead of the given offset in pixels.
-    
+
     CLLocationCoordinate2D coordinate = self.region.center;
-    
+
     // where's the center coordinate in terms of our view?
     CGPoint center = [self convertCoordinate:coordinate toPointToView:self];
-    
+
     // move it by the requested offset
     center.x -= offset.width;
     center.y -= offset.height;
-    
+
     // and translate it back into map coordinates
     coordinate = [self convertPoint:center toCoordinateFromView:self];
-    
+
     // move the map!
     [self setCenterCoordinate:coordinate animated:YES];
-    
+
     // tell the callout to wait for a while while we scroll (we assume the scroll delay for MKMapView matches UIScrollView)
     return kSMCalloutViewRepositionDelayForUIScrollView;
 }
 
-#pragma mark Accessors
+#pragma mark RNMapsAirModuleDelegate.h
 
 - (NSArray *)getMapBoundaries
 {
     MKMapRect mapRect = self.visibleMapRect;
-    
+
     CLLocationCoordinate2D northEast = MKCoordinateForMapPoint(MKMapPointMake(MKMapRectGetMaxX(mapRect), mapRect.origin.y));
     CLLocationCoordinate2D southWest = MKCoordinateForMapPoint(MKMapPointMake(mapRect.origin.x, MKMapRectGetMaxY(mapRect)));
-    
+
     return @[
         @[
             [NSNumber numberWithDouble:northEast.longitude],
@@ -354,6 +338,174 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
         ]
     ];
 }
+- (NSDictionary *) getPointForCoordinates:(CLLocationCoordinate2D) location
+{
+    CGPoint touchPoint = [self convertCoordinate:location toPointToView:self];
+
+    return @{
+        @"x": @(touchPoint.x),
+        @"y": @(touchPoint.y),
+    };
+}
+- (NSDictionary *) getCoordinatesForPoint:(CGPoint)point
+{
+    CLLocationCoordinate2D coordinate = [self convertPoint:point toCoordinateFromView:self];
+    return @{
+        @"latitude": @(coordinate.latitude),
+        @"longitude": @(coordinate.longitude),
+    };
+
+}
+
+- (NSDictionary*) getMarkersFramesWithOnlyVisible:(BOOL)onlyVisible {
+    NSMutableDictionary* markersFrames = [NSMutableDictionary new];
+    for (AIRMapMarker* mrkAnn in self.markers) {
+        CGRect frame = [self frameForMarker:mrkAnn];
+        CGPoint point = [self convertCoordinate:mrkAnn.coordinate toPointToView:self];
+        NSDictionary* frameDict = @{
+            @"x": @(frame.origin.x),
+            @"y": @(frame.origin.y),
+            @"width": @(frame.size.width),
+            @"height": @(frame.size.height)
+        };
+        NSDictionary* pointDict = @{
+            @"x": @(point.x),
+            @"y": @(point.y)
+        };
+        NSString* k = mrkAnn.identifier;
+        BOOL isVisible = CGRectIntersectsRect(self.bounds, frame);
+        if (k != nil && (!onlyVisible || isVisible)) {
+            [markersFrames setObject:@{ @"frame": frameDict, @"point": pointDict } forKey:k];
+        }
+    }
+    return markersFrames;
+}
+
+- (NSDictionary *) getCameraDic {
+    MKMapCamera *camera = [self camera];
+    return @{
+        @"center": @{
+            @"latitude": @(camera.centerCoordinate.latitude),
+            @"longitude": @(camera.centerCoordinate.longitude),
+        },
+        @"pitch": @(camera.pitch),
+        @"heading": @(camera.heading),
+        @"altitude": @(camera.altitude),
+    };
+}
+- (void)takeSnapshotWithConfig:(NSDictionary *)config
+                       success:(RCTPromiseResolveBlock)success error:(RCTPromiseRejectBlock)error
+{
+
+    MKMapSnapshotOptions *options = [[MKMapSnapshotOptions alloc] init];
+
+    options.mapType = self.mapType;
+    NSNumber *width = config[@"width"];
+    NSNumber *height = config[@"height"];
+    NSNumber *quality = config[@"quality"];
+    NSString*format =config[@"format"];
+    NSString*result =config[@"result"];
+    if (config[@"region"]){
+        MKCoordinateRegion region = [RCTConvert MKCoordinateRegion:config[@"region"]];
+        options.region =  region;
+    } else
+    {
+        options.region =  self.region;
+    }
+    options.size = CGSizeMake(
+                              ([width floatValue] == 0) ? self.bounds.size.width : [width floatValue],
+                              ([height floatValue] == 0) ? self.bounds.size.height : [height floatValue]
+                              );
+
+    options.scale = [[UIScreen mainScreen] scale];
+
+
+    MKMapSnapshotter *snapshotter = [[MKMapSnapshotter alloc] initWithOptions:options];
+
+    [self takeMapSnapshot:snapshotter
+                   format:format
+                  quality:[quality floatValue]
+                   result:result
+                  success:success error:error];
+}
+
+#pragma mark Take Snapshot
+- (void)takeMapSnapshot:(MKMapSnapshotter *) snapshotter
+                 format:(NSString *)format
+                quality:(CGFloat) quality
+                 result:(NSString *)result
+               success:(RCTPromiseResolveBlock) success
+                  error:(RCTPromiseRejectBlock) errorCallback {
+    NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
+    NSString *pathComponent = [NSString stringWithFormat:@"Documents/snapshot-%.20lf.%@", timeStamp, format];
+    NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent: pathComponent];
+
+    [snapshotter startWithQueue:dispatch_get_main_queue()
+              completionHandler:^(MKMapSnapshot *snapshot, NSError *error) {
+        if (error) {
+            errorCallback(@"snapshotterError", @"failed", error);
+            return;
+        }
+        MKAnnotationView *pin = [[MKPinAnnotationView alloc] initWithAnnotation:nil reuseIdentifier:nil];
+
+        UIImage *image = snapshot.image;
+        UIGraphicsBeginImageContextWithOptions(image.size, YES, image.scale);
+        {
+            [image drawAtPoint:CGPointMake(0.0f, 0.0f)];
+
+            CGRect rect = CGRectMake(0.0f, 0.0f, image.size.width, image.size.height);
+
+            for (id <AIRMapSnapshot> overlay in self.overlays) {
+                if ([overlay respondsToSelector:@selector(drawToSnapshot:context:)]) {
+                    [overlay drawToSnapshot:snapshot context:UIGraphicsGetCurrentContext()];
+                }
+            }
+
+
+            for (id <MKAnnotation> annotation in self.annotations) {
+                CGPoint point = [snapshot pointForCoordinate:annotation.coordinate];
+
+                MKAnnotationView* anView = [self viewForAnnotation: annotation];
+
+                if (anView){
+                    pin = anView;
+                }
+
+                if (CGRectContainsPoint(rect, point)) {
+                    point.x = point.x + pin.centerOffset.x - (pin.bounds.size.width / 2.0f);
+                    point.y = point.y + pin.centerOffset.y - (pin.bounds.size.height / 2.0f);
+                    if (pin.image) {
+                        [pin.image drawAtPoint:point];
+                    } else {
+                        CGRect pinRect = CGRectMake(point.x, point.y, pin.bounds.size.width, pin.bounds.size.height);
+                        [pin drawViewHierarchyInRect:pinRect afterScreenUpdates:NO];
+                    }
+                }
+            }
+
+            UIImage *compositeImage = UIGraphicsGetImageFromCurrentImageContext();
+
+            NSData *data;
+            if ([format isEqualToString:@"png"]) {
+                data = UIImagePNGRepresentation(compositeImage);
+            }
+            else if([format isEqualToString:@"jpg"]) {
+                data = UIImageJPEGRepresentation(compositeImage, quality);
+            }
+
+            if ([result isEqualToString:@"file"]) {
+                [data writeToFile:filePath atomically:YES];
+                success(filePath);
+            }
+            else if ([result isEqualToString:@"base64"]) {
+                success([data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]);
+            }
+        }
+        UIGraphicsEndImageContext();
+    }];
+}
+
+
 
 - (void)setShowsUserLocation:(BOOL)showsUserLocation
 {
@@ -364,7 +516,6 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
 
 - (void)setUserInterfaceStyle:(NSString*)userInterfaceStyle
 {
-    if (@available(iOS 13.0, *)) {
         if([userInterfaceStyle isEqualToString:@"light"]) {
             self.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
         } else if([userInterfaceStyle isEqualToString:@"dark"]) {
@@ -372,9 +523,6 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
         } else {
             self.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
         }
-    } else {
-        NSLog(@"UserInterfaceStyle not supported below iOS 13");
-    }
 }
 
 - (void)setTintColor:(UIColor *)tintColor
@@ -392,13 +540,14 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
     _userLocationCalloutEnabled = calloutEnabled;
 }
 
-- (void)setHandlePanDrag:(BOOL)handleMapDrag {
+- (void)setHandlePanDrag:(BOOL)handlePanDrag {
     for (UIGestureRecognizer *recognizer in [self gestureRecognizers]) {
         if ([recognizer isKindOfClass:[UIPanGestureRecognizer class]]) {
-            recognizer.enabled = handleMapDrag;
+            recognizer.enabled = handlePanDrag;
             break;
         }
     }
+    _handlePanDrag = handlePanDrag;
 }
 
 - (void)setRegion:(MKCoordinateRegion)region animated:(BOOL)animated
@@ -407,7 +556,7 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
     if (!CLLocationCoordinate2DIsValid(region.center)) {
         return;
     }
-    
+
     // If new span values are nil, use old values instead
     if (!region.span.latitudeDelta) {
         region.span.latitudeDelta = self.region.span.latitudeDelta;
@@ -415,13 +564,28 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
     if (!region.span.longitudeDelta) {
         region.span.longitudeDelta = self.region.span.longitudeDelta;
     }
-    
+
     // Animate/move to new position
     [super setRegion:region animated:animated];
 }
+- (void) setRegion:(MKCoordinateRegion)region
+{
+    if (!CLLocationCoordinate2DIsValid(region.center)) {
+        return;
+    }
+    if (!CLLocationCoordinate2DIsValid(_initialRegion.center)) {
+        [self setInitialRegion:region];
+    }
+    [self setRegion:region animated:NO];
+}
 
 - (void)setInitialRegion:(MKCoordinateRegion)initialRegion {
-    if (!_initialRegionSet) {
+    if (!CLLocationCoordinate2DIsValid(initialRegion.center)) {
+        return;
+    }
+    _initialRegion = initialRegion;
+    _initialRegionProvided = YES;
+    if (!_initialRegionSet && _loadingStarted) {
         _initialRegionSet = YES;
         [self setRegion:initialRegion animated:NO];
     }
@@ -434,9 +598,13 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
 
 
 - (void)setInitialCamera:(MKMapCamera*)initialCamera {
-    if (!_initialCameraSet) {
-        _initialCameraSet = YES;
-        [self setCamera:initialCamera animated:NO];
+    _initialCamera = initialCamera;
+    _initialCameraProvided = YES;
+    if (initialCamera){
+        if (!_initialCameraSet && _loadingStarted) {
+            _initialCameraSet = YES;
+            [self setCamera:initialCamera animated:NO];
+        }
     }
 }
 
@@ -482,26 +650,24 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
 }
 
 - (void)setCameraZoomRange:(NSDictionary *)cameraZoomRange {
-    if (@available(iOS 13.0, *)) {
-        
         if (cameraZoomRange == nil) {
             cameraZoomRange = @{};
         }
-        
+
         NSNumber *minValue = cameraZoomRange[@"minCenterCoordinateDistance"];
         NSNumber *maxValue = cameraZoomRange[@"maxCenterCoordinateDistance"];
-        
+
         if (minValue == nil && maxValue == nil) {
             self.legacyZoomConstraintsEnabled = YES;
-            
+
             MKMapCameraZoomRange *defaultZoomRange = [[MKMapCameraZoomRange alloc] initWithMinCenterCoordinateDistance:MKMapCameraZoomDefault maxCenterCoordinateDistance:MKMapCameraZoomDefault];
             [super setCameraZoomRange:defaultZoomRange animated:NO];
-            
+
             return;
         }
-        
+
         MKMapCameraZoomRange *zoomRange = nil;
-        
+
         if (minValue != nil && maxValue != nil) {
             zoomRange = [[MKMapCameraZoomRange alloc] initWithMinCenterCoordinateDistance:[minValue doubleValue] maxCenterCoordinateDistance:[maxValue doubleValue]];
         } else if (minValue != nil) {
@@ -509,61 +675,13 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
         } else if (maxValue != nil) {
             zoomRange = [[MKMapCameraZoomRange alloc] initWithMaxCenterCoordinateDistance:[maxValue doubleValue]];
         }
-        
+
         BOOL animated = [cameraZoomRange[@"animated"] boolValue];
-        
+
         self.legacyZoomConstraintsEnabled = NO;
         [super setCameraZoomRange:zoomRange animated:animated];
-    }
-}
-
-// Include properties of MKMapView which are only available on iOS 9+
-// and check if their selector is available before calling super method.
-
-- (void)setShowsCompass:(BOOL)showsCompass {
-    if (self.overlayCompassButton != nil) {
-        self.overlayCompassButton.compassVisibility = showsCompass ? MKFeatureVisibilityAdaptive : MKFeatureVisibilityHidden;
-    }
-    if ([MKMapView instancesRespondToSelector:@selector(setShowsCompass:)]) {
-        [super setShowsCompass:showsCompass];
-    }
-}
-
-- (BOOL)showsCompass {
-    if ([MKMapView instancesRespondToSelector:@selector(showsCompass)]) {
-        return [super showsCompass];
-    } else {
-        return NO;
-    }
-}
-
-- (void)setShowsScale:(BOOL)showsScale {
-    if ([MKMapView instancesRespondToSelector:@selector(setShowsScale:)]) {
-        [super setShowsScale:showsScale];
-    }
 }
 
-- (BOOL)showsScale {
-    if ([MKMapView instancesRespondToSelector:@selector(showsScale)]) {
-        return [super showsScale];
-    } else {
-        return NO;
-    }
-}
-
-- (void)setShowsTraffic:(BOOL)showsTraffic {
-    if ([MKMapView instancesRespondToSelector:@selector(setShowsTraffic:)]) {
-        [super setShowsTraffic:showsTraffic];
-    }
-}
-
-- (BOOL)showsTraffic {
-    if ([MKMapView instancesRespondToSelector:@selector(showsTraffic)]) {
-        return [super showsTraffic];
-    } else {
-        return NO;
-    }
-}
 
 - (void)setScrollEnabled:(BOOL)scrollEnabled {
     self.shouldScrollEnabled = [NSNumber numberWithBool:scrollEnabled];
@@ -609,7 +727,7 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
         else {
             self.cacheImageView.image = nil;
             self.cacheImageView.hidden = YES;
-            
+
             dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.01 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                 self.cacheImageView.image = nil;
                 self.cacheImageView.hidden = YES;
@@ -617,18 +735,47 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
                 [self.layer renderInContext:UIGraphicsGetCurrentContext()];
                 UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
                 UIGraphicsEndImageContext();
-                
+
                 self.cacheImageView.image = image;
                 self.cacheImageView.hidden = NO;
             });
         }
-        
+
         [self updateScrollEnabled];
         [self updateZoomEnabled];
         [self updateLegalLabelInsets];
     }
 }
 
+- (void) listenToMemoryWarnings
+{
+    __weak typeof(self) weakSelf = self;
+    static dispatch_once_t onceToken;
+    static dispatch_source_t source;
+    dispatch_once(&onceToken, ^{
+            source = dispatch_source_create(DISPATCH_SOURCE_TYPE_MEMORYPRESSURE, 0, DISPATCH_MEMORYPRESSURE_WARN|DISPATCH_MEMORYPRESSURE_CRITICAL, dispatch_get_main_queue());
+            dispatch_source_set_event_handler(source, ^{
+                [weakSelf handleMemoryWarning];
+            });
+            dispatch_resume(source);
+    });
+}
+/*
+ hacky way to release all cache
+ this is our last chance to release cache before app crash
+ */
+- (void) handleMemoryWarning
+{
+    NSLog(@"handleMemoryWarning warning");
+    MKMapType type = self.mapType;
+    if (type == MKMapTypeSatellite){
+        self.mapType = MKMapTypeStandard;
+    } else {
+        self.mapType = MKMapTypeSatellite;
+    }
+    self.mapType = type;
+}
+
 - (void)updateLegalLabelInsets {
     if (_legalLabel) {
         dispatch_async(dispatch_get_main_queue(), ^{
@@ -672,6 +819,14 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
             self.loadingView.hidden = YES;
         }
     }
+    _loadingStarted = YES;
+    // display initialRegion/Camera
+    if (_initialRegionProvided){
+        [self setInitialRegion:_initialRegion];
+    }
+    if (_initialCameraProvided){
+        [self setInitialCamera:_initialCamera];
+    }
 }
 
 - (void)finishLoading {
@@ -718,50 +873,27 @@ MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords count:coordina
 - (void)layoutSubviews {
     [super layoutSubviews];
     [self cacheViewIfNeeded];
-    
-    if (self.overlayCompassButton == nil) {
-        for (UIView *subview in self.subviews) {
-            if (![NSStringFromClass(subview.class) isEqualToString:@"MKPassThroughStackView"]) continue;
-            self.overlayCompassButton = [MKCompassButton compassButtonWithMapView:self];
-            [subview addSubview:self.overlayCompassButton];
-            self.overlayCompassButton.frame = CGRectMake(self.overlayCompassButton.frame.origin.x + _compassOffset.x, self.overlayCompassButton.frame.origin.y + _compassOffset.y, self.overlayCompassButton.frame.size.width, self.overlayCompassButton.frame.size.height);
-            break;
-        }
-    }
-    
-    if (self.defaultCompassButton == nil) {
-        for (UIView *subview in self.subviews) {
-            if (![NSStringFromClass(subview.class) isEqualToString:@"MKPassThroughStackView"]) continue;
-            for (UIView *subview2 in subview.subviews) {
-                if (![NSStringFromClass(subview2.class) isEqualToString:@"MKCompassView"]) continue;
-                self.defaultCompassButton = subview2;
-                self.defaultCompassButton.hidden = YES;
-            }
-            break;
-        }
-    }
-    
 }
 
 // based on https://medium.com/@dmytrobabych/getting-actual-rotation-and-zoom-level-for-mapkit-mkmapview-e7f03f430aa9
 - (CGFloat)getZoomLevel {
     CGFloat cameraAngle = self.camera.heading;
-    
+
     if (cameraAngle > 270) {
         cameraAngle = 360 - cameraAngle;
     } else if (cameraAngle > 90) {
         cameraAngle = fabs(cameraAngle - 180);
     }
-    
+
     CGFloat angleRad = M_PI * cameraAngle / 180; // map rotation in radians
     CGFloat width = self.frame.size.width;
     CGFloat height = self.frame.size.height;
     CGFloat heightOffset = 20; // the offset (status bar height) which is taken by MapKit into consideration to calculate visible area height
-    
+
     // calculating Longitude span corresponding to normal (non-rotated) width
     CGFloat spanStraight = width * self.region.span.longitudeDelta / (width * cos(angleRad) + (height - heightOffset) * sin(angleRad));
     int normalizingFactor = 512;
-    
+
     return log2(360 * ((width / normalizingFactor) / spanStraight));
 }