@maplibre/maplibre-react-native 11.0.0-alpha.16 → 11.0.0-alpha.18

package/android/src/main/java/org/maplibre/reactnative/MLRNPackage.kt

@@ -29,7 +29,7 @@ import org.maplibre.reactnative.components.sources.MLRNRasterSourceManager
 import org.maplibre.reactnative.components.sources.MLRNShapeSourceManager
 import org.maplibre.reactnative.components.sources.MLRNVectorSourceManager
 import org.maplibre.reactnative.modules.MLRNLocationModule
-import org.maplibre.reactnative.modules.MLRNLogging
+import org.maplibre.reactnative.modules.MLRNLogModule
 import org.maplibre.reactnative.modules.MLRNModule
 import org.maplibre.reactnative.modules.MLRNOfflineModule
 import org.maplibre.reactnative.modules.MLRNSnapshotModule
@@ -56,7 +56,7 @@ class MLRNPackage : BaseReactPackage() {
             MLRNOfflineModule.REACT_CLASS -> return MLRNOfflineModule(reactContext)
             MLRNSnapshotModule.NAME -> return MLRNSnapshotModule(reactContext)
             MLRNLocationModule.NAME -> return MLRNLocationModule(reactContext)
-            MLRNLogging.REACT_CLASS -> return MLRNLogging(reactContext)
+            MLRNLogModule.NAME -> return MLRNLogModule(reactContext)
         }
 
         return null
@@ -120,13 +120,13 @@ class MLRNPackage : BaseReactPackage() {
                 isTurboModule = true
             )
 
-            moduleInfos[MLRNLogging.REACT_CLASS] = ReactModuleInfo(
-                MLRNLogging.REACT_CLASS,
-                MLRNLogging.REACT_CLASS,
+            moduleInfos[MLRNLogModule.NAME] = ReactModuleInfo(
+                MLRNLogModule.NAME,
+                MLRNLogModule.NAME,
                 canOverrideExistingModule = false,
                 needsEagerInit = false,
                 isCxxModule = false,
-                isTurboModule = false
+                isTurboModule = true
             )
 
             moduleInfos

package/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCameraManager.kt

@@ -14,10 +14,8 @@ import org.maplibre.reactnative.location.TrackUserLocationMode
 import org.maplibre.reactnative.utils.GeoJSONUtils
 
 @ReactModule(name = MLRNCameraManager.REACT_CLASS)
-class MLRNCameraManager(private val mContext: ReactApplicationContext) :
-    ViewGroupManager<MLRNCamera>(
-
-    ), MLRNCameraManagerInterface<MLRNCamera> {
+class MLRNCameraManager(private val context: ReactApplicationContext) :
+    ViewGroupManager<MLRNCamera>(), MLRNCameraManagerInterface<MLRNCamera> {
     private val delegate: MLRNCameraManagerDelegate<MLRNCamera, MLRNCameraManager> =
         MLRNCameraManagerDelegate(this)
 
@@ -42,7 +40,7 @@ class MLRNCameraManager(private val mContext: ReactApplicationContext) :
     @ReactProp(name = "initialViewState")
     override fun setInitialViewState(camera: MLRNCamera, value: ReadableMap?) {
         if (value != null && !camera.hasInitialViewState()) {
-            val stop = CameraStop.fromReadableMap(mContext, value, null)
+            val stop = CameraStop.fromReadableMap(context, value, null)
             camera.setInitialViewState(stop)
         }
     }

package/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.kt

@@ -0,0 +1,154 @@
+package org.maplibre.reactnative.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import org.maplibre.android.location.LocationComponent
+import org.maplibre.android.location.LocationComponentActivationOptions
+import org.maplibre.android.location.LocationComponentOptions
+import org.maplibre.android.location.OnCameraTrackingChangedListener
+import org.maplibre.android.location.modes.CameraMode
+import org.maplibre.android.location.modes.RenderMode
+import org.maplibre.android.maps.MapLibreMap
+import org.maplibre.android.maps.Style
+import org.maplibre.reactnative.R
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+import org.maplibre.reactnative.location.LocationManager
+
+/**
+ * The LocationComponent on android implements both location tracking and display of user's current location.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
+ */
+class LocationComponentManager(mapView: MLRNMapView?, private val context: Context) {
+    private var mMapView: MLRNMapView? = null
+    private var mMap: MapLibreMap? = null
+
+    private var mLocationManager: LocationManager? = null
+    private var mLocationComponent: LocationComponent? = null
+
+    @RenderMode.Mode
+    private var mRenderMode: Int = RenderMode.COMPASS
+
+    private var mShowUserLocation = false
+
+    private var mFollowUserLocation = false
+
+    private var mShowingUserLocation = false
+
+    private var mOnCameraTrackingChangedListener: OnCameraTrackingChangedListener? = null
+
+    init {
+        mMapView = mapView
+        mMap = mMapView?.mapLibreMap
+
+        mLocationManager = LocationManager.getInstance(context)
+    }
+
+    fun showUserLocation(showUserLocation: Boolean) {
+        mShowUserLocation = showUserLocation
+        stateChanged()
+    }
+
+    fun setFollowUserLocation(followUserLocation: Boolean) {
+        mFollowUserLocation = followUserLocation
+        stateChanged()
+    }
+
+    fun setCameraMode(@CameraMode.Mode cameraMode: Int) {
+        mLocationComponent?.cameraMode = cameraMode
+    }
+
+    fun setRenderMode(@RenderMode.Mode renderMode: Int) {
+        mRenderMode = renderMode
+        if (mShowingUserLocation) {
+            mLocationComponent?.renderMode = renderMode
+        }
+    }
+
+    fun setPreferredFramesPerSecond(preferredFramesPerSecond: Int) {
+        if (preferredFramesPerSecond <= 0) {
+            return
+        }
+
+        mLocationComponent?.setMaxAnimationFps(preferredFramesPerSecond)
+    }
+
+    fun addOnCameraTrackingChangedListener(onCameraTrackingChangedListener: OnCameraTrackingChangedListener?) {
+        mOnCameraTrackingChangedListener?.let {
+            mLocationComponent?.removeOnCameraTrackingChangedListener(
+                it
+            )
+        }
+
+        mOnCameraTrackingChangedListener = onCameraTrackingChangedListener
+
+        mOnCameraTrackingChangedListener?.let { mLocationComponent?.addOnCameraTrackingChangedListener(it) }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun stateChanged() {
+        mLocationComponent?.setLocationComponentEnabled((mFollowUserLocation || mShowUserLocation))
+
+        if (mShowingUserLocation != mShowUserLocation) {
+            updateShowUserLocation(mShowUserLocation)
+        }
+
+        if (mFollowUserLocation) {
+            if (!mShowUserLocation) {
+                mLocationComponent?.renderMode = RenderMode.GPS
+            } else {
+                mLocationComponent?.renderMode = mRenderMode
+            }
+            mLocationComponent?.onStart()
+        } else {
+            mLocationComponent?.cameraMode = CameraMode.NONE
+        }
+    }
+
+    fun hasLocationComponent(): Boolean {
+        return (mLocationComponent != null)
+    }
+
+    fun update(style: Style) {
+        update(mShowUserLocation, style)
+    }
+
+    fun update(displayUserLocation: Boolean, style: Style) {
+        val tintColor = mMapView?.tintColor
+
+        if (mLocationComponent == null || tintColor != null) {
+            mLocationComponent = mMap?.locationComponent
+
+            val locationComponentActivationOptions: LocationComponentActivationOptions =
+                LocationComponentActivationOptions.builder(context, style)
+                    .locationComponentOptions(options(displayUserLocation)).build()
+            mLocationComponent?.activateLocationComponent(locationComponentActivationOptions)
+            mLocationComponent?.locationEngine = mLocationManager!!.engine
+            mShowingUserLocation = displayUserLocation
+        }
+
+        updateShowUserLocation(displayUserLocation)
+    }
+
+    private fun updateShowUserLocation(displayUserLocation: Boolean) {
+        if (mShowingUserLocation != displayUserLocation) {
+            mLocationComponent?.applyStyle(options(displayUserLocation))
+            mShowingUserLocation = displayUserLocation
+        }
+    }
+
+    fun options(displayUserLocation: Boolean): LocationComponentOptions {
+        var builder: LocationComponentOptions.Builder = LocationComponentOptions.builder(context)
+        val tintColor = mMapView?.tintColor
+        if (!displayUserLocation) {
+            builder = builder.padding(mMap?.getPadding()).backgroundDrawable(R.drawable.empty)
+                .backgroundDrawableStale(R.drawable.empty).bearingDrawable(R.drawable.empty)
+                .foregroundDrawable(R.drawable.empty).foregroundDrawableStale(R.drawable.empty)
+                .gpsDrawable(R.drawable.empty).accuracyAlpha(0.0f)
+        } else if (tintColor != null) {
+            builder = builder.enableStaleState(false).bearingTintColor(tintColor)
+                .foregroundTintColor(tintColor).accuracyColor(tintColor)
+        }
+        return builder.build()
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/location/MLRNNativeUserLocation.kt

@@ -0,0 +1,70 @@
+package org.maplibre.reactnative.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import org.maplibre.android.location.modes.RenderMode
+import org.maplibre.android.location.permissions.PermissionsManager
+import org.maplibre.android.maps.MapLibreMap
+import org.maplibre.android.maps.OnMapReadyCallback
+import org.maplibre.android.maps.Style
+import org.maplibre.android.maps.Style.OnStyleLoaded
+import org.maplibre.reactnative.components.AbstractMapFeature
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+
+class MLRNNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback,
+    OnStyleLoaded {
+    private var enabled = true
+    private var map: MapLibreMap? = null
+    private var mapView: MLRNMapView? = null
+
+    @RenderMode.Mode
+    private var mRenderMode = RenderMode.COMPASS
+    private var mPreferredFramesPerSecond = 0
+
+    override fun addToMap(mapView: MLRNMapView) {
+        enabled = true
+        this.mapView = mapView
+        mapView.getMapAsync(this)
+        setRenderMode(mRenderMode)
+        setPreferredFramesPerSecond(mPreferredFramesPerSecond)
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView?) {
+        enabled = false
+        if (map != null) map!!.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onMapReady(mapLibreMap: MapLibreMap) {
+        map = mapLibreMap
+        mapLibreMap.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onStyleLoaded(style: Style) {
+        val context = getContext()
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        val locationComponent = mapView!!.locationComponentManager
+        locationComponent.update(style)
+        locationComponent.showUserLocation(enabled)
+    }
+
+    fun setRenderMode(@RenderMode.Mode renderMode: Int) {
+        mRenderMode = renderMode
+        if (mapView != null) {
+            val locationComponent = mapView!!.locationComponentManager
+            locationComponent.setRenderMode(renderMode)
+        }
+    }
+
+    fun setPreferredFramesPerSecond(framesPerSecond: Int) {
+        mPreferredFramesPerSecond = framesPerSecond
+        if (mapView != null) {
+            val locationComponent = mapView!!.locationComponentManager
+            locationComponent.setPreferredFramesPerSecond(framesPerSecond)
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/location/MLRNNativeUserLocationManager.kt

@@ -0,0 +1,50 @@
+package org.maplibre.reactnative.components.location
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MLRNNativeUserLocationManagerDelegate
+import com.facebook.react.viewmanagers.MLRNNativeUserLocationManagerInterface
+import org.maplibre.android.location.modes.RenderMode
+
+@ReactModule(name = MLRNNativeUserLocationManager.REACT_CLASS)
+class MLRNNativeUserLocationManager() :
+    ViewGroupManager<MLRNNativeUserLocation>(),
+    MLRNNativeUserLocationManagerInterface<MLRNNativeUserLocation> {
+    private val delegate: MLRNNativeUserLocationManagerDelegate<MLRNNativeUserLocation, MLRNNativeUserLocationManager> =
+        MLRNNativeUserLocationManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNNativeUserLocation> = delegate
+
+    companion object {
+        const val REACT_CLASS: String = "MLRNNativeUserLocation"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): MLRNNativeUserLocation {
+        return MLRNNativeUserLocation(context)
+    }
+
+    @ReactProp(name = "mode")
+    override fun setMode(userLocation: MLRNNativeUserLocation, mode: String?) {
+        if ("heading".equals(mode, ignoreCase = true)) {
+            userLocation.setRenderMode(RenderMode.COMPASS)
+        } else if ("course".equals(mode, ignoreCase = true)) {
+            userLocation.setRenderMode(RenderMode.GPS)
+        } else {
+            userLocation.setRenderMode(RenderMode.NORMAL)
+        }
+    }
+
+    @ReactProp(name = "androidPreferredFramesPerSecond")
+    override fun setAndroidPreferredFramesPerSecond(
+        userLocation: MLRNNativeUserLocation, preferredFramesPerSecond: Int
+    ) {
+        userLocation.setPreferredFramesPerSecond(preferredFramesPerSecond)
+    }
+
+
+}

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNLocationModule.kt

@@ -134,15 +134,31 @@ class MLRNLocationModule(reactContext: ReactApplicationContext) :
 
         coords.putDouble("longitude", location.longitude)
         coords.putDouble("latitude", location.latitude)
-        coords.putDouble("altitude", location.altitude)
         coords.putDouble("accuracy", location.accuracy.toDouble())
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+
+        if (location.hasAltitude()) {
+            coords.putDouble("altitude", location.altitude)
+        } else {
+            coords.putNull("altitude")
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && location.hasVerticalAccuracy()) {
             coords.putDouble("altitudeAccuracy", location.verticalAccuracyMeters.toDouble())
         } else {
             coords.putNull("altitudeAccuracy")
         }
-        coords.putDouble("heading", location.bearing.toDouble())
-        coords.putDouble("speed", location.speed.toDouble())
+
+        if (location.hasBearing()) {
+            coords.putDouble("heading", location.bearing.toDouble())
+        } else {
+            coords.putNull("heading")
+        }
+
+        if (location.hasSpeed()) {
+            coords.putDouble("speed", location.speed.toDouble())
+        } else {
+            coords.putNull("speed")
+        }
 
         val geolocationPosition: WritableMap = WritableNativeMap()
         geolocationPosition.putMap("coords", coords)

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNLogModule.kt

@@ -0,0 +1,99 @@
+package org.maplibre.reactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import org.maplibre.android.log.Logger
+import org.maplibre.android.log.LoggerDefinition
+import org.maplibre.reactnative.NativeLogModuleSpec
+
+class MLRNLogModule(reactContext: ReactApplicationContext) : NativeLogModuleSpec(
+    reactContext
+) {
+
+    companion object {
+        const val NAME: String = "MLRNLogModule"
+    }
+
+    override fun getName() = NAME
+
+
+    init {
+        Logger.setVerbosity(Logger.WARN)
+
+        Logger.setLoggerDefinition(object : LoggerDefinition {
+            override fun v(tag: String, msg: String) {
+                Log.v(tag, msg)
+                onLog("verbose", tag, msg)
+            }
+
+            override fun v(tag: String, msg: String, tr: Throwable) {
+                Log.v(tag, msg, tr)
+                onLog("verbose", tag, msg)
+            }
+
+            override fun d(tag: String, msg: String) {
+                Log.d(tag, msg)
+                onLog("debug", tag, msg)
+            }
+
+            override fun d(tag: String, msg: String, tr: Throwable) {
+                Log.d(tag, msg, tr)
+                onLog("debug", tag, msg)
+            }
+
+            override fun i(tag: String, msg: String) {
+                Log.i(tag, msg)
+                onLog("info", tag, msg)
+            }
+
+            override fun i(tag: String, msg: String, tr: Throwable) {
+                Log.i(tag, msg, tr)
+                onLog("info", tag, msg)
+            }
+
+            override fun w(tag: String, msg: String) {
+                Log.w(tag, msg)
+                onLog("warn", tag, msg)
+            }
+
+            override fun w(tag: String, msg: String, tr: Throwable) {
+                Log.w(tag, msg, tr)
+                onLog("warn", tag, msg)
+            }
+
+            override fun e(tag: String, msg: String) {
+                Log.e(tag, msg)
+                onLog("error", tag, msg)
+            }
+
+            override fun e(tag: String, msg: String, tr: Throwable) {
+                Log.e(tag, msg, tr)
+                onLog("error", tag, msg)
+            }
+        })
+    }
+
+
+    override fun setLogLevel(level: String) {
+        @Logger.LogLevel val logLevel = when (level) {
+            "error" -> Logger.ERROR
+            "warn" -> Logger.WARN
+            "info" -> Logger.INFO
+            "debug" -> Logger.DEBUG
+            "verbose" -> Logger.VERBOSE
+            else -> Logger.NONE
+        }
+        Logger.setVerbosity(logLevel)
+    }
+
+
+    fun onLog(level: String, tag: String, msg: String) {
+        val event = Arguments.createMap()
+        event.putString("level", level)
+        event.putString("tag", tag)
+        event.putString("message", msg)
+
+        emitOnLog(event)
+    }
+}

package/ios/components/camera/MLRNCameraComponentView.h

@@ -1,12 +1,6 @@
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIKit.h>
 
-#import <React/RCTUIManager.h>
-#import <React/RCTViewComponentView.h>
-
-#ifndef MLRNCameraComponentView_h
-#define MLRNCameraComponentView_h
-
 NS_ASSUME_NONNULL_BEGIN
 
 @interface MLRNCameraComponentView : RCTViewComponentView
@@ -14,5 +8,3 @@ NS_ASSUME_NONNULL_BEGIN
 @end
 
 NS_ASSUME_NONNULL_END
-
-#endif

package/ios/components/map-view/MLRNMapView.m

@@ -351,7 +351,7 @@ static double const M2PI = M_PI * 2;
   MLRNStyle *style = [[MLRNStyle alloc] init];
   [style lightLayer:light
       withReactStyle:_reactLight
-             isValid:^BOOL{
+             isValid:^BOOL {
                return self.style != nil;
              }];
   self.style.light = light;

package/ios/components/map-view/MLRNMapViewComponentView.h

@@ -4,9 +4,6 @@
 #import <React/RCTUIManager.h>
 #import <React/RCTViewComponentView.h>
 
-#ifndef MLRNMapViewComponentView_h
-#define MLRNMapViewComponentView_h
-
 NS_ASSUME_NONNULL_BEGIN
 
 @interface MLRNMapViewComponentView : RCTViewComponentView
@@ -14,5 +11,3 @@ NS_ASSUME_NONNULL_BEGIN
 @end
 
 NS_ASSUME_NONNULL_END
-
-#endif

package/ios/components/user-location/MLRNNativeUserLocation.h

@@ -6,6 +6,6 @@
 @interface MLRNNativeUserLocation : UIView
 
 @property (nonatomic, strong) MLRNMapView *map;
-@property (nonatomic) BOOL iosShowsUserHeadingIndicator;
+@property (nonatomic) BOOL showsUserHeadingIndicator;
 
 @end

package/ios/components/user-location/MLRNNativeUserLocation.m

@@ -17,20 +17,21 @@
     _map.showsUserHeadingIndicator = NO;
   } else if (map) {
     map.useNativeUserLocationAnnotationView = YES;
-    // Toggle off/on showsUserLocation in order for Mapbox to invalidate the
+    // Toggle off/on showsUserLocation in order for MapLibre Native to invalidate the
     // current (hidden) user location annotation view. See also: HiddenUserLocationAnnotationView
     map.showsUserLocation = NO;
     map.showsUserLocation = YES;
-    map.showsUserHeadingIndicator = self.iosShowsUserHeadingIndicator;
+    map.showsUserHeadingIndicator = self.showsUserHeadingIndicator;
   }
 
   _map = map;
 }
 
-- (void)setIosShowsUserHeadingIndicator:(BOOL)iosShowsUserHeadingIndicator {
-  _iosShowsUserHeadingIndicator = iosShowsUserHeadingIndicator;
+- (void)setShowsUserHeadingIndicator:(BOOL)showsUserHeadingIndicator {
+  _showsUserHeadingIndicator = showsUserHeadingIndicator;
+
   if (_map) {
-    _map.showsUserHeadingIndicator = iosShowsUserHeadingIndicator;
+    _map.showsUserHeadingIndicator = showsUserHeadingIndicator;
   }
 }
 

package/ios/components/user-location/MLRNNativeUserLocationComponentView.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNNativeUserLocationComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/components/user-location/MLRNNativeUserLocationComponentView.mm

@@ -0,0 +1,51 @@
+#import "MLRNNativeUserLocationComponentView.h"
+
+#import <react/renderer/components/MapLibreReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/Props.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "MLRNNativeUserLocation.h"
+
+using namespace facebook::react;
+
+@interface MLRNNativeUserLocationComponentView () <RCTMLRNNativeUserLocationViewProtocol>
+
+@end
+
+@implementation MLRNNativeUserLocationComponentView {
+  MLRNNativeUserLocation *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNNativeUserLocationProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNNativeUserLocation alloc] init];
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNNativeUserLocationProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNNativeUserLocationProps const>(props);
+
+  if (oldViewProps.mode != newViewProps.mode) {
+    [_view setShowsUserHeadingIndicator:newViewProps.mode != MLRNNativeUserLocationMode::Default];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNNativeUserLocationComponentDescriptor>();
+}
+
+@end

package/ios/modules/location/MLRNLocation.m

@@ -2,22 +2,25 @@
 
 @implementation MLRNLocation
 
-- (NSDictionary<NSString *, id> *)toJSON {
-  NSMutableDictionary<NSString *, id> *json = [[NSMutableDictionary alloc] init];
-
-  NSMutableDictionary<NSString *, NSNumber *> *coords = [[NSMutableDictionary alloc] init];
-  coords[@"longitude"] = @(_location.coordinate.longitude);
-  coords[@"latitude"] = @(_location.coordinate.latitude);
-  coords[@"accuracy"] = @(_location.horizontalAccuracy);
-  coords[@"altitude"] = @(_location.altitude);
-  coords[@"altitudeAccuracy"] = @(_location.verticalAccuracy);
-  coords[@"heading"] = @(_location.course);
-  coords[@"speed"] = @(_location.speed);
+- (id)numberOrNull:(double)value {
+  return value < 0 ? [NSNull null] : @(value);
+}
 
-  json[@"coords"] = coords;
-  json[@"timestamp"] = @([_location.timestamp timeIntervalSince1970]);
+- (NSDictionary<NSString *, id> *)toJSON {
+  double altitudeAccuracy = _location.verticalAccuracy;
 
-  return json;
+  return @{
+    @"coords" : @{
+      @"longitude" : @(_location.coordinate.longitude),
+      @"latitude" : @(_location.coordinate.latitude),
+      @"accuracy" : @(_location.horizontalAccuracy),
+      @"altitude" : altitudeAccuracy < 0 ? [NSNull null] : @(_location.altitude),
+      @"altitudeAccuracy" : [self numberOrNull:altitudeAccuracy],
+      @"heading" : [self numberOrNull:_location.course],
+      @"speed" : [self numberOrNull:_location.speed]
+    },
+    @"timestamp" : @([_location.timestamp timeIntervalSince1970])
+  };
 }
 
 @end

package/ios/modules/logging/MLRNLogModule.h

@@ -0,0 +1,10 @@
+#import <MapLibreReactNativeSpec/MapLibreReactNativeSpec.h>
+
+#import "MLRNLogging.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNLogModule : NativeLogModuleSpecBase <NativeLogModuleSpec, MLRNLoggingDelegate>
+@end
+
+NS_ASSUME_NONNULL_END