@maplibre/maplibre-react-native 10.4.0 → 11.0.0-alpha.10

package/MapLibreReactNative.podspec

@@ -0,0 +1,79 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# Global Variable Defaults
+$MLRN_NATIVE_VERSION ||= "6.17.1"
+$MLRN_SPM_SPEC ||= {
+  url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+  requirement: {
+    kind: "exactVersion",
+    version: $MLRN_NATIVE_VERSION
+  },
+  product_name: "MapLibre"
+}
+
+$MLRN = Object.new
+
+def $MLRN._add_spm_to_target(project, target, url, requirement, product_name)
+  pkg_class = Xcodeproj::Project::Object::XCRemoteSwiftPackageReference
+  ref_class = Xcodeproj::Project::Object::XCSwiftPackageProductDependency
+  pkg = project.root_object.package_references.find { |p| p.class == pkg_class && p.repositoryURL == url }
+  if !pkg
+    pkg = project.new(pkg_class)
+    pkg.repositoryURL = url
+    pkg.requirement = requirement
+    project.root_object.package_references << pkg
+  end
+  ref = target.package_product_dependencies.find { |r| r.class == ref_class && r.package == pkg && r.product_name == product_name }
+  if !ref
+    ref = project.new(ref_class)
+    ref.package = pkg
+    ref.product_name = product_name
+    target.package_product_dependencies << ref
+  end
+end
+
+def $MLRN.post_install(installer)
+  spm_spec = $MLRN_SPM_SPEC
+
+  project = installer.pods_project
+  self._add_spm_to_target(
+    project,
+    project.targets.find { |t| t.name == "MapLibreReactNative"},
+    spm_spec[:url],
+    spm_spec[:requirement],
+    spm_spec[:product_name]
+  )
+
+  installer.aggregate_targets.group_by(&:user_project).each do |project, targets|
+    targets.each do |target|
+      target.user_targets.each do |user_target|
+        self._add_spm_to_target(
+          project,
+          user_target,
+          spm_spec[:url],
+          spm_spec[:requirement],
+          spm_spec[:product_name]
+        )
+      end
+    end
+  end
+end
+
+Pod::Spec.new do |s|
+  s.name         = "MapLibreReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/maplibre/maplibre-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+  s.public_header_files = "ios/MLRNCustomHeaders.h"
+
+ install_modules_dependencies(s)
+end

package/README.md

@@ -18,11 +18,9 @@ _React Native library for creating maps
 with [MapLibre Native for Android & iOS](https://github.com/maplibre/maplibre-gl-native)._
 
 > [!IMPORTANT]
-> Support for the new architecture with v10 is only through the interoperability layer. There are still quite a few
-> [issues](https://github.com/maplibre/maplibre-react-native/issues?q=is%3Aissue%20state%3Aopen%20type%3ABug%20label%3A%22Architecture%3A%20New%22),
-> when used with the new architecture. Switch to the v11 alpha releases on the
-> [`alpha`](https://github.com/maplibre/maplibre-react-native/tree/alpha) branch for better support of the new
-> architecture.
+> This is the v11 alpha branch, which **only supports the new architecture**. Not all components and modules have been ported yet.
+> 
+> Please refer to the [v11 migration guide](https://github.com/maplibre/maplibre-react-native/blob/alpha/docs/content/setup/migrations/v11.md) for upgrading.
 
 This project originated as a fork of [rnmapbox](https://github.com/rnmapbox/maps), a community-maintained
 React Native library for building maps with the Mapbox iOS and Android mobile SDKs. The original library

package/android/build.gradle

@@ -1,145 +1,121 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["org.maplibre.reactnative.kotlinVersion"]
-
-  repositories {
-    google()
-    mavenCentral()
-  }
+    ext.getExtOrDefault = { name ->
+        return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['org.maplibre.reactnative.' + name]
+    }
 
-  dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
-    // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
+    repositories {
+        google()
+        mavenCentral()
+    }
 
-def reactNativeArchitectures() {
-  def value = rootProject.getProperties().get("reactNativeArchitectures")
-  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+    dependencies {
+        classpath "com.android.tools.build:gradle:8.7.2"
+        // noinspection DifferentKotlinGradleVersion
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-// TODO: Currently breaks new arch support, but works without
-// if (isNewArchitectureEnabled()) {
-//   apply plugin: "com.facebook.react"
-// }
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["org.maplibre.reactnative." + name]
-}
-
-def getConfigurableExtOrDefault(name) {
-  return rootProject.ext.has("org.maplibre.reactnative." + name) ? rootProject.ext.get("org.maplibre.reactnative." + name) : project.properties["org.maplibre.reactnative." + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["org.maplibre.reactnative." + name]).toInteger()
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["org.maplibre.reactnative." + name]).toInteger()
 }
 
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
+def getConfigurableExtOrDefault(name) {
+    return rootProject.ext.has("org.maplibre.reactnative." + name) ? rootProject.ext.get("org.maplibre.reactnative." + name) : project.properties["org.maplibre.reactnative." + name]
 }
 
 android {
-  if (supportsNamespace()) {
     namespace "org.maplibre.reactnative"
 
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
-
-  defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-  }
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+        targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    }
 
-  sourceSets {
-    main {
-      java.srcDirs = ['src/main/java']
+    buildFeatures {
+        buildConfig true
+    }
 
-      if (getConfigurableExtOrDefault("locationEngine") == "default") {
-        java.srcDirs += 'src/main/location-engine-default'
-      } else if (getConfigurableExtOrDefault("locationEngine") == "google") {
-        java.srcDirs += 'src/main/location-engine-google'
-      } else {
-        throw new GradleException("org.maplibre.reactnative.locationEngine.locationEngine should be one of [\"default\", \"google\"]`. \"${getConfigurableExtOrDefault("locationEngine")}\" was provided.")
-      }
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
     }
-  }
 
-  buildTypes {
-    release {
-      minifyEnabled false
+    lintOptions {
+        disable "GradleCompatible"
     }
-  }
 
-  lintOptions {
-    disable "GradleCompatible"
-  }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
 
-  compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
-  }
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+
+            if (getConfigurableExtOrDefault("locationEngine") == "default") {
+                java.srcDirs += 'src/main/location-engine-default'
+            } else if (getConfigurableExtOrDefault("locationEngine") == "google") {
+                java.srcDirs += 'src/main/location-engine-google'
+            } else {
+                throw new GradleException("org.maplibre.reactnative.locationEngine.locationEngine should be one of [\"default\", \"google\"]`. \"${getConfigurableExtOrDefault("locationEngine")}\" was provided.")
+            }
+
+            java.srcDirs += [
+                    "generated/java",
+                    "generated/jni"
+            ]
+        }
+    }
 }
 
 repositories {
-  mavenCentral()
-  google()
+    mavenCentral()
+    google()
 }
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-  // MapLibre Native
-  implementation "org.maplibre.gl:android-sdk-${getConfigurableExtOrDefault('nativeVariant')}:${getConfigurableExtOrDefault('nativeVersion')}"
-
-  // MapLibre Plugins
-  implementation("org.maplibre.gl:android-plugin-localization-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
-    exclude(group: "org.maplibre.gl", module: "android-sdk")
-  }
-  implementation("org.maplibre.gl:android-plugin-annotation-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
-    exclude(group: "org.maplibre.gl", module: "android-sdk")
-  }
-  implementation("org.maplibre.gl:android-plugin-markerview-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
-    exclude(group: "org.maplibre.gl", module: "android-sdk")
-  }
-
-  // Dependencies
-  implementation "org.maplibre.gl:android-sdk-turf:${getConfigurableExtOrDefault('turfVersion')}"
-  implementation "com.squareup.okhttp3:okhttp:${getConfigurableExtOrDefault('okhttpVersion')}"
-  implementation "com.squareup.okhttp3:okhttp-urlconnection:${getConfigurableExtOrDefault('okhttpVersion')}"
-  implementation "androidx.vectordrawable:vectordrawable:1.1.0"
-  implementation "androidx.annotation:annotation:1.7.0"
-  implementation "androidx.appcompat:appcompat:1.6.1"
-
-  // Dependencies for Google Location Engine
-  if (getConfigurableExtOrDefault("locationEngine") == "google") {
-    implementation "com.google.android.gms:play-services-location:${getConfigurableExtOrDefault('googlePlayServicesLocationVersion')}"
-  }
+    implementation "com.facebook.react:react-android"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    // MapLibre Native
+    implementation "org.maplibre.gl:android-sdk-${getConfigurableExtOrDefault('nativeVariant')}:${getConfigurableExtOrDefault('nativeVersion')}"
+
+    // MapLibre Plugins
+    implementation("org.maplibre.gl:android-plugin-annotation-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
+        exclude(group: "org.maplibre.gl", module: "android-sdk")
+    }
+    implementation("org.maplibre.gl:android-plugin-markerview-v9:${getConfigurableExtOrDefault('pluginVersion')}") {
+        exclude(group: "org.maplibre.gl", module: "android-sdk")
+    }
+
+    // Dependencies
+    implementation "org.maplibre.gl:android-sdk-turf:${getConfigurableExtOrDefault('turfVersion')}"
+    implementation "com.squareup.okhttp3:okhttp:${getConfigurableExtOrDefault('okhttpVersion')}"
+    implementation "com.squareup.okhttp3:okhttp-urlconnection:${getConfigurableExtOrDefault('okhttpVersion')}"
+    implementation "androidx.vectordrawable:vectordrawable:1.2.0"
+    implementation "androidx.annotation:annotation:1.9.1"
+    implementation "androidx.appcompat:appcompat:1.7.1"
+
+    // Dependencies for Google Location Engine
+    if (getConfigurableExtOrDefault("locationEngine") == "google") {
+        implementation "com.google.android.gms:play-services-location:${getConfigurableExtOrDefault('googlePlayServicesLocationVersion')}"
+    }
+}
+
+react {
+    jsRootDir = file("../src/")
+    libraryName = "MapLibreReactNative"
+    codegenJavaPackageName = "org.maplibre.reactnative"
 }

package/android/gradle.properties

@@ -1,15 +1,15 @@
-org.maplibre.reactnative.kotlinVersion=1.7.0
-org.maplibre.reactnative.minSdkVersion=21
-org.maplibre.reactnative.targetSdkVersion=31
-org.maplibre.reactnative.compileSdkVersion=31
-org.maplibre.reactnative.ndkVersion=21.4.7075529
+org.maplibre.reactnative.kotlinVersion=2.0.21
+org.maplibre.reactnative.minSdkVersion=24
+org.maplibre.reactnative.targetSdkVersion=34
+org.maplibre.reactnative.compileSdkVersion=35
+org.maplibre.reactnative.ndkVersion=27.1.12297006
 
 # MapLibre React Native
 org.maplibre.reactnative.nativeVersion=11.12.1
 org.maplibre.reactnative.nativeVariant=opengl
 org.maplibre.reactnative.pluginVersion=3.0.2
 org.maplibre.reactnative.turfVersion=6.0.1
-org.maplibre.reactnative.okhttpVersion=4.9.0
+org.maplibre.reactnative.okhttpVersion=4.12.0
 # Available values: default, google
 org.maplibre.reactnative.locationEngine=default
 # Only applied if locationEngine=google

package/android/src/main/AndroidManifest.xml

@@ -1,6 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="org.maplibre.reactnative">
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 </manifest>

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

@@ -0,0 +1,183 @@
+package org.maplibre.reactnative
+
+import com.facebook.react.BaseReactPackage
+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 org.maplibre.reactnative.components.annotations.MLRNCalloutManager
+import org.maplibre.reactnative.components.annotations.MLRNMarkerViewManager
+import org.maplibre.reactnative.components.annotations.MLRNPointAnnotationManager
+import org.maplibre.reactnative.components.camera.MLRNCameraManager
+import org.maplibre.reactnative.components.camera.MLRNCameraModule
+import org.maplibre.reactnative.components.images.MLRNImagesManager
+import org.maplibre.reactnative.components.location.MLRNNativeUserLocationManager
+import org.maplibre.reactnative.components.mapview.MLRNAndroidTextureMapViewManager
+import org.maplibre.reactnative.components.mapview.MLRNMapViewManager
+import org.maplibre.reactnative.components.mapview.MLRNMapViewModule
+import org.maplibre.reactnative.components.layers.MLRNBackgroundLayerManager
+import org.maplibre.reactnative.components.layers.MLRNCircleLayerManager
+import org.maplibre.reactnative.components.layers.MLRNFillExtrusionLayerManager
+import org.maplibre.reactnative.components.layers.MLRNFillLayerManager
+import org.maplibre.reactnative.components.layers.MLRNHeatmapLayerManager
+import org.maplibre.reactnative.components.layers.MLRNLineLayerManager
+import org.maplibre.reactnative.components.layers.MLRNRasterLayerManager
+import org.maplibre.reactnative.components.layers.MLRNSymbolLayerManager
+import org.maplibre.reactnative.components.light.MLRNLightManager
+import org.maplibre.reactnative.components.sources.MLRNImageSourceManager
+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.MLRNModule
+import org.maplibre.reactnative.modules.MLRNOfflineModule
+import org.maplibre.reactnative.modules.MLRNSnapshotModule
+import org.maplibre.reactnative.utils.ReactTagResolver
+
+
+class MLRNPackage : BaseReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext
+    ): NativeModule? {
+        when (name) {
+            MLRNModule.REACT_CLASS -> return MLRNModule(reactContext)
+            MLRNMapViewModule.NAME -> return MLRNMapViewModule(
+                reactContext,
+                getReactTagResolver(reactContext)
+            )
+            MLRNCameraModule.NAME -> return MLRNCameraModule(
+                reactContext,
+                getReactTagResolver(reactContext)
+            )
+
+
+            MLRNOfflineModule.REACT_CLASS -> return MLRNOfflineModule(reactContext)
+            MLRNSnapshotModule.NAME -> return MLRNSnapshotModule(reactContext)
+            MLRNLocationModule.REACT_CLASS -> return MLRNLocationModule(reactContext)
+            MLRNLogging.REACT_CLASS -> return MLRNLogging(reactContext)
+        }
+
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+
+            moduleInfos[MLRNModule.REACT_CLASS] = ReactModuleInfo(
+                MLRNModule.REACT_CLASS,
+                MLRNModule.REACT_CLASS,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
+            )
+
+            moduleInfos[MLRNMapViewModule.NAME] = ReactModuleInfo(
+                MLRNMapViewModule.NAME,
+                MLRNMapViewModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
+            moduleInfos[MLRNCameraModule.NAME] = ReactModuleInfo(
+                MLRNCameraModule.NAME,
+                MLRNCameraModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
+            moduleInfos[MLRNOfflineModule.REACT_CLASS] = ReactModuleInfo(
+                MLRNOfflineModule.REACT_CLASS,
+                MLRNOfflineModule.REACT_CLASS,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
+            )
+
+            moduleInfos[MLRNSnapshotModule.NAME] = ReactModuleInfo(
+                MLRNSnapshotModule.NAME,
+                MLRNSnapshotModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+
+            moduleInfos[MLRNLocationModule.REACT_CLASS] = ReactModuleInfo(
+                MLRNLocationModule.REACT_CLASS,
+                MLRNLocationModule.REACT_CLASS,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
+            )
+
+            moduleInfos[MLRNLogging.REACT_CLASS] = ReactModuleInfo(
+                MLRNLogging.REACT_CLASS,
+                MLRNLogging.REACT_CLASS,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
+            )
+
+            moduleInfos
+        }
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        val managers: MutableList<ViewManager<*, *>> = ArrayList()
+
+        // components
+        managers.add(MLRNCameraManager(reactContext))
+        managers.add(MLRNMapViewManager(reactContext))
+        managers.add(MLRNMarkerViewManager(reactContext))
+        managers.add(MLRNAndroidTextureMapViewManager(reactContext))
+        managers.add(MLRNLightManager())
+        managers.add(MLRNPointAnnotationManager(reactContext))
+        managers.add(MLRNCalloutManager())
+        managers.add(MLRNNativeUserLocationManager())
+
+        // sources
+        managers.add(MLRNVectorSourceManager(reactContext))
+        managers.add(MLRNShapeSourceManager(reactContext))
+        managers.add(MLRNRasterSourceManager(reactContext))
+        managers.add(MLRNImageSourceManager())
+
+        // images
+        managers.add(MLRNImagesManager(reactContext))
+
+        // layers
+        managers.add(MLRNFillLayerManager())
+        managers.add(MLRNFillExtrusionLayerManager())
+        managers.add(MLRNHeatmapLayerManager())
+        managers.add(MLRNLineLayerManager())
+        managers.add(MLRNCircleLayerManager())
+        managers.add(MLRNSymbolLayerManager())
+        managers.add(MLRNRasterLayerManager())
+        managers.add(MLRNBackgroundLayerManager())
+
+        return managers
+    }
+
+    private var reactTagResolver: ReactTagResolver? = null
+
+    private fun getReactTagResolver(context: ReactApplicationContext): ReactTagResolver {
+        val reactTagResolver = reactTagResolver
+        if (reactTagResolver == null) {
+            val result = ReactTagResolver(context)
+            this.reactTagResolver = result
+            return result
+        }
+        return reactTagResolver
+    }
+}

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

@@ -0,0 +1,24 @@
+package org.maplibre.reactnative.components
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class AbstractEvent(
+    viewId: Int,
+    private val mEventName: String,
+    private val mCanCoalesce: Boolean,
+    private val mEvent: WritableMap?
+) : Event<AbstractEvent>(viewId) {
+    override fun getEventName(): String {
+        return mEventName
+    }
+
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+        rctEventEmitter.receiveEvent(viewTag, eventName, mEvent)
+    }
+
+    override fun canCoalesce(): Boolean {
+        return mCanCoalesce
+    }
+}

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

@@ -0,0 +1,71 @@
+package org.maplibre.reactnative.components
+
+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.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.events.EventDispatcher
+import org.maplibre.reactnative.events.IEvent
+
+abstract class AbstractEventEmitter<T : ViewGroup>(private val reactContext: ReactApplicationContext) :
+    ViewGroupManager<T>() {
+    private val mRateLimitedEvents: MutableMap<String?, Long?> = HashMap()
+    private var mEventDispatcher: EventDispatcher? = null
+
+    fun handleEvent(event: IEvent) {
+        val eventCacheKey = getEventCacheKey(event)
+
+        // fail safe to protect bridge from being spammed
+        if (shouldDropEvent(eventCacheKey, event)) {
+            return
+        }
+
+        mRateLimitedEvents.put(eventCacheKey, System.currentTimeMillis())
+        mEventDispatcher!!.dispatchEvent(
+            AbstractEvent(
+                event.getID(), event.getKey(), event.canCoalesce(), event.toJSON()
+            )
+        )
+    }
+
+    override fun addEventEmitters(context: ThemedReactContext, view: T) {
+        mEventDispatcher =
+            UIManagerHelper.getUIManager(context, UIManagerType.Companion.FABRIC)!!.eventDispatcher
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String?, Any?>? {
+        val events = customEvents()
+
+        if (events == null) {
+            return null
+        }
+
+        val exportedEvents: MutableMap<String?, Any?> = HashMap<String?, Any?>()
+
+        for (event in events.entries) {
+            exportedEvents.put(
+                event.key, MapBuilder.of<String?, String?>("registrationName", event.value!!)
+            )
+        }
+
+        return exportedEvents
+    }
+
+    abstract fun customEvents(): Map<String, String>?
+
+    private fun shouldDropEvent(cacheKey: String?, event: IEvent): Boolean {
+        val lastEventTimestamp = mRateLimitedEvents.get(cacheKey)
+        return lastEventTimestamp != null && (event.getTimestamp() - lastEventTimestamp) <= BRIDGE_TIMEOUT_MS
+    }
+
+    private fun getEventCacheKey(event: IEvent): String {
+        return String.format("%s-%s", event.getKey(), event.getType())
+    }
+
+    companion object {
+        private const val BRIDGE_TIMEOUT_MS = 10.0
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/annotations/MLRNCallout.java

@@ -0,0 +1,11 @@
+package org.maplibre.reactnative.components.annotations;
+
+import android.content.Context;
+
+import com.facebook.react.views.view.ReactViewGroup;
+
+public class MLRNCallout extends ReactViewGroup {
+    public MLRNCallout(Context context) {
+        super(context);
+    }
+}