support Vulkan backend for Maps SDK Android

GitOrigin-RevId: cef65f0901a91bacc9b5745136d01d852f935307

Author: alexey-romanov

maps-sdk/src/main/java/com/mapbox/maps/MapController.kt

@@ -300,7 +300,7 @@ internal class MapController : MapPluginProviderDelegate, MapControllable {
 
   @OptIn(MapboxExperimental::class)
   override fun removeWidget(widget: Widget): Boolean {
-    val wasRemoved = renderer.renderThread.removeWidget(widget)
+    val wasRemoved = renderer.renderThread.removeWidget(widget) ?: false
     if (wasRemoved) {
       renderer.scheduleRepaint()
     }

maps-sdk/src/main/java/com/mapbox/maps/MapSurface.kt

@@ -51,10 +51,13 @@ class MapSurface : MapPluginProviderDelegate, MapControllable {
     this.context = context
     this.surface = surface
     this.mapInitOptions = mapInitOptions
+    if (Map.getSupportedRenderBackend() == RenderBackendType.VULKAN) {
+      throw RuntimeException("Vulkan is not supported yet on MapSurface")
+    }
     this.renderer = MapboxSurfaceRenderer(
-      mapInitOptions.antialiasingSampleCount,
-      mapInitOptions.mapOptions.contextMode ?: ContextMode.UNIQUE,
-      mapInitOptions.mapName
+      antialiasingSampleCount = mapInitOptions.antialiasingSampleCount,
+      contextMode = mapInitOptions.mapOptions.contextMode ?: ContextMode.UNIQUE,
+      mapName = mapInitOptions.mapName,
     )
     this.mapController = MapController(renderer, mapInitOptions).apply {
       initializePlugins(mapInitOptions)

maps-sdk/src/main/java/com/mapbox/maps/MapView.kt

@@ -133,14 +133,14 @@ open class MapView : FrameLayout, MapPluginProviderDelegate, MapControllable {
           view.holder,
           resolvedMapInitOptions.antialiasingSampleCount,
           contextMode,
-          resolvedMapInitOptions.mapName
+          resolvedMapInitOptions.mapName,
         )
 
         is TextureView -> MapboxTextureViewRenderer(
           view,
           resolvedMapInitOptions.antialiasingSampleCount,
           contextMode,
-          resolvedMapInitOptions.mapName
+          resolvedMapInitOptions.mapName,
         )
 
         else -> throw IllegalArgumentException("Provided view has to be a texture or a surface.")

maps-sdk/src/main/java/com/mapbox/maps/NativeMapImpl.kt

@@ -76,6 +76,10 @@ internal class NativeMapImpl(val map: Map) {
     map.render()
   }
 
+  fun getVulkanManager(): IVulkanManager {
+    return map.createVulkanManager()
+  }
+
   @OptIn(com.mapbox.annotation.MapboxExperimental::class)
   @MapboxExperimental
   fun resetThreadServiceType() {

maps-sdk/src/main/java/com/mapbox/maps/renderer/GLMapboxRenderThread.kt

@@ -73,6 +73,9 @@ internal class GLMapboxRenderThread : MapboxRenderThread {
     this.eglSurface = eglCore.eglNoSurface
     this.contextMode = ContextMode.UNIQUE
   }
+  init {
+    logI(TAG, "GLMapboxRenderThread created")
+  }
 
   override fun detachSurfaceFromRenderer(creatingSurface: Boolean) {
     // on Android SDK <= 23 at least on x86 emulators we need to force set EGL14.EGL_NO_CONTEXT

maps-sdk/src/main/java/com/mapbox/maps/renderer/MapboxRenderThread.kt

@@ -84,7 +84,7 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
 
   internal val renderHandlerThread: RenderHandlerThread
   protected val mapboxRenderer: MapboxRenderer
-  protected val widgetRenderer: MapboxWidgetRenderer
+  protected val widgetRenderer: MapboxWidgetRenderer?
 
   /**
    * [ReentrantLock] to guarantee consistent behaviour of surface create / destroy events.
@@ -214,7 +214,7 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
 
   constructor(
     mapboxRenderer: MapboxRenderer,
-    widgetRenderer: MapboxWidgetRenderer,
+    widgetRenderer: MapboxWidgetRenderer?,
     mapName: String,
     rendererName: String
   ) {
@@ -232,7 +232,7 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
   @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
   constructor(
     mapboxRenderer: MapboxRenderer,
-    mapboxWidgetRenderer: MapboxWidgetRenderer,
+    mapboxWidgetRenderer: MapboxWidgetRenderer?,
     handlerThread: RenderHandlerThread,
     fpsManager: FpsManager,
     surfaceProcessingLock: ReentrantLock,
@@ -348,7 +348,7 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
   @RenderThread
   private fun notifyRenderersSizeChanged(width: Int, height: Int) {
     mapboxRenderer.onSurfaceChanged(width = width, height = height)
-    widgetRenderer.onSurfaceChanged(width = width, height = height)
+    widgetRenderer?.onSurfaceChanged(width = width, height = height)
   }
 
   private val presentFrameFunc = Choreographer.FrameCallback { presentFrame() }
@@ -362,7 +362,7 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
       return
     }
     preRenderWithSharedContext()
-    if (widgetRenderer.hasWidgets() == true) {
+    if (widgetRenderer?.hasWidgets() == true) {
       renderWithWidgets()
     } else {
       renderWithoutWidgets()
@@ -509,11 +509,11 @@ internal abstract class MapboxRenderThread : Choreographer.FrameCallback {
 
   @OptIn(MapboxExperimental::class)
   fun addWidget(widget: Widget) {
-    widgetRenderer.addWidget(widget)
+    widgetRenderer?.addWidget(widget)
   }
 
   @OptIn(MapboxExperimental::class)
-  fun removeWidget(widget: Widget): Boolean = widgetRenderer.removeWidget(widget)
+  fun removeWidget(widget: Widget): Boolean = widgetRenderer?.removeWidget(widget) == true
 
   @RenderThread
   internal fun processAndroidSurface(surface: Surface, width: Int, height: Int) {

maps-sdk/src/main/java/com/mapbox/maps/renderer/MapboxRenderer.kt

@@ -9,6 +9,8 @@ import androidx.annotation.UiThread
 import androidx.annotation.VisibleForTesting
 import com.mapbox.common.Cancelable
 import com.mapbox.maps.DelegatingMapClient
+import com.mapbox.maps.Map
+import com.mapbox.maps.RenderBackendType
 import com.mapbox.maps.MapView.OnSnapshotReady
 import com.mapbox.maps.MapboxExperimental
 import com.mapbox.maps.NativeMapImpl
@@ -22,7 +24,9 @@ import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
-internal abstract class MapboxRenderer(mapName: String) : DelegatingMapClient {
+internal abstract class MapboxRenderer(
+  mapName: String,
+) : DelegatingMapClient {
 
   internal lateinit var renderThread: MapboxRenderThread
   internal abstract val widgetRenderer: MapboxWidgetRenderer
@@ -103,7 +107,7 @@ internal abstract class MapboxRenderer(mapName: String) : DelegatingMapClient {
     if (width != this.width || height != this.height) {
       this.width = width
       this.height = height
-      GLES20.glViewport(0, 0, width, height)
+      renderThread.resize(width, height)
       map?.setSize(Size(width.toFloat(), height.toFloat()))
     }
   }
@@ -262,5 +266,9 @@ internal abstract class MapboxRenderer(mapName: String) : DelegatingMapClient {
   companion object {
     @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
     internal val repaintRenderEvent = RenderEvent(null, true)
+
+    internal val supportedRenderBackend: RenderBackendType by lazy {
+      Map.getSupportedRenderBackend()
+    }
   }
 }

maps-sdk/src/main/java/com/mapbox/maps/renderer/MapboxSurfaceRenderer.kt

@@ -3,6 +3,7 @@ package com.mapbox.maps.renderer
 import android.view.Surface
 import androidx.annotation.VisibleForTesting
 import com.mapbox.maps.ContextMode
+import com.mapbox.maps.RenderBackendType
 
 internal open class MapboxSurfaceRenderer : MapboxRenderer {
 
@@ -19,14 +20,20 @@ internal open class MapboxSurfaceRenderer : MapboxRenderer {
       antialiasingSampleCount = antialiasingSampleCount,
       mapName = mapName,
     )
-    renderThread = GLMapboxRenderThread(
-      mapboxRenderer = this,
-      mapboxWidgetRenderer = widgetRenderer,
-      translucentSurface = false,
-      antialiasingSampleCount = antialiasingSampleCount,
-      contextMode = contextMode,
-      mapName = mapName,
-    )
+    renderThread = when (supportedRenderBackend) {
+      RenderBackendType.VULKAN -> VulkanMapboxRenderThread(
+        mapboxRenderer = this,
+        mapName = mapName,
+      )
+      RenderBackendType.OPEN_GL -> GLMapboxRenderThread(
+        mapboxRenderer = this,
+        mapboxWidgetRenderer = widgetRenderer,
+        translucentSurface = false,
+        antialiasingSampleCount = antialiasingSampleCount,
+        contextMode = contextMode,
+        mapName = mapName,
+      )
+    }
   }
 
   @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)

maps-sdk/src/main/java/com/mapbox/maps/renderer/MapboxTextureViewRenderer.kt

@@ -6,6 +6,7 @@ import android.view.TextureView
 import androidx.annotation.RestrictTo
 import androidx.annotation.VisibleForTesting
 import com.mapbox.maps.ContextMode
+import com.mapbox.maps.RenderBackendType
 
 @RestrictTo(RestrictTo.Scope.LIBRARY)
 internal class MapboxTextureViewRenderer : MapboxRenderer, TextureView.SurfaceTextureListener {
@@ -23,14 +24,20 @@ internal class MapboxTextureViewRenderer : MapboxRenderer, TextureView.SurfaceTe
       mapName = mapName,
     )
     this.widgetRenderer = widgetRenderer
-    renderThread = GLMapboxRenderThread(
-      mapboxRenderer = this,
-      mapboxWidgetRenderer = widgetRenderer,
-      translucentSurface = true,
-      antialiasingSampleCount = antialiasingSampleCount,
-      contextMode = contextMode,
-      mapName = mapName,
-    )
+    renderThread = when (supportedRenderBackend) {
+      RenderBackendType.VULKAN -> VulkanMapboxRenderThread(
+        mapboxRenderer = this,
+        mapName = mapName,
+      )
+      RenderBackendType.OPEN_GL -> GLMapboxRenderThread(
+        mapboxRenderer = this,
+        mapboxWidgetRenderer = widgetRenderer,
+        translucentSurface = true,
+        antialiasingSampleCount = antialiasingSampleCount,
+        contextMode = contextMode,
+        mapName = mapName,
+      )
+    }
     textureView.let {
       it.isOpaque = false
       it.surfaceTextureListener = this

maps-sdk/src/main/java/com/mapbox/maps/renderer/VulkanMapboxRenderThread.kt

@@ -0,0 +1,121 @@
+package com.mapbox.maps.renderer
+
+import android.view.Surface
+import com.mapbox.maps.IVulkanManager
+import com.mapbox.maps.RenderCallback
+import com.mapbox.maps.logI
+import com.mapbox.maps.logW
+
+/**
+ * Vulkan-based implementation of MapboxRenderThread.
+ */
+internal class VulkanMapboxRenderThread(mapboxRenderer: MapboxRenderer, mapName: String) :
+  MapboxRenderThread(
+    mapboxRenderer = mapboxRenderer,
+    widgetRenderer = null,
+    mapName = mapName,
+    rendererName = "Vulkan"
+  ) {
+
+  private var nativeVulkanManager: IVulkanManager? = null
+  private val surfaceWrapper: SurfaceWrapper = SurfaceWrapper()
+
+  init {
+    logI(TAG, "VulkanMapboxRenderThread created")
+  }
+
+  override fun detachSurfaceFromRenderer(creatingSurface: Boolean) {
+    // no-op for now
+  }
+
+  /**
+   * For Vulkan renderer there's not much to prepare, just get the [IVulkanManager].
+   * Preparations will be done in [attachSurfaceToRenderer].
+   */
+  override fun prepareRenderer(): Boolean {
+    logI(TAG, "prepareRenderer called")
+    // TODO: How to handle vulkan not supported in the device?
+    if (nativeVulkanManager == null) {
+      nativeVulkanManager = mapboxRenderer.map?.getVulkanManager()
+    }
+    val result = nativeVulkanManager != null
+    return result
+  }
+
+  override fun attachSurfaceToRenderer(surface: Surface): Boolean {
+    logI(TAG, "attachSurfaceToRenderer called")
+
+    surfaceWrapper.setSurface(surface)
+    val nativeWindowPtr = surfaceWrapper.aNativeWindow
+
+    if (nativeWindowPtr == 0L) {
+      logW(TAG, "Failed to get native window pointer")
+      return false
+    }
+
+    logI(TAG, "Vulkan pre-init")
+    val result = nativeVulkanManager?.init(nativeWindowPtr) ?: run {
+      // TODO cache surface until nativeVulkanManager is set via setMap
+      false
+    }
+
+    logI(TAG, "Vulkan init result: $result")
+    return result
+  }
+
+  private val renderCallback: RenderCallback = RenderCallback(mapboxRenderer::render)
+
+  override fun renderWithoutWidgets() {
+    nativeVulkanManager?.render(renderCallback)
+  }
+
+  override fun presentFrame() {
+    // no-op as presentFrame is called from native side as part of `render { }`
+  }
+
+  override fun preRenderWithSharedContext() {
+    // no-op for now
+  }
+
+  override fun renderWithWidgets() {
+    TODO("Not yet supported in Vulkan")
+  }
+
+  override fun releaseResources() {
+    logI(TAG, "releaseResources called")
+    isRendererReady = false
+    surfaceWrapper.releaseSurface()
+    nativeVulkanManager?.release()
+  }
+
+  override fun prepareWidgetRender() {
+    // no-op for now
+  }
+
+  override fun releaseRenderSurface() {
+    logI(TAG, "releaseRenderSurface called")
+     nativeVulkanManager?.releaseSurface()
+  }
+
+  override fun clearRendererStateListeners() {
+    // no-op for now
+  }
+
+  override fun addRendererStateListener(listener: RendererSetupErrorListener) {
+    // no-op for now
+  }
+
+  override fun removeRendererStateListener(listener: RendererSetupErrorListener) {
+    // no-op for now
+  }
+
+  override fun resize(width: Int, height: Int) {
+    logI(TAG, "resize to ${width}x${height} called")
+    // TODO cache width/height if NULL
+    nativeVulkanManager?.resize(width, height)
+  }
+
+  override fun flushCommands() {
+    // no-op for now
+  }
+}