react-native-maps 1.20.1 → 1.21.0-alpha.10

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;
@@ -85,8 +86,8 @@ const NSInteger AIRMapMaxZoomLevel = 20;
         self.calloutView = [SMCalloutView platformCalloutView];
         self.calloutView.delegate = self;
         
-        self.minZoomLevel = 0;
-        self.maxZoomLevel = AIRMapMaxZoomLevel;
+        self.minZoom = 0;
+        self.maxZoom = AIRMapMaxZoomLevel;
         self.compassOffset = CGPointMake(0, 0);
         self.legacyZoomConstraintsEnabled = YES;
     }
@@ -199,36 +200,25 @@ const NSInteger AIRMapMaxZoomLevel = 20;
     }
     return marker;
 }
+// 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];
 
+// Set Map viewport
+
+[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;
@@ -322,7 +312,7 @@ const NSInteger AIRMapMaxZoomLevel = 20;
     return kSMCalloutViewRepositionDelayForUIScrollView;
 }
 
-#pragma mark Accessors
+#pragma mark RNMapsAirModuleDelegate.h
 
 - (NSArray *)getMapBoundaries
 {
@@ -342,6 +332,169 @@ const NSInteger AIRMapMaxZoomLevel = 20;
         ]
     ];
 }
+- (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 *) getCamera {
+    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
+                      callback:(RCTPromiseResolveBlock) callback
+{
+    
+  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"];
+  MKCoordinateRegion region = [RCTConvert MKCoordinateRegion:config[@"region"]];
+ 
+
+  options.region = (region.center.latitude && region.center.longitude) ? 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
+               callback:callback];
+}
+
+#pragma mark Take Snapshot
+- (void)takeMapSnapshot:(MKMapSnapshotter *) snapshotter
+        format:(NSString *)format
+        quality:(CGFloat) quality
+        result:(NSString *)result
+        callback:(RCTPromiseResolveBlock) callback {
+    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) {
+                      callback(@[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];
+                          callback(filePath);
+                      }
+                      else if ([result isEqualToString:@"base64"]) {
+                          callback([data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]);
+                      }
+                  }
+                  UIGraphicsEndImageContext();
+              }];
+}
+
+
 
 - (void)setShowsUserLocation:(BOOL)showsUserLocation
 {
@@ -372,7 +525,7 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 
 - (void)setFollowsUserLocation:(BOOL)followsUserLocation
 {
-    _followUserLocation = followsUserLocation;
+    _followsUserLocation = followsUserLocation;
 }
 
 - (void)setUserLocationCalloutEnabled:(BOOL)calloutEnabled

package/ios/AirMaps/AIRMapManager.m

@@ -52,13 +52,13 @@ RCT_EXPORT_MODULE()
 
     map.isAccessibilityElement = NO;
     map.accessibilityElementsHidden = NO;
-    
+
     // MKMapView doesn't report tap events, so we attach gesture recognizers to it
     UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleMapTap:)];
     UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleMapDoubleTap:)];
     [doubleTap setNumberOfTapsRequired:2];
     [tap requireGestureRecognizerToFail:doubleTap];
-    
+
     UILongPressGestureRecognizer *longPress = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handleMapLongPress:)];
     UIPanGestureRecognizer *drag = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(handleMapDrag:)];
     [drag setMinimumNumberOfTouches:1];
@@ -66,13 +66,13 @@ RCT_EXPORT_MODULE()
     tap.cancelsTouchesInView = NO;
     doubleTap.cancelsTouchesInView = NO;
     longPress.cancelsTouchesInView = NO;
-    
+
     doubleTap.delegate = self;
-    
+
     // disable drag by default
     drag.enabled = NO;
     drag.delegate = self;
-  
+
     [map addGestureRecognizer:tap];
     [map addGestureRecognizer:doubleTap];
     [map addGestureRecognizer:longPress];
@@ -139,7 +139,7 @@ RCT_CUSTOM_VIEW_PROPERTY(initialRegion, MKCoordinateRegion, AIRMap)
 RCT_CUSTOM_VIEW_PROPERTY(initialCamera, MKMapCamera, AIRMap)
 {
     if (json == nil) return;
-    
+
     // don't emit region change events when we are setting the initialCamera
     BOOL originalIgnore = view.ignoreRegionChanges;
     view.ignoreRegionChanges = YES;
@@ -166,7 +166,7 @@ RCT_CUSTOM_VIEW_PROPERTY(region, MKCoordinateRegion, AIRMap)
 RCT_CUSTOM_VIEW_PROPERTY(camera, MKMapCamera*, AIRMap)
 {
     if (json == nil) return;
-    
+
     // don't emit region change events when we are setting the camera
     BOOL originalIgnore = view.ignoreRegionChanges;
     view.ignoreRegionChanges = YES;
@@ -350,23 +350,8 @@ RCT_EXPORT_METHOD(fitToCoordinates:(nonnull NSNumber *)reactTag
             RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
         } else {
             AIRMap *mapView = (AIRMap *)view;
-
-            // Create Polyline with coordinates
-            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
-            CGFloat top = [RCTConvert CGFloat:edgePadding[@"top"]];
-            CGFloat right = [RCTConvert CGFloat:edgePadding[@"right"]];
-            CGFloat bottom = [RCTConvert CGFloat:edgePadding[@"bottom"]];
-            CGFloat left = [RCTConvert CGFloat:edgePadding[@"left"]];
-
-            [mapView setVisibleMapRect:[polyline boundingMapRect] edgePadding:UIEdgeInsetsMake(top, left, bottom, right) animated:animated];
-
+            UIEdgeInsets edgeInsets = [RCTConvert UIEdgeInsets:edgePadding];
+            [mapView fitToCoordinates: coordinates edgePadding:edgeInsets animated:animated];
         }
     }];
 }
@@ -551,16 +536,16 @@ RCT_EXPORT_METHOD(getAddressFromCoordinates:(nonnull NSNumber *)reactTag
                                   [overlay drawToSnapshot:snapshot context:UIGraphicsGetCurrentContext()];
                           }
                       }
-                      
+
                       for (id <MKAnnotation> annotation in mapView.annotations) {
                           CGPoint point = [snapshot pointForCoordinate:annotation.coordinate];
-                          
+
                           MKAnnotationView* anView = [mapView 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);
@@ -720,7 +705,7 @@ RCT_EXPORT_METHOD(getAddressFromCoordinates:(nonnull NSNumber *)reactTag
 - (void)handleMapDoubleTap:(UIPanGestureRecognizer*)recognizer {
     AIRMap *map = (AIRMap *)recognizer.view;
     if (!map.onDoublePress) return;
-    
+
     CGPoint touchPoint = [recognizer locationInView:map];
     CLLocationCoordinate2D coord = [map convertPoint:touchPoint toCoordinateFromView:map];
     map.onDoublePress(@{
@@ -733,7 +718,7 @@ RCT_EXPORT_METHOD(getAddressFromCoordinates:(nonnull NSNumber *)reactTag
                             @"y": @(touchPoint.y),
                             },
                     });
-    
+
 }
 
 
@@ -925,15 +910,15 @@ static int kDragCenterContext;
                          @"heading": @(location.location.course),
                          }
                  };
-    
+
     if (mapView.onUserLocationChange) {
         mapView.onUserLocationChange(event);
     }
-    
-    if (mapView.followUserLocation) {
+
+    if (mapView.followsUserLocation) {
         [mapView setCenterCoordinate:location.coordinate animated:YES];
     }
-    
+
 }
 
 - (void)mapView:(AIRMap *)mapView regionWillChangeAnimated:(BOOL)animated
@@ -1171,15 +1156,15 @@ static int kDragCenterContext;
     // flyover maps don't use mercator projection so we can't calculate their zoom level.
     if (mapView.mapType == MKMapTypeHybridFlyover || mapView.mapType == MKMapTypeSatelliteFlyover) {
         return;
-    } 
+    }
 
     CGFloat zoomLevel = [mapView getZoomLevel];
 
-    if (zoomLevel < mapView.minZoomLevel) {
-      [self setCenterCoordinate:[mapView centerCoordinate] zoomLevel:mapView.minZoomLevel animated:TRUE mapView:mapView];
+    if (zoomLevel < mapView.minZoom) {
+      [self setCenterCoordinate:[mapView centerCoordinate] zoomLevel:mapView.minZoom animated:TRUE mapView:mapView];
     }
-    else if (zoomLevel > mapView.maxZoomLevel) {
-      [self setCenterCoordinate:[mapView centerCoordinate] zoomLevel:mapView.maxZoomLevel animated:TRUE mapView:mapView];
+    else if (zoomLevel > mapView.maxZoom) {
+      [self setCenterCoordinate:[mapView centerCoordinate] zoomLevel:mapView.maxZoom animated:TRUE mapView:mapView];
     }
 }
 

package/ios/AirMaps/AIRMapMarker.m

@@ -70,6 +70,14 @@ NSInteger const AIR_CALLOUT_OPEN_ZINDEX_BASELINE = 999;
         [super insertReactSubview:(UIView *)subview atIndex:atIndex];
     }
 }
+- (void) setFrame:(CGRect)frame {
+    // hack to ignore call by react transactions when it shouldn't
+    if (!CGPointEqualToPoint(self.frame.origin, CGPointZero) &&
+        CGPointEqualToPoint(frame.origin, CGPointZero)){
+        return;
+    }
+    [super setFrame:frame];
+}
 
 - (void)removeReactSubview:(id<RCTComponent>)subview {
     if ([subview isKindOfClass:[AIRMapCallout class]] && self.calloutView == subview) {
@@ -84,7 +92,7 @@ NSInteger const AIR_CALLOUT_OPEN_ZINDEX_BASELINE = 999;
     if ([self shouldUsePinView]) {
         // In this case, we want to render a platform "default" legacy marker.
 
-        
+
         if (_pinView == nil && _useLegacyPinView) {
             _pinView = [[MKPinAnnotationView alloc] initWithAnnotation:self reuseIdentifier: nil];
             [self addGestureRecognizerToView:_pinView];
@@ -99,8 +107,8 @@ NSInteger const AIR_CALLOUT_OPEN_ZINDEX_BASELINE = 999;
 
             return _pinView;
         }
-    
-        
+
+
 
         if (_markerView == nil && !_useLegacyPinView) {
             _markerView = [[MKMarkerAnnotationView alloc] initWithAnnotation:self reuseIdentifier: nil];

package/ios/AirMaps/RCTConvert+AirMap.h

@@ -7,6 +7,8 @@
 #import <MapKit/MapKit.h>
 #import <React/RCTConvert.h>
 
+@class AIRMapCoordinate;
+
 @interface RCTConvert (AirMap)
 
 + (MKCoordinateSpan)MKCoordinateSpan:(id)json;
@@ -14,5 +16,8 @@
 + (MKMapCamera*)MKMapCamera:(id)json;
 + (MKMapCamera*)MKMapCameraWithDefaults:(id)json existingCamera:(MKMapCamera*)camera;
 + (MKMapType)MKMapType:(id)json;
-
++ (NSDictionary*) dictonaryFromString:(NSString *) str;
++ (NSArray*) arrayFromString:(NSString *) str;
++ (NSArray<NSArray<AIRMapCoordinate *> *> *)AIRMapCoordinateArrayArray:(id)json;
++ (AIRMapCoordinate*) AIRMapCoordinate:(id)json;
 @end

package/ios/AirMaps/RCTConvert+AirMap.m

@@ -27,12 +27,30 @@
   };
 }
 
+
 + (MKMapCamera*)MKMapCamera:(id)json
 {
     json = [self NSDictionary:json];
     return [RCTConvert MKMapCameraWithDefaults:json existingCamera:nil];
 }
 
++ (NSDictionary*) dictonaryFromString:(NSString *) str {
+    NSError *jsonError;
+    NSData *objectData = [str dataUsingEncoding:NSUTF8StringEncoding];
+    return [NSJSONSerialization JSONObjectWithData:objectData
+                                              options:NSJSONReadingMutableContainers
+                                                error:&jsonError];
+}
+
++ (NSArray*) arrayFromString:(NSString *) str {
+    NSError *jsonError;
+    NSData *objectData = [str dataUsingEncoding:NSUTF8StringEncoding];
+    return [NSJSONSerialization JSONObjectWithData:objectData
+                                              options:NSJSONReadingMutableContainers
+                                                error:&jsonError];
+}
+
+
 + (MKMapCamera*)MKMapCameraWithDefaults:(id)json existingCamera:(MKMapCamera*)camera
 {
     json = [self NSDictionary:json];

package/ios/AirMaps/RNMapsAirModule.h

@@ -0,0 +1,16 @@
+//  RCTNativeLocalStorage.h
+//  TurboModuleExample
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <Foundation/Foundation.h>
+#import <RNMapsSpecs/RNMapsSpecs.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNMapsAirModule : NSObject <NativeAirMapsModuleSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/AirMaps/RNMapsAirModule.mm

@@ -0,0 +1,149 @@
+//
+//  RNMapsMarkerManager.m
+//  AirMaps
+//
+//  Created by Salah Ghanim on 23.11.24.
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+
+#import "RNMapsAirModule.h"
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+#import "RNMapsMapView.h"
+#import "AIRMap.h"
+#import "AIRMapSnapshot.h"
+#import <MapKit/MapKit.h>
+#import "RCTConvert+AirMap.h"
+
+@implementation RNMapsAirModule
+
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
+- (void)executeWithMapView:(double)tag
+                   success:(void (^)(id<RNMapsAirModuleDelegate> mapView))success
+                   reject:(RCTPromiseRejectBlock)reject {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        id view = [_viewRegistry_DEPRECATED viewForReactTag:[NSNumber numberWithDouble:tag]];
+        if ([view conformsToProtocol:@protocol(RNMapsHostVewDelegate)]) {
+            id<RNMapsAirModuleDelegate> mapViewDelegate = [view mapView];
+            success(mapViewDelegate);
+        } else {
+            reject(@"Invalid argument", [NSString stringWithFormat:@"Invalid view returned from registry, expecting RNMapsMapView, got: %@", view], NULL);
+        }
+    });
+}
+
+- (void)getCamera:(double)tag
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        resolve([mapView getCamera]);
+    } reject:reject];
+
+}
+
+- (void)getMarkersFrames:(double)tag
+             onlyVisible:(BOOL)onlyVisible
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        resolve([mapView getMarkersFramesWithOnlyVisible:onlyVisible]);
+    } reject:reject];
+}
+- (void)getMapBoundaries:(double)tag
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        resolve([mapView getMapBoundaries]);
+    } reject:reject];
+}
+- (void)takeSnapshot:(double)tag
+              config:(NSDictionary *)config
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        [mapView takeSnapshotWithConfig:config callback:resolve];
+    } reject:reject];
+}
+
+- (void)getAddressFromCoordinates:(double)tag
+                       coordinate:(JS::NativeAirMapsModule::LatLng &)coordinate
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
+{
+    double latitude = coordinate.latitude();
+    double longitude = coordinate.longitude();
+    
+  
+    CLLocation *location = [[CLLocation alloc] initWithLatitude:latitude
+                                                          longitude:longitude];
+    CLGeocoder *geoCoder = [[CLGeocoder alloc] init];
+    [geoCoder reverseGeocodeLocation:location
+                       completionHandler:^(NSArray *placemarks, NSError *error) {
+        if (error == nil && [placemarks count] > 0){
+            CLPlacemark *placemark = placemarks[0];
+            resolve(@{
+                @"name" : [NSString stringWithFormat:@"%@", placemark.name],
+                @"thoroughfare" : [NSString stringWithFormat:@"%@", placemark.thoroughfare],
+                @"subThoroughfare" : [NSString stringWithFormat:@"%@", placemark.subThoroughfare],
+                @"locality" : [NSString stringWithFormat:@"%@", placemark.locality],
+                @"subLocality" : [NSString stringWithFormat:@"%@", placemark.subLocality],
+                @"administrativeArea" : [NSString stringWithFormat:@"%@", placemark.administrativeArea],
+                @"subAdministrativeArea" : [NSString stringWithFormat:@"%@", placemark.subAdministrativeArea],
+                @"postalCode" : [NSString stringWithFormat:@"%@", placemark.postalCode],
+                @"countryCode" : [NSString stringWithFormat:@"%@", placemark.ISOcountryCode],
+                @"country" : [NSString stringWithFormat:@"%@", placemark.country],
+            });
+        } else {
+            reject(@"Invalid argument", [NSString stringWithFormat:@"Can not get address location"], NULL);
+        }
+    }];
+}
+
+- (void)getPointForCoordinate:(double)tag
+                   coordinate:(JS::NativeAirMapsModule::LatLng &)coordinate
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+    double latitude = coordinate.latitude();
+    double longitude = coordinate.longitude();
+    
+    CLLocationCoordinate2D location = CLLocationCoordinate2DMake(latitude,longitude);
+    
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        resolve([mapView getPointForCoordinates:location]);
+        
+    } reject:reject];
+    
+}
+- (void)getCoordinateForPoint:(double)tag
+                        point:(JS::NativeAirMapsModule::Point &)point
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+    double x = point.x();
+    double y = point.y();
+    CGPoint pt = CGPointMake(x,y);
+    [self executeWithMapView:tag success:^(id<RNMapsAirModuleDelegate> mapView) {
+        resolve([mapView getCoordinatesForPoint:pt]);
+    } reject:reject];
+   
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeAirMapsModuleSpecJSI>(params);
+}
+
++ (NSString *)moduleName { 
+    return nil;
+}
+
+
+
+@end
+

package/ios/AirMaps/RNMapsMapView.h

@@ -0,0 +1,24 @@
+//
+//  RNMapsMarker.h
+//  AirMaps
+//
+//  Created by Salah Ghanim on 23.11.24.
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+#import "RNMapsHostVewDelegate.h"
+
+@class AIRMap;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNMapsMapView : RCTViewComponentView<RNMapsHostVewDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif