react-native-map4d-map-dtqg 0.1.4 → 0.1.6

package/README.md

@@ -8,6 +8,18 @@ Map4dMap DTQG SDK for React Native
 npm install react-native-map4d-map-dtqg
 ```
 
+## TurboModule compatibility
+
+This library supports React Native New Architecture module resolution for `Map4dMap` by using `TurboModuleRegistry` with automatic fallback to `NativeModules`.
+
+The package now also includes a TurboModule codegen spec (`src/specs/NativeMap4dMap.js`) and `codegenConfig` in `package.json` so React Native apps can generate module bindings in New Architecture builds.
+
+What this means:
+- On React Native apps with New Architecture enabled, map native module lookup works with TurboModule resolution.
+- On older React Native versions, the library keeps using legacy bridge resolution.
+- No public JavaScript API changes are required for existing apps.
+- Native `Map4dMap` APIs (`getCamera`, `getBounds`, `getMyLocation`, `pointForCoordinate`, `coordinateForPoint`, `cameraForBounds`) are implemented in both Android and iOS modules to align with the TurboModule spec.
+
 ## Usage
 
 ```javascript
@@ -131,3 +143,49 @@ Examples:
 - `focusArea({ type: 'freeTradeZone', id: 10 })`
 - `focusArea({ type: IndustrialEconomicType.NON_TARIFF_ZONE, id: 11 })`
 - `clearFocusedArea()` to clear current focus
+
+## MFBanDoSo usage
+
+`MFBanDoSo` extends `MFMapView`. It fetches a category config from a fixed internal URL, lets the user toggle which categories are shown, and syncs the resulting GeoJSON style to the map against a fixed internal vector tile source. Both URLs are internal to the SDK (only the `/staging` path segment can be toggled via `isStaging`) and are not otherwise configurable via props. It renders its own layer-selector and legend UI on top of the map — there is no prop to disable or reposition this UI.
+
+```javascript
+import {MFBanDoSo} from 'react-native-map4d-map-dtqg';
+import React from 'react';
+import {SafeAreaView, StyleSheet} from 'react-native';
+
+const INITIAL_CAMERA = {
+  center: {latitude: 16.157436, longitude: 106.243699},
+  zoom: 6,
+  bearing: 0,
+  tilt: 0,
+};
+
+function App() {
+  const onDataSourceFeaturePress = async (e) => {
+    console.log('Press Data Source Feature:', e.nativeEvent);
+  };
+
+  return (
+    <SafeAreaView style={styles.safeView}>
+      <MFBanDoSo
+        style={styles.container}
+        camera={INITIAL_CAMERA}
+        mapType="roadmap"
+        onDataSourceFeaturePress={onDataSourceFeaturePress}
+      />
+    </SafeAreaView>
+  );
+}
+
+const styles = StyleSheet.create({
+  safeView: {flex: 1},
+  container: {flex: 1},
+});
+
+export default App;
+```
+
+Props:
+- `isStaging`: optional `boolean`, default `true`. Selects between the staging and production API for both the category config and vector tile source (toggles the `/staging` path segment on the fixed internal host). Pass `isStaging={false}` to use production.
+- Otherwise no `MFBanDoSo`-specific props — the category config URL and vector tile source URL are fixed internally by the SDK.
+- All `MFMapView` props (`camera`, `mapType`, `mapStyle`, `onDataSourceFeaturePress`, etc.) and children (e.g. `MFBuilding`, `MFMarker`) are supported the same way as on `MFMapView`.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Wed Jul 08 09:44:56 ICT 2026
-gradle.version=9.2.0
+#Fri Jul 24 17:11:04 ICT 2026
+gradle.version=8.9

package/android/build.gradle

@@ -11,17 +11,29 @@ buildscript {
     }
 }
 
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
 apply plugin: 'com.android.library'
 
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
 android {
-    compileSdkVersion safeExtGet('Map4dMap_compileSdkVersion', 30)
+    compileSdkVersion safeExtGet('Map4dMap_compileSdkVersion', 33)
     defaultConfig {
         minSdkVersion safeExtGet('Map4dMap_minSdkVersion', 21)
-        targetSdkVersion safeExtGet('Map4dMap_targetSdkVersion', 30)
+        targetSdkVersion safeExtGet('Map4dMap_targetSdkVersion', 33)
         versionCode 1
         versionName "1.0"
 
@@ -39,6 +51,15 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+    sourceSets.main {
+        java {
+            if (isNewArchitectureEnabled()) {
+                srcDirs += [
+                    "${project.buildDir}/generated/source/codegen/java"
+                ]
+            }
+        }
+    }
 }
 
 repositories {

package/android/src/main/java/com/reactnativemap4dmap/Map4dMapModule.java

@@ -5,10 +5,13 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
 import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.UIManagerModule;
 
 import android.view.View;
@@ -26,6 +29,8 @@ interface ResolveViewCallback {
 
 public class Map4dMapModule extends ReactContextBaseJavaModule {
 
+  public static final String NAME = "Map4dMap";
+
     private final ReactApplicationContext reactContext;
 
     public Map4dMapModule(ReactApplicationContext reactContext) {
@@ -35,14 +40,35 @@ public class Map4dMapModule extends ReactContextBaseJavaModule {
 
     @Override
     public String getName() {
-        return "Map4dMap";
+      return NAME;
     }
 
     private void getView(final int tag, final ResolveViewCallback callback) {
       final ReactApplicationContext context = getReactApplicationContext();
 
-      UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
-      uiManager.addUIBlock(new UIBlock()
+      final UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(context, tag);
+      if (uiManager != null) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+          @Override
+          public void run() {
+            View view = uiManager.resolveView(tag);
+            if (view == null) {
+              Log.e(getName(), "View with tag: " + tag + " was not found");
+            }
+            callback.found(view);
+          }
+        });
+        return;
+      }
+
+      UIManagerModule legacyUIManager = context.getNativeModule(UIManagerModule.class);
+      if (legacyUIManager == null) {
+        Log.e(getName(), "Could not get UIManager to resolve tag: " + tag);
+        callback.found(null);
+        return;
+      }
+
+      legacyUIManager.addUIBlock(new UIBlock()
       {
         @Override
         public void execute(NativeViewHierarchyManager nvhm)
@@ -152,6 +178,7 @@ public class Map4dMapModule extends ReactContextBaseJavaModule {
     });
   }
 
+  @ReactMethod
   public void isMyLocationButtonEnabled(final int tag, final Promise promise) {
     getView(tag, new ResolveViewCallback(){
       @Override
@@ -167,20 +194,15 @@ public class Map4dMapModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void pointForCoordinate(final int tag, ReadableMap coordinate, final Promise promise) {
-    final ReactApplicationContext context = getReactApplicationContext();
-
     final MFLocationCoordinate coord = new MFLocationCoordinate(
             coordinate.hasKey("latitude") ? coordinate.getDouble("latitude") : 0.0,
             coordinate.hasKey("longitude") ? coordinate.getDouble("longitude") : 0.0
     );
 
-    UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
-    uiManager.addUIBlock(new UIBlock()
-    {
+    getView(tag, new ResolveViewCallback() {
       @Override
-      public void execute(NativeViewHierarchyManager nvhm)
-      {
-        RMFMapView mapView = (RMFMapView) nvhm.resolveView(tag);
+      public void found(View view) {
+        RMFMapView mapView = (RMFMapView) view;
         if (!validateMapView(mapView, promise)) {
           return;
         }
@@ -198,20 +220,15 @@ public class Map4dMapModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void coordinateForPoint(final int tag, ReadableMap point, final Promise promise) {
-    final ReactApplicationContext context = getReactApplicationContext();
-
     final Point pt = new Point(
             point.hasKey("x") ? (int)(point.getDouble("x")) : 0,
             point.hasKey("y") ? (int)(point.getDouble("y")) : 0
     );
 
-    UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
-    uiManager.addUIBlock(new UIBlock()
-    {
+    getView(tag, new ResolveViewCallback() {
       @Override
-      public void execute(NativeViewHierarchyManager nvhm)
-      {
-        RMFMapView mapView = (RMFMapView) nvhm.resolveView(tag);
+      public void found(View view) {
+        RMFMapView mapView = (RMFMapView) view;
         if (!validateMapView(mapView, promise)) {
           return;
         }
@@ -229,18 +246,13 @@ public class Map4dMapModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void cameraForBounds(final int tag, ReadableMap boundData, final Promise promise) {
-    final ReactApplicationContext context = getReactApplicationContext();
-    UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
-
     final ReadableMap bounds = boundData.getMap("bounds");
     final ReadableMap padding = boundData.getMap("padding");
 
-    uiManager.addUIBlock(new UIBlock()
-    {
+    getView(tag, new ResolveViewCallback() {
       @Override
-      public void execute(NativeViewHierarchyManager nvhm)
-      {
-        RMFMapView mapView = (RMFMapView) nvhm.resolveView(tag);
+      public void found(View view) {
+        RMFMapView mapView = (RMFMapView) view;
         if (!validateMapView(mapView, promise)) {
           return;
         }

package/ios/Map4dMap.h

@@ -1,7 +1,16 @@
 #import <React/RCTBridgeModule.h>
-#import "RMFMapViewManager.h"
-#import "RMFMarkerManager.h"
 
-@interface Map4dMap : NSObject <RCTBridgeModule>
+#if defined(RCT_NEW_ARCH_ENABLED) && __has_include("Map4dMapSpec.h")
+#import "Map4dMapSpec.h"
+#define MAP4D_HAS_NEW_ARCH_SPEC 1
+#else
+#define MAP4D_HAS_NEW_ARCH_SPEC 0
+#endif
+
+@interface Map4dMap : NSObject <RCTBridgeModule
+#if MAP4D_HAS_NEW_ARCH_SPEC
+, NativeMap4dMapSpec
+#endif
+>
 
 @end

package/ios/Map4dMap.m

@@ -1,14 +1,119 @@
 #import "Map4dMap.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTBridge.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTConvert+CoreLocation.h>
+#import "RCTConvert+Map4dMap.h"
+#import "RMFEventResponse.h"
+#import "RMFMapView.h"
 
 
 @implementation Map4dMap
 
 RCT_EXPORT_MODULE()
 
-RCT_EXPORT_METHOD(sampleMethod:(NSString *)stringArgument numberParameter:(nonnull NSNumber *)numberArgument callback:(RCTResponseSenderBlock)callback)
+- (void)withMapViewForTag:(nonnull NSNumber *)reactTag
+                  rejecter:(RCTPromiseRejectBlock)reject
+                   handler:(void (^)(RMFMapView *mapView))handler
 {
-    // TODO: Implement some actually useful functionality
-    callback(@[[NSString stringWithFormat: @"numberArgument: %@ stringArgument: %@", numberArgument, stringArgument]]);
+    RCTUIManager *uiManager = self.bridge.uiManager;
+    if (uiManager == nil) {
+        if (reject) {
+            reject(@"E_UI_MANAGER_UNAVAILABLE", @"UIManager is unavailable on iOS runtime", nil);
+        } else {
+            RCTLogError(@"UIManager is unavailable on iOS runtime");
+        }
+        return;
+    }
+
+    [uiManager addUIBlock:^(__unused RCTUIManager *manager,
+                            NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RMFMapView class]]) {
+            if (reject) {
+                reject(@"E_INVALID_VIEW",
+                       [NSString stringWithFormat:@"Invalid view returned from registry, expecting RMFMapView, got: %@", view],
+                       nil);
+            } else {
+                RCTLogError(@"Invalid view returned from registry, expecting RMFMapView, got: %@", view);
+            }
+            return;
+        }
+
+        handler((RMFMapView *)view);
+    }];
+}
+
+RCT_EXPORT_METHOD(getCamera:(nonnull NSNumber *)reactTag
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        resolve([RMFEventResponse fromCameraPosition:[mapView camera]]);
+    }];
+}
+
+RCT_EXPORT_METHOD(getBounds:(nonnull NSNumber *)reactTag
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        resolve([RMFEventResponse fromCoordinateBounds:[mapView getBounds]]);
+    }];
+}
+
+RCT_EXPORT_METHOD(getMyLocation:(nonnull NSNumber *)reactTag
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        resolve([RMFEventResponse fromCLLocation:[mapView getMyLocation]]);
+    }];
+}
+
+RCT_EXPORT_METHOD(pointForCoordinate:(nonnull NSNumber *)reactTag
+                                    coordinate:(id)json
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        CGPoint point = [mapView.projection pointForCoordinate:[RCTConvert CLLocationCoordinate2D:json]];
+        resolve([RMFEventResponse fromCGPoint:point]);
+    }];
+}
+
+RCT_EXPORT_METHOD(coordinateForPoint:(nonnull NSNumber *)reactTag
+                                    point:(id)json
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        CLLocationCoordinate2D coordinate = [mapView.projection coordinateForPoint:[RCTConvert CGPoint:json]];
+        resolve([RMFEventResponse fromCoordinate:coordinate]);
+    }];
+}
+
+RCT_EXPORT_METHOD(cameraForBounds:(nonnull NSNumber *)reactTag
+                                    boundsData:(id)json
+                                    resolver:(RCTPromiseResolveBlock)resolve
+                                    rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapViewForTag:reactTag rejecter:reject handler:^(RMFMapView *mapView) {
+        MFCameraPosition *camera = nil;
+        id data = [RCTConvert NSDictionary:json];
+        if (data[@"bounds"]) {
+            MFCoordinateBounds *bounds = [RCTConvert MFCoordinateBounds:data[@"bounds"]];
+            if (data[@"padding"]) {
+                UIEdgeInsets insets = [RCTConvert UIEdgeInsets:data[@"padding"]];
+                camera = [mapView cameraForBounds:bounds insets:insets];
+            } else {
+                camera = [mapView cameraForBounds:bounds];
+            }
+        }
+
+        resolve([RMFEventResponse fromCameraPosition:camera]);
+    }];
 }
 
 @end

package/ios/Map4dMapTurbo.mm

@@ -0,0 +1,16 @@
+#import "Map4dMap.h"
+
+#if defined(RCT_NEW_ARCH_ENABLED) && __has_include("Map4dMapSpec.h")
+#import "Map4dMapSpec.h"
+#import <ReactCommon/RCTTurboModule.h>
+#import <memory>
+
+@implementation Map4dMap (TurboModule)
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeMap4dMapSpecJSI>(params);
+}
+
+@end
+#endif

package/ios/RMFCircleManager.m

@@ -17,6 +17,26 @@
 
 RCT_EXPORT_MODULE(RMFCircle)
 
+- (void)withCircleForTag:(nonnull NSNumber *)reactTag
+                 handler:(void (^)(RMFCircle *circle))handler
+{
+  RCTUIManager *uiManager = self.bridge.uiManager;
+  if (uiManager == nil) {
+    RCTLogError(@"UIManager is unavailable on iOS runtime");
+    return;
+  }
+
+  [uiManager addUIBlock:^(__unused RCTUIManager *manager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFCircle class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
+      return;
+    }
+
+    handler((RMFCircle *)view);
+  }];
+}
+
 - (UIView *)view {
   RMFCircle * circle = [[RMFCircle alloc] init];
   return circle;
@@ -37,44 +57,26 @@ RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
 RCT_EXPORT_METHOD(setCenter:(nonnull NSNumber *)reactTag
                   withCoordinate:(id)coordinate)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setCenterCoordinate:[RCTConvert CLLocationCoordinate2D:coordinate]];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setCenterCoordinate:[RCTConvert CLLocationCoordinate2D:coordinate]];
   }];
 }
 
 RCT_EXPORT_METHOD(setRadius:(nonnull NSNumber *)reactTag
                   withRadius:(double)radius)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setRadius:radius];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setRadius:radius];
   }];
 }
 
 RCT_EXPORT_METHOD(setFillColor:(nonnull NSNumber *)reactTag
                   color:(id)color)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      UIColor* fillCorlor = [RCTConvert UIColor:color];
-      if (fillCorlor != nil) {
-        [circle setFillColor:fillCorlor];
-      }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    UIColor* fillCorlor = [RCTConvert UIColor:color];
+    if (fillCorlor != nil) {
+      [circle setFillColor:fillCorlor];
     }
   }];
 }
@@ -82,16 +84,10 @@ RCT_EXPORT_METHOD(setFillColor:(nonnull NSNumber *)reactTag
 RCT_EXPORT_METHOD(setStrokeColor:(nonnull NSNumber *)reactTag
                   color:(id)color)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      UIColor* strokeColor = [RCTConvert UIColor:color];
-      if (strokeColor != nil) {
-        [circle setStrokeColor:strokeColor];
-      }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    UIColor* strokeColor = [RCTConvert UIColor:color];
+    if (strokeColor != nil) {
+      [circle setStrokeColor:strokeColor];
     }
   }];
 }
@@ -99,56 +95,32 @@ RCT_EXPORT_METHOD(setStrokeColor:(nonnull NSNumber *)reactTag
 RCT_EXPORT_METHOD(setStrokeWidth:(nonnull NSNumber *)reactTag
                   width:(double)width)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setStrokeWidth:width];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setStrokeWidth:width];
   }];
 }
 
 RCT_EXPORT_METHOD(setZIndex:(nonnull NSNumber *)reactTag
                   zIndex:(float)zIndex)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setZIndex:zIndex];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setZIndex:zIndex];
   }];
 }
 
 RCT_EXPORT_METHOD(setVisible:(nonnull NSNumber *)reactTag
                   visible:(BOOL)visible)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setVisible:visible];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setVisible:visible];
   }];
 }
 
 RCT_EXPORT_METHOD(setUserData:(nonnull NSNumber *)reactTag
                   userData:(id)json)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFCircle class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFCircle *circle = (RMFCircle *)view;
-      [circle setUserData:[RCTConvert NSDictionary:json]];
-    }
+  [self withCircleForTag:reactTag handler:^(RMFCircle *circle) {
+    [circle setUserData:[RCTConvert NSDictionary:json]];
   }];
 }
 

package/ios/RMFDirectionsRendererManager.m

@@ -15,6 +15,26 @@
 
 RCT_EXPORT_MODULE(RMFDirectionsRenderer)
 
+- (void)withRendererForTag:(nonnull NSNumber *)reactTag
+                   handler:(void (^)(RMFDirectionsRenderer *renderer))handler
+{
+  RCTUIManager *uiManager = self.bridge.uiManager;
+  if (uiManager == nil) {
+    RCTLogError(@"UIManager is unavailable on iOS runtime");
+    return;
+  }
+
+  [uiManager addUIBlock:^(__unused RCTUIManager *manager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RMFDirectionsRenderer class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RMFDirectionsRenderer, got: %@", view);
+      return;
+    }
+
+    handler((RMFDirectionsRenderer *)view);
+  }];
+}
+
 - (UIView*)view {
   RMFDirectionsRenderer* renderer = [[RMFDirectionsRenderer alloc] init];
   return renderer;
@@ -42,42 +62,24 @@ RCT_EXPORT_VIEW_PROPERTY(onPress, RCTBubblingEventBlock)
 RCT_EXPORT_METHOD(setActivedIndex:(nonnull NSNumber *)reactTag
                   withRouteIndex:(NSUInteger)routeIndex)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFDirectionsRenderer class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFCircle, got: %@", view);
-    } else {
-      RMFDirectionsRenderer* renderer = (RMFDirectionsRenderer*)view;
-      renderer.activedIndex = routeIndex;
-    }
+  [self withRendererForTag:reactTag handler:^(RMFDirectionsRenderer *renderer) {
+    renderer.activedIndex = routeIndex;
   }];
 }
 
 RCT_EXPORT_METHOD(setRoutes:(nonnull NSNumber *)reactTag
                   withRoutes:(id)routes)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFDirectionsRenderer class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFPolygon, got: %@", view);
-    } else {
-      RMFDirectionsRenderer* renderer = (RMFDirectionsRenderer*)view;
-      [renderer setRoutes:[RCTConvert RMFCoordinateArrayArray:routes]];
-    }
+  [self withRendererForTag:reactTag handler:^(RMFDirectionsRenderer *renderer) {
+    [renderer setRoutes:[RCTConvert RMFCoordinateArrayArray:routes]];
   }];
 }
 
 RCT_EXPORT_METHOD(setDirections:(nonnull NSNumber *)reactTag
                   withDirections:(NSString*)directions)
 {
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[RMFDirectionsRenderer class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting RMFMarker, got: %@", view);
-    } else {
-      RMFDirectionsRenderer* renderer = (RMFDirectionsRenderer*)view;
-      [renderer.map4dDirectionsRenderer setRoutesWithJson:directions];
-    }
+  [self withRendererForTag:reactTag handler:^(RMFDirectionsRenderer *renderer) {
+    [renderer.map4dDirectionsRenderer setRoutesWithJson:directions];
   }];
 }