@rnmapbox/maps 10.0.15-rc.1 → 10.1.0-beta.2

package/android/build.gradle

@@ -5,6 +5,14 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
+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"
+}
+
 // expo plugin
 if (rootProject.ext.has('expoRNMapboxMapsImpl')) {
     rootProject.ext.set('RNMapboxMapsImpl', rootProject.ext.get('expoRNMapboxMapsImpl'))
@@ -25,6 +33,9 @@ buildscript {
   }
 }
 
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
 apply plugin: 'com.android.library'
 
 if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
@@ -68,6 +79,14 @@ android {
         throw new GradleException(msg)
     }
 
+    if (!isNewArchitectureEnabled()) {
+        sourceSets {
+            main {
+                java.srcDirs += 'src/main/old-arch'
+            }
+        }
+    }
+
     compileSdkVersion safeExtGet("compileSdkVersion", 28)
     buildToolsVersion safeExtGet("buildToolsVersion", '28.0.3')
 
@@ -76,6 +95,7 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', 26)
         versionCode 1
         versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     }
 
     compileOptions {

package/android/src/main/java-v10/com/mapbox/rctmgl/RCTMGLPackage.java

@@ -1,14 +1,21 @@
 package com.mapbox.rctmgl;
 
+import androidx.annotation.Nullable;
+
 import com.facebook.react.ReactPackage;
+import com.facebook.react.TurboReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.uimanager.ViewManager;
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager;
 
@@ -18,6 +25,7 @@ import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerViewManager;
 import com.mapbox.rctmgl.components.images.RCTMGLImageManager;
 import com.mapbox.rctmgl.components.images.RCTMGLImagesManager;
 import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocationManager;
+import com.mapbox.rctmgl.components.mapview.NativeMapViewModule;
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapViewManager;
 import com.mapbox.rctmgl.components.mapview.RCTMGLAndroidTextureMapViewManager;
 import com.mapbox.rctmgl.components.styles.atmosphere.RCTMGLAtmosphereManager;
@@ -49,20 +57,27 @@ import com.mapbox.rctmgl.modules.RCTMGLLocationModule;
 import com.mapbox.rctmgl.modules.RCTMGLModule;
 
 
-public class RCTMGLPackage implements ReactPackage {
+public class RCTMGLPackage extends TurboReactPackage {
 
+    @Nullable
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
-        List<NativeModule> modules = new ArrayList<>();
-        modules.add(new RCTMGLModule(reactApplicationContext));
-        modules.add(new RCTMGLLocationModule(reactApplicationContext));
-
-        modules.add(new RCTMGLOfflineModule(reactApplicationContext));
-        modules.add(new RCTMGLSnapshotModule(reactApplicationContext));
-
-        modules.add(new RCTMGLLogging(reactApplicationContext));
-
-        return modules;
+    public NativeModule getModule(String s, ReactApplicationContext reactApplicationContext) {
+        switch (s) {
+            case RCTMGLModule.REACT_CLASS:
+                return new RCTMGLModule(reactApplicationContext);
+            case RCTMGLLocationModule.REACT_CLASS:
+                return new RCTMGLLocationModule(reactApplicationContext);
+            case RCTMGLOfflineModule.REACT_CLASS:
+                return new RCTMGLOfflineModule(reactApplicationContext);
+            case RCTMGLSnapshotModule.REACT_CLASS:
+                return new RCTMGLSnapshotModule(reactApplicationContext);
+            case RCTMGLLogging.REACT_CLASS:
+                return new RCTMGLLogging(reactApplicationContext);
+            case NativeMapViewModule.NAME:
+                return new NativeMapViewModule(reactApplicationContext);
+        }
+
+        return null;
     }
 
     @Deprecated
@@ -115,4 +130,86 @@ public class RCTMGLPackage implements ReactPackage {
 
         return managers;
     }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+            boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+
+            moduleInfos.put(
+                    RCTMGLModule.REACT_CLASS,
+                    new ReactModuleInfo(
+                            RCTMGLModule.REACT_CLASS,
+                            RCTMGLModule.REACT_CLASS,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            false // isTurboModule
+                    ));
+
+            moduleInfos.put(
+                    RCTMGLLocationModule.REACT_CLASS,
+                    new ReactModuleInfo(
+                            RCTMGLLocationModule.REACT_CLASS,
+                            RCTMGLLocationModule.REACT_CLASS,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            false // isTurboModule
+                    ));
+
+            moduleInfos.put(
+                    RCTMGLOfflineModule.REACT_CLASS,
+                    new ReactModuleInfo(
+                            RCTMGLOfflineModule.REACT_CLASS,
+                            RCTMGLOfflineModule.REACT_CLASS,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            false // isTurboModule
+                    ));
+
+            moduleInfos.put(
+                    RCTMGLSnapshotModule.REACT_CLASS,
+                    new ReactModuleInfo(
+                            RCTMGLSnapshotModule.REACT_CLASS,
+                            RCTMGLSnapshotModule.REACT_CLASS,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            false // isTurboModule
+                    ));
+
+            moduleInfos.put(
+                    RCTMGLLogging.REACT_CLASS,
+                    new ReactModuleInfo(
+                            RCTMGLLogging.REACT_CLASS,
+                            RCTMGLLogging.REACT_CLASS,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            false // isTurboModule
+                    ));
+
+            moduleInfos.put(
+                    NativeMapViewModule.NAME,
+                    new ReactModuleInfo(
+                            NativeMapViewModule.NAME,
+                            NativeMapViewModule.NAME,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            false, // hasConstants
+                            false, // isCxxModule
+                            isTurboModule // isTurboModule
+                    ));
+
+            return moduleInfos;
+        };
+    }
 }

package/android/src/main/java-v10/com/mapbox/rctmgl/components/AbstractEventEmitter.kt

@@ -5,11 +5,10 @@ import android.view.ViewGroup
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.mapbox.rctmgl.events.IEvent
-import javax.annotation.Nonnull
 
 /**
  * Created by nickitaliano on 8/23/17.
@@ -47,7 +46,7 @@ abstract class AbstractEventEmitter<T : ViewGroup?>(reactApplicationContext: Rea
     }
 
     override fun addEventEmitters(context: ThemedReactContext, view: T) {
-        mEventDispatcher = context.getNativeModule(UIManagerModule::class.java)!!.eventDispatcher
+        mEventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view!!.id)
     }
 
     override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {

package/android/src/main/java-v10/com/mapbox/rctmgl/components/mapview/NativeMapViewModule.kt

@@ -0,0 +1,193 @@
+package com.mapbox.rctmgl.components.mapview
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.mapbox.rctmgl.BuildConfig
+import com.mapbox.rctmgl.NativeMapViewModuleSpec
+import com.mapbox.rctmgl.utils.ConvertUtils
+import com.mapbox.rctmgl.utils.ExpressionParser
+import com.mapbox.rctmgl.utils.extensions.toCoordinate
+import com.mapbox.rctmgl.utils.extensions.toScreenCoordinate
+
+class NativeMapViewModule(context: ReactApplicationContext) : NativeMapViewModuleSpec(context) {
+    private fun withMapViewOnUIThread(viewRef: Double?, promise: Promise, fn: (RCTMGLMapView) -> Unit) {
+        if (viewRef == null) {
+            return
+        }
+
+        reactApplicationContext.runOnUiQueueThread {
+            val manager = if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED)
+                UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.FABRIC)
+            else
+                UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.DEFAULT)
+
+            val view = manager?.resolveView(viewRef.toInt()) as? RCTMGLMapView
+
+            if (view != null) {
+                fn(view)
+            } else {
+                promise.reject(Exception("cannot find map view for tag ${viewRef.toInt()}"))
+            }
+        }
+    }
+
+    private fun createCommandResponse(promise: Promise): CommandResponse = object : CommandResponse {
+        override fun success(builder: (WritableMap) -> Unit) {
+            val payload: WritableMap = WritableNativeMap()
+            builder(payload)
+
+            promise.resolve(payload)
+        }
+
+        override fun error(message: String) {
+            promise.reject(Exception(message))
+        }
+    }
+
+    override fun takeSnap(viewRef: Double?, writeToDisk: Boolean, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.takeSnap(writeToDisk, createCommandResponse(promise))
+        }
+    }
+
+    override fun queryTerrainElevation(
+        viewRef: Double?,
+        coordinates: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.queryTerrainElevation(coordinates.getDouble(0), coordinates.getDouble(1), createCommandResponse(promise))
+        }
+    }
+
+    override fun setSourceVisibility(
+        viewRef: Double?,
+        visible: Boolean,
+        sourceId: String,
+        sourceLayerId: String?,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.setSourceVisibility(visible, sourceId, sourceLayerId)
+
+            promise.resolve(null)
+        }
+    }
+
+    override fun getCenter(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getCenter(createCommandResponse(promise))
+        }
+    }
+
+    override fun getCoordinateFromView(
+        viewRef: Double?,
+        atPoint: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getCoordinateFromView(atPoint.toScreenCoordinate(), createCommandResponse(promise))
+        }
+    }
+
+    override fun getPointInView(viewRef: Double?, atCoordinate: ReadableArray, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getPointInView(atCoordinate.toCoordinate(), createCommandResponse(promise))
+        }
+    }
+
+    override fun getZoom(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getZoom(createCommandResponse(promise))
+        }
+    }
+
+    override fun getVisibleBounds(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.getVisibleBounds(createCommandResponse(promise))
+        }
+    }
+
+    override fun queryRenderedFeaturesAtPoint(
+        viewRef: Double?,
+        atPoint: ReadableArray,
+        withFilter: ReadableArray,
+        withLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val layerIds = ConvertUtils.toStringList(withLayerIDs)
+
+            it.queryRenderedFeaturesAtPoint(
+                ConvertUtils.toPointF(atPoint),
+                ExpressionParser.from(withFilter),
+                if (layerIds.size == 0) null else layerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    override fun queryRenderedFeaturesInRect(
+        viewRef: Double?,
+        withBBox: ReadableArray,
+        withFilter: ReadableArray,
+        withLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val layerIds = ConvertUtils.toStringList(withLayerIDs)
+
+            it.queryRenderedFeaturesInRect(
+                ConvertUtils.toRectF(withBBox),
+                ExpressionParser.from(withFilter),
+                if (layerIds.size == 0) null else layerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    override fun setHandledMapChangedEvents(
+        viewRef: Double?,
+        events: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.setHandledMapChangedEvents(events.asArrayString())
+            promise.resolve(null)
+        }
+    }
+
+    override fun clearData(viewRef: Double?, promise: Promise) {
+        withMapViewOnUIThread(viewRef, promise) {
+            it.clearData(createCommandResponse(promise))
+        }
+    }
+
+    override fun querySourceFeatures(
+        viewRef: Double?,
+        sourceId: String,
+        withFilter: ReadableArray,
+        withSourceLayerIDs: ReadableArray,
+        promise: Promise
+    ) {
+        withMapViewOnUIThread(viewRef, promise) {
+            val sourceLayerIds = ConvertUtils.toStringList(withSourceLayerIDs)
+
+            it.querySourceFeatures(
+                sourceId,
+                ExpressionParser.from(withFilter),
+                if (sourceLayerIds.size == 0) null else sourceLayerIds,
+                createCommandResponse(promise)
+            )
+        }
+    }
+
+    companion object {
+        const val NAME = "MBXMapViewModule"
+    }
+}

package/android/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLAndroidTextureMapViewManager.kt

@@ -2,11 +2,25 @@ package com.mapbox.rctmgl.components.mapview
 
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.MBXAndroidTextureMapViewManagerDelegate
+import com.facebook.react.viewmanagers.MBXAndroidTextureMapViewManagerInterface
+import com.facebook.react.viewmanagers.MBXMapViewManagerDelegate
 import com.mapbox.maps.MapInitOptions
 
 class RCTMGLAndroidTextureMapViewManager(context: ReactApplicationContext) : RCTMGLMapViewManager(
     context
-) {
+), MBXAndroidTextureMapViewManagerInterface<RCTMGLMapView> {
+    private val mDelegate: ViewManagerDelegate<RCTMGLMapView>
+
+    init {
+        mDelegate = MBXAndroidTextureMapViewManagerDelegate<RCTMGLMapView, RCTMGLAndroidTextureMapViewManager>(this)
+    }
+
+    override fun getDelegate(): ViewManagerDelegate<RCTMGLMapView>? {
+        return mDelegate
+    }
+
     override fun getName(): String {
         return REACT_CLASS
     }
@@ -18,6 +32,6 @@ class RCTMGLAndroidTextureMapViewManager(context: ReactApplicationContext) : RCT
     }
 
     companion object {
-        const val REACT_CLASS = "RCTMGLAndroidTextureMapView"
+        const val REACT_CLASS = "MBXAndroidTextureMapView"
     }
 }

package/android/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -970,7 +970,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 ScreenCoordinate(rect.right.toDouble(), rect.bottom.toDouble() ),
                 ScreenCoordinate(rect.left.toDouble(), rect.top.toDouble()),
         )
-        mMap?.queryRenderedFeatures(
+        mMap.queryRenderedFeatures(
                 RenderedQueryGeometry(screenBox),
                 RenderedQueryOptions(layerIDs, filter)
         ) { features ->