Reset stale texture ID in BitmapWidgetRenderer after glDeleteTextures (#10780)

## Summary
Fixes https://mapbox.atlassian.net/browse/MAPSAND-2215

- Stale texture ID reuse in `BitmapWidgetRenderer` causing rendering
artifacts on Android Auto after surface recreation
- Adds `textures[0] = 0` in `release()` after `glDeleteTextures` to
prevent the old ID from being reused on re-attach
- New unit tests in `BitmapWidgetRendererTest.kt` verifying texture
reallocation and `needRender` state after release

## Problem

Customers report intermittent rendering artifacts and reversed/large
bitmaps on Android Auto when using `BitmapWidget` (e.g., speedometer).
Reported on multiple devices (OnePlus Nord 4, Samsung Galaxy S25, Pixel
7, Fairphone 5) all running Android 15, Maps SDK 11.6.0.

### Root Cause

`BitmapWidgetRenderer.release()` deletes the GL texture but does **not**
reset `textures[0] = 0`:

```kotlin
// BEFORE fix
override fun release() {
    lock.withLock {
        if (program != 0) {
            GLES20.glDeleteTextures(textures.size, textures, 0)
            // BUG: textures[0] still holds the old (now freed) ID!
            GLES20.glDeleteProgram(program)
            program = 0
        }
        needRender = false
    }
}
```

Meanwhile, `textureFromBitmapIfChanged()` only allocates a new texture
when `textures[0] == 0`:

```kotlin
if (textures[0] == 0) {       // skipped when textures[0] still holds stale ID
    GLES20.glGenTextures(1, textures, 0)
}
```

### What Happens on Android Auto

The widget renderer and native map renderer **share a texture
namespace** (via a shared EGL context), so texture IDs can collide
between them.

```mermaid
sequenceDiagram
    participant AA as Android Auto
    participant W as BitmapWidgetRenderer
    participant GPU as GPU Driver
    participant Map as Native Map Renderer

    Note over AA: Car head unit connected
    AA->>W: prepare() + render()
    W->>GPU: glGenTextures → ID 42
    W->>GPU: texImage2D(42, speedometer bitmap)
    Note over W: textures[0] = 42

    Note over AA: Surface destroyed (disconnect/reconnect)
    AA->>W: release()
    W->>GPU: glDeleteTextures(42)
    Note over W,GPU: ID 42 freed, but textures[0] still holds 42!

    Note over Map: Native renderer allocates textures...
    Map->>GPU: glGenTextures → ID 42 (recycled!)
    Map->>GPU: texImage2D(42, map tile bitmap)

    Note over AA: New surface created
    AA->>W: prepare() + render()
    Note over W: textures[0] = 42 ≠ 0, skip glGenTextures
    W->>GPU: glBindTexture(42)
    W->>GPU: texImage2D(42, speedometer bitmap)
    Note over GPU: OVERWRITES the map tile texture!

    Note over GPU: Frame composited: map tile shows<br/>speedometer bitmap = giant reversed image
```

The artifact appears as a **large reversed bitmap** because:
- **Large**: The speedometer bitmap overwrites a map tile texture, which
is drawn at map-tile scale (covering a large screen area)
- **Reversed**: Map tile UV coordinates differ from widget UV
coordinates, so the bitmap appears flipped

### Why Android Auto Specifically?

Android Auto has significantly more surface lifecycle churn than a
normal `MapView`:
- Connecting/disconnecting from the car head unit destroys and recreates
the surface
- Google's `SurfaceContainer` can call `onSurfaceAvailable` without a
prior `onSurfaceDestroyed` (acknowledged in `CarMapSurfaceOwner.kt`
referencing [Google issue
#235121269](https://issuetracker.google.com/issues/235121269))
- Each cycle triggers `release()` → re-`prepare()`, hitting this bug

A regular `MapView` in an Activity rarely goes through this cycle, which
is why the bug was only reported on Android Auto.

## Fix

One line — reset `textures[0]` after deletion so the next render
allocates a fresh ID:

```kotlin
GLES20.glDeleteTextures(textures.size, textures, 0)
textures[0] = 0  // ← ensures glGenTextures is called on next render
```

This matches the pattern already used correctly in
`MapboxWidgetRenderer.deleteFrameBufferWithTexture()`.

## Key Changes
- **`BitmapWidgetRenderer.kt`**: Add `textures[0] = 0` after
`glDeleteTextures` in `release()`
- **`BitmapWidgetRendererTest.kt`** (new): Robolectric tests — `release
then re-render allocates fresh texture` and `release sets needRender to
false`

## Test plan
- [x] Unit tests added and passing
- [x] Manual verification on Android Auto (surface destroy/recreate
cycle)

cc @mapbox/maps-android

cc @mapbox/sdk-platform

GitOrigin-RevId: 457b011818610755601dd0c12b5f1a9cf56d5e4b

Author: pengdev

CHANGELOG.md

@@ -14,6 +14,7 @@ Mapbox welcomes participation and contributions from everyone.
 * Fix NPE crash in `PointAnnotationClusterActivity` example when the remote GeoJSON endpoint returns a non-successful HTTP response.
 * Fix `MapSurface.setMaximumFps` not working correctly on secondary displays (e.g. Android Auto). Use `Context.getDisplay()` on API 30+ to get the actual display refresh rate instead of always using the primary display's rate.
 * Fix `PointAnnotationManager.iconImageBitmap` setter not registering the bitmap image with the style, causing group-level bitmap icons to be invisible.
+* Fix intermittent rendering artifacts (reversed/large bitmaps) on Android Auto caused by stale texture ID reuse in `BitmapWidgetRenderer` after surface recreation.
 
 # 11.19.0 February 24, 2026
 

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

@@ -235,6 +235,7 @@ internal class BitmapWidgetRenderer(
         GLES20.glDeleteShader(vertexShader)
         GLES20.glDeleteShader(fragmentShader)
         GLES20.glDeleteTextures(textures.size, textures, 0)
+        textures[0] = 0
         GLES20.glDeleteProgram(program)
         program = 0
       }

maps-sdk/src/test/java/com/mapbox/maps/renderer/widget/BitmapWidgetRendererTest.kt

@@ -0,0 +1,115 @@
+package com.mapbox.maps.renderer.widget
+
+import android.graphics.Bitmap
+import android.opengl.GLES20
+import android.opengl.GLUtils
+import com.mapbox.maps.logE
+import com.mapbox.maps.logI
+import com.mapbox.maps.logW
+import io.mockk.*
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+internal class BitmapWidgetRendererTest {
+
+  private lateinit var renderer: BitmapWidgetRenderer
+  private lateinit var bitmap: Bitmap
+  private var genTexturesCallCount = 0
+
+  @Before
+  fun setUp() {
+    genTexturesCallCount = 0
+
+    mockkStatic("com.mapbox.maps.MapboxLogger")
+    every { logE(any(), any()) } just Runs
+    every { logI(any(), any()) } just Runs
+    every { logW(any(), any()) } just Runs
+
+    mockkStatic("android.opengl.GLES20")
+    mockkStatic("android.opengl.GLUtils")
+
+    every { GLES20.glGetIntegerv(any(), any(), any()) } just Runs
+    every { GLES20.glCreateShader(any()) } returns 1
+    every { GLES20.glShaderSource(any(), any()) } just Runs
+    every { GLES20.glCompileShader(any()) } just Runs
+    every { GLES20.glGetShaderiv(any(), any(), any(), any()) } answers {
+      val params = arg<IntArray>(2)
+      params[0] = GLES20.GL_TRUE
+    }
+    every { GLES20.glCreateProgram() } returns 1
+    every { GLES20.glAttachShader(any(), any()) } just Runs
+    every { GLES20.glLinkProgram(any()) } just Runs
+    every { GLES20.glGetUniformLocation(any(), any()) } returns 1
+    every { GLES20.glGetAttribLocation(any(), any()) } returns 1
+    every { GLES20.glGetError() } returns GLES20.GL_NO_ERROR
+    every { GLES20.glGenTextures(any(), any<IntArray>(), any()) } answers {
+      val texArray = arg<IntArray>(1)
+      texArray[0] = 42 + genTexturesCallCount
+      genTexturesCallCount++
+    }
+    every { GLES20.glBindTexture(any(), any()) } just Runs
+    every { GLES20.glTexParameterf(any(), any(), any()) } just Runs
+    every { GLES20.glUniformMatrix4fv(any(), any(), any(), any()) } just Runs
+    every { GLES20.glUniform1i(any(), any()) } just Runs
+    every { GLES20.glEnableVertexAttribArray(any()) } just Runs
+    every { GLES20.glVertexAttribPointer(any(), any(), any(), any(), any(), any<java.nio.Buffer>()) } just Runs
+    every { GLES20.glDrawArrays(any(), any(), any()) } just Runs
+    every { GLES20.glDisableVertexAttribArray(any()) } just Runs
+    every { GLES20.glBindBuffer(any(), any()) } just Runs
+    every { GLES20.glUseProgram(any()) } just Runs
+    every { GLES20.glDeleteTextures(any(), any<IntArray>(), any()) } just Runs
+    every { GLES20.glDeleteProgram(any()) } just Runs
+    every { GLES20.glDeleteShader(any()) } just Runs
+    every { GLES20.glDetachShader(any(), any()) } just Runs
+    every { GLES20.glEnable(any()) } just Runs
+    every { GLES20.glBlendFunc(any(), any()) } just Runs
+    every { GLUtils.texImage2D(any(), any(), any<Bitmap>(), any()) } just Runs
+
+    bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    renderer = BitmapWidgetRenderer(bitmap, WidgetPosition { })
+  }
+
+  @After
+  fun tearDown() {
+    unmockkStatic("android.opengl.GLES20")
+    unmockkStatic("android.opengl.GLUtils")
+    unmockkStatic("com.mapbox.maps.MapboxLogger")
+  }
+
+  @Test
+  fun `release then re-render allocates fresh texture`() {
+    renderer.onSurfaceChanged(800, 600)
+    renderer.prepare()
+    renderer.render()
+
+    // First render should have called glGenTextures once
+    verify(exactly = 1) { GLES20.glGenTextures(1, any(), 0) }
+
+    // Release deletes the texture
+    renderer.release()
+    verify { GLES20.glDeleteTextures(any(), any<IntArray>(), any()) }
+
+    // Re-render after release: render() internally calls prepare() when program == 0,
+    // and should call glGenTextures again because textures[0] was reset to 0
+    renderer.onSurfaceChanged(800, 600)
+    renderer.render()
+
+    // glGenTextures should have been called a second time for the new texture
+    verify(exactly = 2) { GLES20.glGenTextures(1, any(), 0) }
+  }
+
+  @Test
+  fun `release sets needRender to false`() {
+    renderer.onSurfaceChanged(800, 600)
+    renderer.prepare()
+    assertTrue(renderer.needRender)
+    renderer.release()
+    assertFalse(renderer.needRender)
+  }
+}