@aguacerowx/react-native 0.0.46 → 0.0.49

package/ios/NexradRadarLayerView.swift

@@ -0,0 +1,475 @@
+import Foundation
+import MapboxMaps
+import React
+import UIKit
+
+@objc(NexradRadarLayerView)
+public final class NexradRadarLayerView: UIView {
+
+    public static let nexradLayerId = "aguacero-nexrad-custom-layer"
+    private static let weatherGridLayerId = "aguacero-weather-grid-custom"
+
+    @objc public var layerInstance: NexradRadarLayer!
+    @objc public weak var mapView: MapView?
+    @objc public var layerId: String = NexradRadarLayerView.nexradLayerId
+    @objc public var belowID: String?
+
+    @objc public weak var bridge: RCTBridge?
+
+    private var isLayerAdded = false
+    private var nexradReparentScheduled = false
+
+    /// Obj-C diagnostics (`NexradRadarManager`).
+    @objc public var nexradLayerAdded: Bool { isLayerAdded }
+
+    private let decodeQueue = DispatchQueue(label: "com.aguacero.nexrad-decode", qos: .utility)
+    private var decodeGeneration = 0
+
+    private var gpuReadyObserver: NSObjectProtocol?
+
+
+    public override init(frame: CGRect) {
+        layerInstance = NexradRadarLayer(id: NexradRadarLayerView.nexradLayerId)
+        super.init(frame: frame)
+        isOpaque = false
+        setupObservers()
+    }
+
+    required init?(coder: NSCoder) {
+        layerInstance = NexradRadarLayer(id: NexradRadarLayerView.nexradLayerId)
+        super.init(coder: coder)
+        setupObservers()
+    }
+
+    deinit {
+        if let gpuReadyObserver {
+            NotificationCenter.default.removeObserver(gpuReadyObserver)
+        }
+    }
+
+    private func setupObservers() {
+        gpuReadyObserver = NotificationCenter.default.addObserver(
+            forName: NSNotification.Name("AguaceroNexradGpuFrameReadyInternal"),
+            object: nil,
+            queue: .main
+        ) { [weak self] note in
+            guard let key = note.userInfo?["nativeGpuCacheKey"] as? String else { return }
+            self?.emitGpuReadyToJs(key)
+        }
+    }
+
+    private func emitGpuReadyToJs(_ key: String) {
+        guard let bridge else { return }
+        bridge.enqueueJSCall(
+            "RCTDeviceEventEmitter",
+            method: "emit",
+            args: ["AguaceroNexradGpuFrameReady", ["nativeGpuCacheKey": key]],
+            completion: nil
+        )
+    }
+
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil && !isLayerAdded {
+            findMapViewAndAddLayer(in: window!)
+        }
+    }
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        if !isLayerAdded {
+            let root = window ?? superview
+            if let root {
+                findMapViewAndAddLayer(in: root)
+            }
+        }
+    }
+
+    private func findMapViewAndAddLayer(in view: UIView) {
+        if isLayerAdded {
+            return
+        }
+
+        if let map = findMapViewRecursive(view) {
+            self.mapView = map
+            waitForStyleLoadAndAddLayer()
+            return
+        }
+    }
+
+    private func findMapViewRecursive(_ view: UIView) -> MapView? {
+        let name = NSStringFromClass(type(of: view))
+        if name == "RNMBXMapView", view.subviews.count > 0 {
+            let first = view.subviews[0]
+            let subName = NSStringFromClass(type(of: first))
+            if subName.contains("MapboxMaps.MapView") || subName == "MapView" {
+                return first as? MapView
+            }
+        }
+        for sub in view.subviews {
+            if let found = findMapViewRecursive(sub) {
+                return found
+            }
+        }
+        return nil
+    }
+
+    private func waitForStyleLoadAndAddLayer() {
+        guard let mapView else {
+            return
+        }
+        let anchor = belowID ?? "AML_-_terrain"
+        let anchorExists = GridRenderLayerBridge.layerExists(in: mapView, layerId: anchor)
+        if anchorExists {
+            addLayerToMap()
+            return
+        }
+        pollForLayerExistence(anchor: anchor, attempts: 0)
+    }
+
+    private func pollForLayerExistence(anchor: String, attempts: Int) {
+        guard let mapView, !isLayerAdded else { return }
+        if attempts > 80 {
+            return
+        }
+        if GridRenderLayerBridge.layerExists(in: mapView, layerId: anchor) {
+            addLayerToMap()
+            return
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            self?.pollForLayerExistence(anchor: anchor, attempts: attempts + 1)
+        }
+    }
+
+    private func addLayerToMap() {
+        guard let mapView, !isLayerAdded else {
+            return
+        }
+        guard let host = layerInstance.getHostWrapper() as? CustomLayerHost else {
+            return
+        }
+
+        let gridExists = GridRenderLayerBridge.layerExists(in: mapView, layerId: Self.weatherGridLayerId)
+
+        let success = GridRenderLayerBridge.addNexradCustomLayer(
+            to: mapView,
+            layerHost: host,
+            layerId: layerId,
+            weatherGridLayerId: Self.weatherGridLayerId,
+            belowLayerId: belowID
+        )
+
+        if success {
+            isLayerAdded = true
+            GridRenderLayerBridge.triggerRepaint(on: mapView)
+            scheduleReparentAboveGridOnce()
+        } else {
+        }
+    }
+
+    private func scheduleReparentAboveGridOnce() {
+        if nexradReparentScheduled { return }
+        nexradReparentScheduled = true
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self] in
+            self?.nexradReparentScheduled = false
+            self?.reparentAboveGridIfNeeded()
+        }
+    }
+
+    private func reparentAboveGridIfNeeded() {
+        guard let mapView else { return }
+        let gridOk = GridRenderLayerBridge.layerExists(in: mapView, layerId: Self.weatherGridLayerId)
+        let nexradOk = GridRenderLayerBridge.layerExists(in: mapView, layerId: layerId)
+        guard gridOk, nexradOk else {
+            return
+        }
+        guard let host = layerInstance.getHostWrapper() as? CustomLayerHost else {
+            return
+        }
+
+        GridRenderLayerBridge.removeCustomLayer(from: mapView, layerId: layerId)
+        _ = GridRenderLayerBridge.addNexradCustomLayer(
+            to: mapView,
+            layerHost: host,
+            layerId: layerId,
+            weatherGridLayerId: Self.weatherGridLayerId,
+            belowLayerId: belowID
+        )
+        GridRenderLayerBridge.triggerRepaint(on: mapView)
+    }
+
+    public override func removeFromSuperview() {
+        if let mapView, isLayerAdded {
+            GridRenderLayerBridge.removeCustomLayer(from: mapView, layerId: layerId)
+        }
+        super.removeFromSuperview()
+    }
+
+    // MARK: - Decode helpers (Android `NexradRadarLayerView` parity)
+
+    private static func decodeRleGateData(_ compressed: Data, expectedSize: Int) -> Data {
+        let comp = [UInt8](compressed)
+        var out = [UInt8](repeating: 0, count: expectedSize)
+        var outIdx = 0
+        var inIdx = 0
+        while inIdx + 3 < comp.count && outIdx + 1 < expectedSize {
+            let count = Int(comp[inIdx]) | (Int(comp[inIdx + 1]) << 8)
+            let val0 = comp[inIdx + 2]
+            let val1 = comp[inIdx + 3]
+            inIdx += 4
+            for _ in 0 ..< count where outIdx + 1 < expectedSize {
+                out[outIdx] = val0
+                out[outIdx + 1] = val1
+                outIdx += 2
+            }
+        }
+        return Data(out)
+    }
+
+    // MARK: - Commands from RN
+
+    @objc public func uploadFrameFromJson(_ json: String?) {
+        guard let json, !json.isEmpty else {
+            return
+        }
+        let genSnapshot = decodeGeneration
+        decodeQueue.async { [weak self] in
+            guard let self else {
+                return
+            }
+            let wallStart = CFAbsoluteTimeGetCurrent()
+            autoreleasepool {
+            do {
+                let tJson0 = CFAbsoluteTimeGetCurrent()
+                guard let data = json.data(using: .utf8) else {
+                    return
+                }
+                // `.mutableContainers` so we can drop huge base64 string keys after decoding (peak RAM / jetsam).
+                guard var o = try JSONSerialization.jsonObject(with: data, options: [.mutableContainers]) as? [String: Any] else {
+                    return
+                }
+                let jsonMs = (CFAbsoluteTimeGetCurrent() - tJson0) * 1000
+
+                let tGate0 = CFAbsoluteTimeGetCurrent()
+                guard let gateB64 = o["gateB64"] as? String,
+                      let gateRaw = Data(base64Encoded: gateB64) else {
+                    return
+                }
+
+                let nGates = o["nGates"] as? Int ?? 0
+                let nRays = o["nRays"] as? Int ?? 0
+                let gateIsRle = o["gateIsRle"] as? Bool ?? false
+                let gateBytes: Data = gateIsRle
+                    ? Self.decodeRleGateData(gateRaw, expectedSize: nGates * nRays * 2)
+                    : gateRaw
+                let gateMs = (CFAbsoluteTimeGetCurrent() - tGate0) * 1000
+
+                let expectedGateBytes = max(0, nGates * nRays * 2)
+                guard gateBytes.count >= expectedGateBytes, expectedGateBytes > 0 else {
+                    return
+                }
+
+                let stationLat = o["stationLat"] as? Double ?? 0
+                let stationLon = o["stationLon"] as? Double ?? 0
+                let firstGateKm = Float(o["firstGateKm"] as? Double ?? 0)
+                let gateWidthKm = Float(o["gateWidthKm"] as? Double ?? 0)
+
+                guard let rayArr = o["rayBoundaries"] as? [Double] else {
+                    return
+                }
+                let ray = rayArr.map { Float($0) }
+                guard ray.count >= nRays + 1 else {
+                    return
+                }
+
+                let uploadOpts = o["uploadOpts"] as? [String: Any]
+                let geometryLayoutKey = uploadOpts?["geometryLayoutKey"] as? String ?? ""
+
+                let tGpu0 = CFAbsoluteTimeGetCurrent()
+                let gpuMatch = RadarFrameGpuMatch.prepareRadarFrameForGpuReadout(
+                    nRays: nRays,
+                    nGates: nGates,
+                    gateData: gateBytes,
+                    rayBoundariesDeg: ray,
+                    geometryLayoutKey: geometryLayoutKey
+                )
+                let gpuMs = (CFAbsoluteTimeGetCurrent() - tGpu0) * 1000
+
+                // Drop multi‑MB base64 string before LUT + geometry to lower peak RSS (jetsam on iOS).
+                o.removeValue(forKey: "gateB64")
+
+                guard let lutB64 = o["lutB64"] as? String else {
+                    return
+                }
+                let lut: Data = autoreleasepool {
+                    let decoded = Data(base64Encoded: lutB64)
+                    return decoded ?? Data()
+                }
+                guard lut.count >= 256 * 4 else {
+                    return
+                }
+                o.removeValue(forKey: "lutB64")
+
+                let valueScale = Float(o["valueScale"] as? Double ?? 1)
+                let valueOffset = Float(o["valueOffset"] as? Double ?? 0)
+                let lutMin = Float(o["lutMin"] as? Double ?? 0)
+                let lutMax = Float(o["lutMax"] as? Double ?? 80)
+                let discrete = Float(o["discreteIntegerLut"] as? Double ?? 0)
+                let opacity = Float(o["opacity"] as? Double ?? 1)
+                let gateSmooth = Float(o["gateSmoothPolar"] as? Double ?? 1)
+                let interpolateLut = o["interpolateLut"] as? Int ?? 1
+                let nativeGpuCacheKeyRaw = o["nativeGpuCacheKey"] as? String ?? ""
+                let nativeGpuCacheKey: String? = nativeGpuCacheKeyRaw.isEmpty ? nil : nativeGpuCacheKeyRaw
+
+
+                let geomKey = NexradRadarLayer.buildGeometryCacheKey(
+                    nRays: nRays,
+                    nGates: nGates,
+                    stationLat: stationLat,
+                    stationLon: stationLon,
+                    firstGateKm: firstGateKm,
+                    gateWidthKm: gateWidthKm,
+                    rayBoundariesDeg: gpuMatch.rayBoundariesDeg
+                )
+
+                let committedBeforeGeom = self.layerInstance.isGeometryCommitted(geomKey)
+
+                var geomVertices: [Float]?
+                var geomVertexCount = 0
+                var ax = Float(0)
+                var ay = Float(0)
+
+                var geomBuildMs: Double = 0
+
+                if !committedBeforeGeom {
+                    let floatsPerVert = 4
+                    let vertsPerGate = 6
+                    let _estFloats = nRays * nGates * vertsPerGate * floatsPerVert
+                    let tGeom0 = CFAbsoluteTimeGetCurrent()
+                    let built = RadarRayGeometryBuilder.build(
+                        nRays: nRays,
+                        nGates: nGates,
+                        stationLat: stationLat,
+                        stationLon: stationLon,
+                        firstGateKm: firstGateKm,
+                        gateWidthKm: gateWidthKm,
+                        rayBoundariesDeg: gpuMatch.rayBoundariesDeg
+                    )
+                    geomBuildMs = (CFAbsoluteTimeGetCurrent() - tGeom0) * 1000
+                    geomVertices = built.vertexFloats
+                    geomVertexCount = built.vertexCount
+                    ax = built.anchorMercatorX
+                    ay = built.anchorMercatorY
+                }
+
+                let bgTotalMs = (CFAbsoluteTimeGetCurrent() - wallStart) * 1000
+
+                DispatchQueue.main.async { [weak self] in
+                    guard let self else {
+                        return
+                    }
+                    if genSnapshot != self.decodeGeneration {
+                        return
+                    }
+                    if !self.isLayerAdded {
+                        if let win = self.window {
+                            self.findMapViewAndAddLayer(in: win)
+                        } else {
+                        }
+                    }
+                    self.layerInstance.requestFullFrameUpload(
+                        gateBytes: gpuMatch.gateData,
+                        nGates: nGates,
+                        nRays: nRays,
+                        stationLat: stationLat,
+                        stationLon: stationLon,
+                        firstGateKm: firstGateKm,
+                        gateWidthKm: gateWidthKm,
+                        rayBoundariesDeg: gpuMatch.rayBoundariesDeg,
+                        lutRgba256: lut,
+                        valueScale: valueScale,
+                        valueOffset: valueOffset,
+                        lutMin: lutMin,
+                        lutMax: lutMax,
+                        discreteIntegerLut: discrete,
+                        opacity: opacity,
+                        gateSmoothPolar: gateSmooth,
+                        interpolateLut: interpolateLut,
+                        nativeGpuCacheKey: nativeGpuCacheKey,
+                        geomVertices: geomVertices,
+                        geomVertexCount: geomVertexCount,
+                        anchorMercatorX: ax,
+                        anchorMercatorY: ay
+                    )
+                    if let mv = self.mapView {
+                        GridRenderLayerBridge.triggerRepaint(on: mv)
+                    }
+                }
+            } catch {
+            }
+            }
+        }
+    }
+
+    @objc public func activateNexradCachedFrame(_ key: String?) {
+        guard let key, !key.isEmpty else {
+            return
+        }
+        layerInstance.requestActivateCachedFrame(key)
+        if let mapView {
+            GridRenderLayerBridge.triggerRepaint(on: mapView)
+        } else {
+        }
+    }
+
+    @objc public func uploadStyleOnlyFromJson(_ json: String?) {
+        guard let json, !json.isEmpty else {
+            return
+        }
+        do {
+            guard let data = json.data(using: .utf8),
+                  let o = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                return
+            }
+            if !isLayerAdded, let win = window {
+                findMapViewAndAddLayer(in: win)
+            }
+            guard let lutB64 = o["lutB64"] as? String,
+                  let lut = Data(base64Encoded: lutB64) else {
+                return
+            }
+            let valueScale = Float(o["valueScale"] as? Double ?? 1)
+            let valueOffset = Float(o["valueOffset"] as? Double ?? 0)
+            let lutMin = Float(o["lutMin"] as? Double ?? 0)
+            let lutMax = Float(o["lutMax"] as? Double ?? 80)
+            let discrete = Float(o["discreteIntegerLut"] as? Double ?? 0)
+            let opacity = Float(o["opacity"] as? Double ?? 1)
+            let gateSmooth = Float(o["gateSmoothPolar"] as? Double ?? 1)
+            let interpolateLut = o["interpolateLut"] as? Int ?? 1
+
+            layerInstance.requestStyleOnlyUpload(
+                lutRgba256: lut,
+                valueScale: valueScale,
+                valueOffset: valueOffset,
+                lutMin: lutMin,
+                lutMax: lutMax,
+                discreteIntegerLut: discrete,
+                opacity: opacity,
+                gateSmoothPolar: gateSmooth,
+                interpolateLut: interpolateLut
+            )
+            if let mapView {
+                GridRenderLayerBridge.triggerRepaint(on: mapView)
+            }
+        } catch {
+        }
+    }
+
+    @objc public func clearNexrad() {
+        decodeGeneration += 1
+        layerInstance.clearFrame()
+        if let mapView {
+            GridRenderLayerBridge.triggerRepaint(on: mapView)
+        }
+    }
+}

package/ios/NexradRadarManager.mm

@@ -0,0 +1,162 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+
+#if __has_include("aguacerowx_react_native-Swift.h")
+    #import "aguacerowx_react_native-Swift.h"
+#else
+    #import <aguacerowx_react_native/aguacerowx_react_native-Swift.h>
+#endif
+
+@interface NexradRadarManager : RCTViewManager
+@end
+
+@implementation NexradRadarManager
+
+RCT_EXPORT_MODULE(NexradRadarLayer)
+
+/// JS `UIManager.getViewManagerConfig('NexradRadarLayer').Commands` — must match `receiveCommand:` cases below.
+- (NSDictionary *)constantsToExport {
+    return @{
+        @"Commands" : @{
+            @"uploadNexradFrame" : @1,
+            @"uploadNexradStyleOnly" : @2,
+            @"clearNexrad" : @3,
+            @"activateNexradCachedFrame" : @4,
+        },
+    };
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (UIView *)view {
+    NexradRadarLayerView *v = [[NexradRadarLayerView alloc] init];
+    v.bridge = self.bridge;
+    return v;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(belowID, NSString)
+
+// MARK: - RCT_EXPORT_METHOD (required for New Architecture / Fabric interop)
+//
+// Numeric `dispatchViewManagerCommand(handle, N, args)` indexes into the RCT_EXPORT_METHOD
+// table — not into receiveCommand. NexradRadarManager had only receiveCommand, so N was
+// out-of-bounds. These exports match JS command names and GridRenderLayer bridge style.
+
+RCT_EXPORT_METHOD(uploadNexradFrame:(nonnull NSNumber *)reactTag json:(NSString *)json)
+{
+    NSUInteger jlen = json.length;
+    RCTLogInfo(@"📡 [NEXRAD][iOS] uploadNexradFrame UIBlock reactTag=%@ jsonChars=%lu", reactTag, (unsigned long)jlen);
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        UIView *view = viewRegistry[reactTag];
+        if (view == nil) {
+            RCTLogError(@"📡 [NEXRAD][iOS] uploadNexradFrame NO VIEW for reactTag=%@", reactTag);
+            return;
+        }
+        if (![view isKindOfClass:[NexradRadarLayerView class]]) {
+            RCTLogError(@"📡 [NEXRAD][iOS] uploadNexradFrame WRONG CLASS %@ — expected NexradRadarLayerView", NSStringFromClass([view class]));
+            return;
+        }
+        NexradRadarLayerView *v = (NexradRadarLayerView *)view;
+        [v uploadFrameFromJson:json];
+    }];
+}
+
+RCT_EXPORT_METHOD(uploadNexradStyleOnly:(nonnull NSNumber *)reactTag json:(NSString *)json)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        UIView *view = viewRegistry[reactTag];
+        if (view == nil || ![view isKindOfClass:[NexradRadarLayerView class]]) {
+            RCTLogWarn(@"📡 [NEXRAD][iOS] uploadNexradStyleOnly bad view tag=%@ class=%@", reactTag, view ? NSStringFromClass([view class]) : @"(nil)");
+            return;
+        }
+        [(NexradRadarLayerView *)view uploadStyleOnlyFromJson:json];
+    }];
+}
+
+RCT_EXPORT_METHOD(clearNexrad:(nonnull NSNumber *)reactTag)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        UIView *view = viewRegistry[reactTag];
+        if (view == nil || ![view isKindOfClass:[NexradRadarLayerView class]]) {
+            RCTLogWarn(@"📡 [NEXRAD][iOS] clearNexrad bad view tag=%@", reactTag);
+            return;
+        }
+        [(NexradRadarLayerView *)view clearNexrad];
+    }];
+}
+
+RCT_EXPORT_METHOD(activateNexradCachedFrame:(nonnull NSNumber *)reactTag key:(NSString *)key)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        UIView *view = viewRegistry[reactTag];
+        if (view == nil || ![view isKindOfClass:[NexradRadarLayerView class]]) {
+            RCTLogWarn(@"📡 [NEXRAD][iOS] activateNexradCachedFrame bad view tag=%@", reactTag);
+            return;
+        }
+        [(NexradRadarLayerView *)view activateNexradCachedFrame:key];
+    }];
+}
+
+/// Legacy Paper path; Fabric routes through RCT_EXPORT_METHOD entries above.
+- (void)receiveCommand:(UIView *)view commandID:(NSInteger)commandID args:(NSArray<id> *)args {
+    NexradRadarLayerView *v = (NexradRadarLayerView *)view;
+    if (![v isKindOfClass:[NexradRadarLayerView class]]) {
+        RCTLogWarn(@"🔍 [NexradRadarManager] receiveCommand ignored — view class %@", NSStringFromClass([view class]));
+        return;
+    }
+    NSString *cmdName = @(commandID).description;
+    switch (commandID) {
+        case 1:
+            cmdName = @"uploadNexradFrame";
+            break;
+        case 2:
+            cmdName = @"uploadNexradStyleOnly";
+            break;
+        case 3:
+            cmdName = @"clearNexrad";
+            break;
+        case 4:
+            cmdName = @"activateNexradCachedFrame";
+            break;
+        default:
+            break;
+    }
+    NSUInteger jsonLen = 0;
+    if (args.count > 0 && [args[0] isKindOfClass:[NSString class]]) {
+        jsonLen = [(NSString *)args[0] length];
+    }
+    RCTLogInfo(@"🔍 [NexradRadarManager] receiveCommand %@ (id=%ld) args=%lu jsonChars=%lu mapViewAttached=%d nexradLayerAdded=%d",
+               cmdName, (long)commandID, (unsigned long)args.count, (unsigned long)jsonLen, v.mapView != nil, v.nexradLayerAdded);
+    NSLog(@"🔍 [NexradRadarManager] receiveCommand %@ id=%ld jsonChars=%lu layerAdded=%d",
+          cmdName, (long)commandID, (unsigned long)jsonLen, v.nexradLayerAdded ? 1 : 0);
+    switch (commandID) {
+        case 1: {
+            NSString *json = args.count > 0 ? [RCTConvert NSString:args[0]] : nil;
+            [v uploadFrameFromJson:json];
+            break;
+        }
+        case 2: {
+            NSString *json = args.count > 0 ? [RCTConvert NSString:args[0]] : nil;
+            [v uploadStyleOnlyFromJson:json];
+            break;
+        }
+        case 3:
+            [v clearNexrad];
+            break;
+        case 4: {
+            NSString *key = args.count > 0 ? [RCTConvert NSString:args[0]] : nil;
+            [v activateNexradCachedFrame:key];
+            break;
+        }
+        default:
+            RCTLogWarn(@"🔍 [NexradRadarManager] unknown commandID %ld", (long)commandID);
+            break;
+    }
+}
+
+@end