@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/location-engine-google/io/github/mapvina/reactnative/location/engine/GoogleLocationEngineImpl.kt

@@ -0,0 +1,142 @@
+package io.github.mapvina.reactnative.location.engine
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import androidx.annotation.VisibleForTesting
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import com.google.android.gms.tasks.OnFailureListener
+import com.google.android.gms.tasks.OnSuccessListener
+import io.github.mapvina.android.location.engine.LocationEngineCallback
+import io.github.mapvina.android.location.engine.LocationEngineImpl
+import io.github.mapvina.android.location.engine.LocationEngineRequest
+import io.github.mapvina.android.location.engine.LocationEngineResult
+
+/**
+ * Wraps implementation of Fused Location Provider
+ */
+class GoogleLocationEngineImpl : LocationEngineImpl<LocationCallback?> {
+    private val fusedLocationProviderClient: FusedLocationProviderClient
+
+    @VisibleForTesting
+    internal constructor(fusedLocationProviderClient: FusedLocationProviderClient) {
+        this.fusedLocationProviderClient = fusedLocationProviderClient
+    }
+
+    constructor(context: Context) {
+        this.fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(context)
+    }
+
+    override fun createListener(callback: LocationEngineCallback<LocationEngineResult?>): LocationCallback =
+        GoogleLocationEngineCallbackTransport(callback)
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun getLastLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+        val transport = GoogleLastLocationEngineCallbackTransport(callback)
+        fusedLocationProviderClient.lastLocation
+            .addOnSuccessListener(transport)
+            .addOnFailureListener(transport)
+    }
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest,
+        listener: LocationCallback,
+        looper: Looper?,
+    ) {
+        fusedLocationProviderClient.requestLocationUpdates(
+            toGMSLocationRequest(request),
+            listener,
+            looper,
+        )
+    }
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest,
+        pendingIntent: PendingIntent,
+    ) {
+        fusedLocationProviderClient.requestLocationUpdates(
+            toGMSLocationRequest(request),
+            pendingIntent,
+        )
+    }
+
+    override fun removeLocationUpdates(listener: LocationCallback?) {
+        if (listener != null) {
+            fusedLocationProviderClient.removeLocationUpdates(listener)
+        }
+    }
+
+    override fun removeLocationUpdates(pendingIntent: PendingIntent?) {
+        if (pendingIntent != null) {
+            fusedLocationProviderClient.removeLocationUpdates(pendingIntent)
+        }
+    }
+
+    private class GoogleLocationEngineCallbackTransport(
+        private val callback: LocationEngineCallback<LocationEngineResult?>,
+    ) : LocationCallback() {
+        override fun onLocationResult(locationResult: LocationResult) {
+            super.onLocationResult(locationResult)
+            val locations = locationResult.locations
+            if (!locations.isEmpty()) {
+                callback.onSuccess(LocationEngineResult.create(locations))
+            } else {
+                callback.onFailure(Exception("Unavailable location"))
+            }
+        }
+    }
+
+    @VisibleForTesting
+    internal class GoogleLastLocationEngineCallbackTransport(
+        private val callback: LocationEngineCallback<LocationEngineResult?>,
+    ) : OnSuccessListener<Location?>,
+        OnFailureListener {
+        override fun onSuccess(location: Location?) {
+            callback.onSuccess(
+                if (location != null) {
+                    LocationEngineResult.create(location)
+                } else {
+                    LocationEngineResult.create(
+                        mutableListOf<Location?>(),
+                    )
+                },
+            )
+        }
+
+        override fun onFailure(e: Exception) {
+            callback.onFailure(e)
+        }
+    }
+
+    companion object {
+        private fun toGMSLocationRequest(request: LocationEngineRequest): LocationRequest {
+            val builder = LocationRequest.Builder(request.interval)
+            builder.setMinUpdateIntervalMillis(request.fastestInterval)
+            builder.setMinUpdateDistanceMeters(request.displacement)
+            builder.setMaxUpdateDelayMillis(request.maxWaitTime)
+            builder.setPriority(toGMSLocationPriority(request.priority))
+            return builder.build()
+        }
+
+        private fun toGMSLocationPriority(enginePriority: Int): Int =
+            when (enginePriority) {
+                LocationEngineRequest.PRIORITY_HIGH_ACCURACY -> Priority.PRIORITY_HIGH_ACCURACY
+                LocationEngineRequest.PRIORITY_BALANCED_POWER_ACCURACY -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+                LocationEngineRequest.PRIORITY_LOW_POWER -> Priority.PRIORITY_LOW_POWER
+                LocationEngineRequest.PRIORITY_NO_POWER -> Priority.PRIORITY_PASSIVE
+                else -> Priority.PRIORITY_PASSIVE
+            }
+    }
+}

package/android/src/main/location-engine-google/io/github/mapvina/reactnative/location/engine/GoogleLocationEngineProvider.kt

@@ -0,0 +1,29 @@
+package io.github.mapvina.reactnative.location.engine
+
+import android.content.Context
+import android.util.Log
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.location.LocationCallback
+import io.github.mapvina.android.location.engine.LocationEngine
+import io.github.mapvina.android.location.engine.LocationEngineProxy
+
+class GoogleLocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        if (GoogleApiAvailability
+                .getInstance()
+                .isGooglePlayServicesAvailable(context) == ConnectionResult.SUCCESS
+        ) {
+            val locationEngine: LocationEngine =
+                LocationEngineProxy<LocationCallback?>(GoogleLocationEngineImpl(context.applicationContext))
+            Log.d(LOG_TAG, "GoogleLocationEngine will be used.")
+            return locationEngine
+        } else {
+            return DefaultLocationEngineProvider().getLocationEngine(context)
+        }
+    }
+
+    companion object {
+        private const val LOG_TAG = "GoogleLocationEngineProvider"
+    }
+}

package/android/src/main/location-engine-google/io/github/mapvina/reactnative/location/engine/LocationEngineProvider.kt

@@ -0,0 +1,8 @@
+package io.github.mapvina.reactnative.location.engine
+
+import android.content.Context
+import io.github.mapvina.android.location.engine.LocationEngine
+
+class LocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine = GoogleLocationEngineProvider().getLocationEngine(context)
+}

package/android/src/main/res/drawable/empty.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+  <size android:height="1dp" android:width="1dp" />
+  <solid android:color="@android:color/transparent" />
+</shape>

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./lib/commonjs/plugin/withMapVina");

package/ios/components/ViewManager.h

@@ -0,0 +1,8 @@
+#import <React/RCTViewManager.h>
+#import "MLRNEvent.h"
+
+@interface ViewManager : RCTViewManager
+
+- (void)fireEvent:(MLRNEvent*)event withCallback:(RCTBubblingEventBlock)callback;
+
+@end

package/ios/components/ViewManager.m

@@ -0,0 +1,49 @@
+#import "ViewManager.h"
+
+@implementation ViewManager {
+  NSMutableDictionary<NSString *, NSNumber *> *eventTimestampCache;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
++ (NSString *)moduleName {
+  // Hack, to prevent JS from throwing a useless warning
+  return @"RCTViewManager";
+}
+
+static NSTimeInterval EVENT_THROTTLE_S = 0.01;
+
+- (instancetype)init {
+  if (self = [super init]) {
+    eventTimestampCache = [[NSMutableDictionary alloc] init];
+  }
+
+  return self;
+}
+
+- (void)fireEvent:(MLRNEvent *)event withCallback:(RCTBubblingEventBlock)callback {
+  if (![self _shouldDropEvent:event]) {
+    NSString *cacheKey = [self _getCacheKey:event];
+    NSTimeInterval now = [[NSDate date] timeIntervalSince1970];
+    [eventTimestampCache setObject:[NSNumber numberWithDouble:now] forKey:cacheKey];
+
+    if (callback != nil) {
+      callback([event toJSON]);
+    }
+  }
+}
+
+- (BOOL)_shouldDropEvent:(MLRNEvent *)event {
+  NSString *cacheKey = [self _getCacheKey:event];
+  NSNumber *lastTimestamp = [eventTimestampCache objectForKey:cacheKey];
+  return lastTimestamp != nil &&
+         (event.timestamp - [lastTimestamp doubleValue]) <= EVENT_THROTTLE_S;
+}
+
+- (NSString *)_getCacheKey:(MLRNEvent *)event {
+  return event.type;
+}
+
+@end

package/ios/components/annotations/callout/MLRNCallout.h

@@ -0,0 +1,7 @@
+#import <React/RCTView.h>
+
+#import <MapVina/MapVina.h>
+
+@interface MLRNCallout : RCTView <MLNCalloutView>
+
+@end

package/ios/components/annotations/callout/MLRNCallout.m

@@ -0,0 +1,67 @@
+#import "MLRNCallout.h"
+#import <React/UIView+React.h>
+
+@implementation MLRNCallout {
+  id<MLNAnnotation> _representedObject;
+  __unused UIView *_leftAccessoryView;  /* unused */
+  __unused UIView *_rightAccessoryView; /* unused */
+  __weak id<MLNCalloutViewDelegate> _delegate;
+  BOOL _dismissesAutomatically;
+  BOOL _anchoredToAnnotation;
+}
+
+@synthesize representedObject = _representedObject;
+@synthesize leftAccessoryView = _leftAccessoryView;   /* unused */
+@synthesize rightAccessoryView = _rightAccessoryView; /* unused */
+@synthesize delegate = _delegate;
+@synthesize anchoredToAnnotation = _anchoredToAnnotation;
+@synthesize dismissesAutomatically = _dismissesAutomatically;
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // prevent tap from bubbling up to it's superview
+    UITapGestureRecognizer *captureTap = [[UITapGestureRecognizer alloc] initWithTarget:self
+                                                                                 action:nil];
+    [self addGestureRecognizer:captureTap];
+  }
+  return self;
+}
+
+// https://github.com/mapbox/mapbox-gl-native/issues/9228
+- (void)setCenter:(CGPoint)center {
+  center.y = center.y - CGRectGetMidY(self.bounds);
+  [super setCenter:center];
+}
+
+- (void)presentCalloutFromRect:(CGRect)rect
+                        inView:(UIView *)view
+             constrainedToRect:(CGRect)constrainedRect
+                      animated:(BOOL)animated;
+{
+  // we want to attach to our parents parent to be on the same zPosition stack, so the callout will
+  // appear over other custom views
+  [view.superview addSubview:self];
+
+  // adjust frame
+  double centerX = rect.origin.x + (rect.size.width / 2);
+  CGPoint center = CGPointMake(centerX, rect.origin.y);
+  [self setCenter:center];
+}
+
+- (void)dismissCalloutAnimated:(BOOL)animated {
+  [self removeFromSuperview];
+}
+
+- (BOOL)dismissesAutomatically {
+  return NO;
+}
+
+- (BOOL)isAnchoredToAnnotation {
+  return YES;
+}
+
+- (void)update {
+  [self setCenter:self.center];
+}
+
+@end

package/ios/components/annotations/callout/MLRNCalloutComponentView.h

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

package/ios/components/annotations/callout/MLRNCalloutComponentView.mm

@@ -0,0 +1,85 @@
+#import "MLRNCalloutComponentView.h"
+
+#import <react/renderer/components/MapVinaReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/Props.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <React/RCTConversions.h>
+#import "MLRNCallout.h"
+
+using namespace facebook::react;
+
+// MARK: - MLRNCalloutComponentView
+
+@interface MLRNCalloutComponentView () <RCTMLRNCalloutViewProtocol>
+
+@end
+
+@implementation MLRNCalloutComponentView {
+  MLRNCallout *_view;
+}
+
++ (BOOL)shouldBeRecycled {
+  return NO;
+}
+
+- (UIView *)contentView {
+  // Return _view so PointAnnotation's mountChildComponentView can detect this as a Callout
+  // via: [contentView isKindOfClass:[MLRNCallout class]]
+  return _view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNCalloutProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNCallout alloc] init];
+}
+
+#pragma mark - Child Mounting
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  // Add children to _view (the MLRNCallout) so they're visible when presented
+  // This includes the Animated.View with title/content that React renders
+  [_view insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+
+  // Forward layout to _view so the callout has the correct size
+  CGRect frame = CGRectMake(layoutMetrics.frame.origin.x, layoutMetrics.frame.origin.y,
+                            layoutMetrics.frame.size.width, layoutMetrics.frame.size.height);
+  _view.frame = frame;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNCalloutComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> MLRNCalloutCls(void) { return MLRNCalloutComponentView.class; }

package/ios/components/annotations/point-annotation/MLRNPointAnnotation.h

@@ -0,0 +1,45 @@
+#import <React/RCTComponent.h>
+#import <React/RCTView.h>
+#import <UIKit/UIKit.h>
+#import "MLRNCallout.h"
+
+#import <MapVina/MapVina.h>
+
+@interface MLRNPointAnnotation : MLNAnnotationView <MLNAnnotation>
+
+@property (nonatomic, weak) MLNMapView *map;
+@property (nonatomic, strong) MLRNCallout *calloutView;
+
+@property (nonatomic, copy) NSString *id;
+@property (nonatomic, copy) NSString *reactTitle;
+@property (nonatomic, copy) NSString *reactSnippet;
+
+@property (nonatomic, copy) NSArray<NSNumber *> *reactLngLat;
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+
+@property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *anchor;
+@property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *offset;
+
+@property (nonatomic, copy) void (^reactOnPress)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnSelect)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnDeselect)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnDragStart)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnDrag)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnDragEnd)(NSDictionary *event);
+
+@property (nonatomic, assign) BOOL reactSelected;
+@property (nonatomic, assign) BOOL reactDraggable;
+@property (nonatomic, assign) BOOL hasExplicitZIndex;
+@property (nonatomic, assign) CGFloat explicitZIndex;
+
+// For Fabric: track custom child count without adding to view hierarchy
+@property (nonatomic, assign) NSInteger customChildCount;
+
+- (MLNAnnotationView *)getAnnotationView;
+- (NSDictionary *)makeEventPayload;
+- (void)setZIndex:(CGFloat)zIndex;
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex;
+- (void)removeReactSubview:(UIView *)subview;
+
+@end